]> Dogcows Code - chaz/openbox/blob - src/client.cc
rm a debug print
[chaz/openbox] / src / client.cc
1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2
3 #include "config.h"
4
5 #include "client.hh"
6 #include "frame.hh"
7 #include "screen.hh"
8 #include "openbox.hh"
9 #include "bindings.hh"
10 #include "otk/display.hh"
11 #include "otk/property.hh"
12
13 extern "C" {
14 #include <X11/Xlib.h>
15 #include <X11/Xutil.h>
16 #include <X11/Xatom.h>
17
18 #include "gettext.h"
19 #define _(str) gettext(str)
20 }
21
22 #include <climits>
23 #include <cassert>
24 #include <algorithm>
25
26 namespace ob {
27
28 Client::Client(int screen, Window window)
29 : otk::EventHandler(),
30 frame(0), _screen(screen), _window(window)
31 {
32 assert(screen >= 0);
33 assert(window);
34
35 ignore_unmaps = 0;
36
37 // update EVERYTHING the first time!!
38
39 // defaults
40 _wmstate = NormalState;
41 _focused = false;
42 _transient_for = 0;
43 _layer = Layer_Normal;
44 _urgent = false;
45 _positioned = false;
46 _disabled_decorations = 0;
47 _group = None;
48 _desktop = 0;
49
50 getArea();
51 getDesktop();
52 getState(); // do this before updateTransientFor! (for _modal)
53 getShaped();
54
55 updateTransientFor();
56 getMwmHints();
57 getType(); // this can change the mwmhints for special cases
58
59 updateProtocols();
60
61 getGravity(); // get the attribute gravity
62 updateNormalHints(); // this may override the attribute gravity
63
64 // got the type, the mwmhints, the protocols, and the normal hints (min/max
65 // sizes), so we're ready to set up
66 // the decorations/functions
67 setupDecorAndFunctions();
68
69 // also get the initial_state and set _iconic if we aren't "starting"
70 // when we're "starting" that means we should use whatever state was already
71 // on the window over the initial map state, because it was already mapped
72 updateWMHints(openbox->state() != Openbox::State_Starting);
73 updateTitle();
74 updateIconTitle();
75 updateClass();
76 updateStrut();
77
78 // this makes sure that these windows appear on all desktops
79 if (/*_type == Type_Dock ||*/ _type == Type_Desktop)
80 _desktop = 0xffffffff;
81
82 // set the desktop hint, to make sure that it always exists, and to reflect
83 // any changes we've made here
84 otk::Property::set(_window, otk::Property::atoms.net_wm_desktop,
85 otk::Property::atoms.cardinal, (unsigned)_desktop);
86
87 changeState();
88 }
89
90
91 Client::~Client()
92 {
93 // clean up childrens' references
94 while (!_transients.empty()) {
95 _transients.front()->_transient_for = 0;
96 _transients.pop_front();
97 }
98
99 // clean up parents reference to this
100 if (_transient_for)
101 _transient_for->_transients.remove(this); // remove from old parent
102
103 if (openbox->state() != Openbox::State_Exiting) {
104 // these values should not be persisted across a window unmapping/mapping
105 otk::Property::erase(_window, otk::Property::atoms.net_wm_desktop);
106 otk::Property::erase(_window, otk::Property::atoms.net_wm_state);
107 } else {
108 // if we're left in an iconic state, the client wont be mapped. this is
109 // bad, since we will no longer be managing the window on restart
110 if (_iconic)
111 XMapWindow(**otk::display, _window);
112 }
113 }
114
115
116 bool Client::validate() const
117 {
118 XSync(**otk::display, false); // get all events on the server
119
120 XEvent e;
121 if (XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &e) ||
122 XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &e)) {
123 XPutBackEvent(**otk::display, &e);
124 return false;
125 }
126
127 return true;
128 }
129
130
131 void Client::getGravity()
132 {
133 XWindowAttributes wattrib;
134 Status ret;
135
136 ret = XGetWindowAttributes(**otk::display, _window, &wattrib);
137 assert(ret != BadWindow);
138 _gravity = wattrib.win_gravity;
139 }
140
141
142 void Client::getDesktop()
143 {
144 // defaults to the current desktop
145 _desktop = openbox->screen(_screen)->desktop();
146
147 if (otk::Property::get(_window, otk::Property::atoms.net_wm_desktop,
148 otk::Property::atoms.cardinal,
149 (long unsigned*)&_desktop)) {
150 #ifdef DEBUG
151 // printf("Window requested desktop: %ld\n", _desktop);
152 #endif
153 }
154 }
155
156
157 void Client::getType()
158 {
159 _type = (WindowType) -1;
160
161 unsigned long *val;
162 unsigned long num = (unsigned) -1;
163 if (otk::Property::get(_window, otk::Property::atoms.net_wm_window_type,
164 otk::Property::atoms.atom, &num, &val)) {
165 // use the first value that we know about in the array
166 for (unsigned long i = 0; i < num; ++i) {
167 if (val[i] == otk::Property::atoms.net_wm_window_type_desktop)
168 _type = Type_Desktop;
169 else if (val[i] == otk::Property::atoms.net_wm_window_type_dock)
170 _type = Type_Dock;
171 else if (val[i] == otk::Property::atoms.net_wm_window_type_toolbar)
172 _type = Type_Toolbar;
173 else if (val[i] == otk::Property::atoms.net_wm_window_type_menu)
174 _type = Type_Menu;
175 else if (val[i] == otk::Property::atoms.net_wm_window_type_utility)
176 _type = Type_Utility;
177 else if (val[i] == otk::Property::atoms.net_wm_window_type_splash)
178 _type = Type_Splash;
179 else if (val[i] == otk::Property::atoms.net_wm_window_type_dialog)
180 _type = Type_Dialog;
181 else if (val[i] == otk::Property::atoms.net_wm_window_type_normal)
182 _type = Type_Normal;
183 else if (val[i] == otk::Property::atoms.kde_net_wm_window_type_override){
184 // prevent this window from getting any decor or functionality
185 _mwmhints.flags &= MwmFlag_Functions | MwmFlag_Decorations;
186 _mwmhints.decorations = 0;
187 _mwmhints.functions = 0;
188 }
189 if (_type != (WindowType) -1)
190 break; // grab the first known type
191 }
192 delete val;
193 }
194
195 if (_type == (WindowType) -1) {
196 /*
197 * the window type hint was not set, which means we either classify ourself
198 * as a normal window or a dialog, depending on if we are a transient.
199 */
200 if (_transient_for)
201 _type = Type_Dialog;
202 else
203 _type = Type_Normal;
204 }
205 }
206
207
208 void Client::setupDecorAndFunctions()
209 {
210 // start with everything (cept fullscreen)
211 _decorations = Decor_Titlebar | Decor_Handle | Decor_Border |
212 Decor_AllDesktops | Decor_Iconify | Decor_Maximize;
213 _functions = Func_Resize | Func_Move | Func_Iconify | Func_Maximize |
214 Func_Shade;
215 if (_delete_window) {
216 _decorations |= Decor_Close;
217 _functions |= Func_Close;
218 }
219
220 if (!(_min_size.width() < _max_size.width() ||
221 _min_size.height() < _max_size.height())) {
222 _decorations &= ~(Decor_Maximize | Decor_Handle);
223 _functions &= ~(Func_Resize | Func_Maximize);
224 }
225
226 switch (_type) {
227 case Type_Normal:
228 // normal windows retain all of the possible decorations and
229 // functionality, and are the only windows that you can fullscreen
230 _functions |= Func_Fullscreen;
231 break;
232
233 case Type_Dialog:
234 // dialogs cannot be maximized
235 _decorations &= ~Decor_Maximize;
236 _functions &= ~Func_Maximize;
237 break;
238
239 case Type_Menu:
240 case Type_Toolbar:
241 case Type_Utility:
242 // these windows get less functionality
243 _decorations &= ~(Decor_Iconify | Decor_Handle);
244 _functions &= ~(Func_Iconify | Func_Resize);
245 break;
246
247 case Type_Desktop:
248 case Type_Dock:
249 case Type_Splash:
250 // none of these windows are manipulated by the window manager
251 _decorations = 0;
252 _functions = 0;
253 break;
254 }
255
256 // Mwm Hints are applied subtractively to what has already been chosen for
257 // decor and functionality
258 if (_mwmhints.flags & MwmFlag_Decorations) {
259 if (! (_mwmhints.decorations & MwmDecor_All)) {
260 if (! (_mwmhints.decorations & MwmDecor_Border))
261 _decorations &= ~Decor_Border;
262 if (! (_mwmhints.decorations & MwmDecor_Handle))
263 _decorations &= ~Decor_Handle;
264 if (! (_mwmhints.decorations & MwmDecor_Title))
265 _decorations &= ~Decor_Titlebar;
266 if (! (_mwmhints.decorations & MwmDecor_Iconify))
267 _decorations &= ~Decor_Iconify;
268 if (! (_mwmhints.decorations & MwmDecor_Maximize))
269 _decorations &= ~Decor_Maximize;
270 }
271 }
272
273 if (_mwmhints.flags & MwmFlag_Functions) {
274 if (! (_mwmhints.functions & MwmFunc_All)) {
275 if (! (_mwmhints.functions & MwmFunc_Resize))
276 _functions &= ~Func_Resize;
277 if (! (_mwmhints.functions & MwmFunc_Move))
278 _functions &= ~Func_Move;
279 if (! (_mwmhints.functions & MwmFunc_Iconify))
280 _functions &= ~Func_Iconify;
281 if (! (_mwmhints.functions & MwmFunc_Maximize))
282 _functions &= ~Func_Maximize;
283 // dont let mwm hints kill the close button
284 //if (! (_mwmhints.functions & MwmFunc_Close))
285 // _functions &= ~Func_Close;
286 }
287 }
288
289 // can't maximize without moving/resizing
290 if (!((_functions & Func_Move) && (_functions & Func_Resize)))
291 _functions &= ~Func_Maximize;
292
293 // finally, user specified disabled decorations are applied to subtract
294 // decorations
295 if (_disabled_decorations & Decor_Titlebar)
296 _decorations &= ~Decor_Titlebar;
297 if (_disabled_decorations & Decor_Handle)
298 _decorations &= ~Decor_Handle;
299 if (_disabled_decorations & Decor_Border)
300 _decorations &= ~Decor_Border;
301 if (_disabled_decorations & Decor_Iconify)
302 _decorations &= ~Decor_Iconify;
303 if (_disabled_decorations & Decor_Maximize)
304 _decorations &= ~Decor_Maximize;
305 if (_disabled_decorations & Decor_AllDesktops)
306 _decorations &= ~Decor_AllDesktops;
307 if (_disabled_decorations & Decor_Close)
308 _decorations &= ~Decor_Close;
309
310 // if we don't have a titlebar, then we cannot shade!
311 if (!(_decorations & Decor_Titlebar))
312 _functions &= ~Func_Shade;
313
314 changeAllowedActions();
315
316 if (frame) {
317 frame->adjustSize(); // change the decors on the frame
318 frame->adjustPosition(); // with more/less decorations, we may need to be
319 // moved
320 remaximize(); // with new decor, the window's maximized size may change
321 }
322 }
323
324
325 void Client::getMwmHints()
326 {
327 unsigned long num = MwmHints::elements;
328 unsigned long *hints;
329
330 _mwmhints.flags = 0; // default to none
331
332 if (!otk::Property::get(_window, otk::Property::atoms.motif_wm_hints,
333 otk::Property::atoms.motif_wm_hints, &num,
334 (unsigned long **)&hints))
335 return;
336
337 if (num >= MwmHints::elements) {
338 // retrieved the hints
339 _mwmhints.flags = hints[0];
340 _mwmhints.functions = hints[1];
341 _mwmhints.decorations = hints[2];
342 }
343
344 delete [] hints;
345 }
346
347
348 void Client::getArea()
349 {
350 XWindowAttributes wattrib;
351 Status ret;
352
353 ret = XGetWindowAttributes(**otk::display, _window, &wattrib);
354 assert(ret != BadWindow);
355
356 _area = otk::Rect(wattrib.x, wattrib.y, wattrib.width, wattrib.height);
357 _border_width = wattrib.border_width;
358 }
359
360
361 void Client::getState()
362 {
363 _modal = _shaded = _max_horz = _max_vert = _fullscreen = _above = _below =
364 _iconic = _skip_taskbar = _skip_pager = false;
365
366 unsigned long *state;
367 unsigned long num = (unsigned) -1;
368
369 if (otk::Property::get(_window, otk::Property::atoms.net_wm_state,
370 otk::Property::atoms.atom, &num, &state)) {
371 for (unsigned long i = 0; i < num; ++i) {
372 if (state[i] == otk::Property::atoms.net_wm_state_modal)
373 _modal = true;
374 else if (state[i] == otk::Property::atoms.net_wm_state_shaded)
375 _shaded = true;
376 else if (state[i] == otk::Property::atoms.net_wm_state_hidden)
377 _iconic = true;
378 else if (state[i] == otk::Property::atoms.net_wm_state_skip_taskbar)
379 _skip_taskbar = true;
380 else if (state[i] == otk::Property::atoms.net_wm_state_skip_pager)
381 _skip_pager = true;
382 else if (state[i] == otk::Property::atoms.net_wm_state_fullscreen)
383 _fullscreen = true;
384 else if (state[i] == otk::Property::atoms.net_wm_state_maximized_vert)
385 _max_vert = true;
386 else if (state[i] == otk::Property::atoms.net_wm_state_maximized_horz)
387 _max_horz = true;
388 else if (state[i] == otk::Property::atoms.net_wm_state_above)
389 _above = true;
390 else if (state[i] == otk::Property::atoms.net_wm_state_below)
391 _below = true;
392 }
393
394 delete [] state;
395 }
396 }
397
398
399 void Client::getShaped()
400 {
401 _shaped = false;
402 #ifdef SHAPE
403 if (otk::display->shape()) {
404 int foo;
405 unsigned int ufoo;
406 int s;
407
408 XShapeSelectInput(**otk::display, _window, ShapeNotifyMask);
409
410 XShapeQueryExtents(**otk::display, _window, &s, &foo,
411 &foo, &ufoo, &ufoo, &foo, &foo, &foo, &ufoo, &ufoo);
412 _shaped = (s != 0);
413 }
414 #endif // SHAPE
415 }
416
417
418 void Client::calcLayer() {
419 StackLayer l;
420
421 if (_iconic) l = Layer_Icon;
422 else if (_fullscreen) l = Layer_Fullscreen;
423 else if (_type == Type_Desktop) l = Layer_Desktop;
424 else if (_type == Type_Dock) {
425 if (!_below) l = Layer_Top;
426 else l = Layer_Normal;
427 }
428 else if (_above) l = Layer_Above;
429 else if (_below) l = Layer_Below;
430 else l = Layer_Normal;
431
432 if (l != _layer) {
433 _layer = l;
434 if (frame) {
435 /*
436 if we don't have a frame, then we aren't mapped yet (and this would
437 SIGSEGV :)
438 */
439 openbox->screen(_screen)->raiseWindow(this);
440 }
441 }
442 }
443
444
445 void Client::updateProtocols()
446 {
447 Atom *proto;
448 int num_return = 0;
449
450 _focus_notify = false;
451 _delete_window = false;
452
453 if (XGetWMProtocols(**otk::display, _window, &proto, &num_return)) {
454 for (int i = 0; i < num_return; ++i) {
455 if (proto[i] == otk::Property::atoms.wm_delete_window) {
456 // this means we can request the window to close
457 _delete_window = true;
458 } else if (proto[i] == otk::Property::atoms.wm_take_focus)
459 // if this protocol is requested, then the window will be notified
460 // by the window manager whenever it receives focus
461 _focus_notify = true;
462 }
463 XFree(proto);
464 }
465 }
466
467
468 void Client::updateNormalHints()
469 {
470 XSizeHints size;
471 long ret;
472 int oldgravity = _gravity;
473
474 // defaults
475 _min_ratio = 0.0;
476 _max_ratio = 0.0;
477 _size_inc = otk::Size(1, 1);
478 _base_size = otk::Size(0, 0);
479 _min_size = otk::Size(0, 0);
480 _max_size = otk::Size(INT_MAX, INT_MAX);
481
482 // get the hints from the window
483 if (XGetWMNormalHints(**otk::display, _window, &size, &ret)) {
484 _positioned = (size.flags & (PPosition|USPosition));
485
486 if (size.flags & PWinGravity) {
487 _gravity = size.win_gravity;
488
489 // if the client has a frame, i.e. has already been mapped and is
490 // changing its gravity
491 if (frame && _gravity != oldgravity) {
492 // move our idea of the client's position based on its new gravity
493 int x = frame->area().x(), y = frame->area().y();
494 frame->frameGravity(x, y);
495 _area = otk::Rect(otk::Point(x, y), _area.size());
496 }
497 }
498
499 if (size.flags & PAspect) {
500 if (size.min_aspect.y) _min_ratio = size.min_aspect.x/size.min_aspect.y;
501 if (size.max_aspect.y) _max_ratio = size.max_aspect.x/size.max_aspect.y;
502 }
503
504 if (size.flags & PMinSize)
505 _min_size = otk::Size(size.min_width, size.min_height);
506
507 if (size.flags & PMaxSize)
508 _max_size = otk::Size(size.max_width, size.max_height);
509
510 if (size.flags & PBaseSize)
511 _base_size = otk::Size(size.base_width, size.base_height);
512
513 if (size.flags & PResizeInc)
514 _size_inc = otk::Size(size.width_inc, size.height_inc);
515 }
516 }
517
518
519 void Client::updateWMHints(bool initstate)
520 {
521 XWMHints *hints;
522
523 // assume a window takes input if it doesnt specify
524 _can_focus = true;
525 bool ur = false;
526
527 if ((hints = XGetWMHints(**otk::display, _window)) != NULL) {
528 if (hints->flags & InputHint)
529 _can_focus = hints->input;
530
531 // only do this when initstate is true!
532 if (initstate && (hints->flags & StateHint))
533 _iconic = hints->initial_state == IconicState;
534
535 if (hints->flags & XUrgencyHint)
536 ur = true;
537
538 if (hints->flags & WindowGroupHint) {
539 if (hints->window_group != _group) {
540 // XXX: remove from the old group if there was one
541 _group = hints->window_group;
542 // XXX: do stuff with the group
543 }
544 } else // no group!
545 _group = None;
546
547 XFree(hints);
548 }
549
550 if (ur != _urgent) {
551 _urgent = ur;
552 #ifdef DEBUG
553 printf("DEBUG: Urgent Hint for 0x%lx: %s\n",
554 (long)_window, _urgent ? "ON" : "OFF");
555 #endif
556 // fire the urgent callback if we're mapped, otherwise, wait until after
557 // we're mapped
558 if (frame)
559 fireUrgent();
560 }
561 }
562
563
564 void Client::updateTitle()
565 {
566 _title = "";
567
568 // try netwm
569 if (!otk::Property::get(_window, otk::Property::atoms.net_wm_name,
570 otk::Property::utf8, &_title)) {
571 // try old x stuff
572 otk::Property::get(_window, otk::Property::atoms.wm_name,
573 otk::Property::ascii, &_title);
574 }
575
576 if (_title.empty())
577 _title = _("Unnamed Window");
578
579 if (frame)
580 frame->adjustTitle();
581 }
582
583
584 void Client::updateIconTitle()
585 {
586 _icon_title = "";
587
588 // try netwm
589 if (!otk::Property::get(_window, otk::Property::atoms.net_wm_icon_name,
590 otk::Property::utf8, &_icon_title)) {
591 // try old x stuff
592 otk::Property::get(_window, otk::Property::atoms.wm_icon_name,
593 otk::Property::ascii, &_icon_title);
594 }
595
596 if (_title.empty())
597 _icon_title = _("Unnamed Window");
598 }
599
600
601 void Client::updateClass()
602 {
603 // set the defaults
604 _app_name = _app_class = _role = "";
605
606 otk::Property::StringVect v;
607 unsigned long num = 2;
608
609 if (otk::Property::get(_window, otk::Property::atoms.wm_class,
610 otk::Property::ascii, &num, &v)) {
611 if (num > 0) _app_name = v[0].c_str();
612 if (num > 1) _app_class = v[1].c_str();
613 }
614
615 v.clear();
616 num = 1;
617 if (otk::Property::get(_window, otk::Property::atoms.wm_window_role,
618 otk::Property::ascii, &num, &v)) {
619 if (num > 0) _role = v[0].c_str();
620 }
621 }
622
623
624 void Client::updateStrut()
625 {
626 unsigned long num = 4;
627 unsigned long *data;
628 if (!otk::Property::get(_window, otk::Property::atoms.net_wm_strut,
629 otk::Property::atoms.cardinal, &num, &data))
630 return;
631
632 if (num == 4) {
633 _strut.left = data[0];
634 _strut.right = data[1];
635 _strut.top = data[2];
636 _strut.bottom = data[3];
637
638 // updating here is pointless while we're being mapped cuz we're not in
639 // the screen's client list yet
640 if (frame)
641 openbox->screen(_screen)->updateStruts();
642 }
643
644 delete [] data;
645 }
646
647
648 void Client::updateTransientFor()
649 {
650 Window t = 0;
651 Client *c = 0;
652
653 if (XGetTransientForHint(**otk::display, _window, &t) &&
654 t != _window) { // cant be transient to itself!
655 c = openbox->findClient(t);
656 assert(c != this); // if this happens then we need to check for it
657
658 if (!c /*XXX: && _group*/) {
659 // not transient to a client, see if it is transient for a group
660 if (//t == _group->leader() ||
661 t == None ||
662 t == otk::display->screenInfo(_screen)->rootWindow()) {
663 // window is a transient for its group!
664 // XXX: for now this is treated as non-transient.
665 // this needs to be fixed!
666 }
667 }
668 }
669
670 // if anything has changed...
671 if (c != _transient_for) {
672 if (_transient_for)
673 _transient_for->_transients.remove(this); // remove from old parent
674 _transient_for = c;
675 if (_transient_for)
676 _transient_for->_transients.push_back(this); // add to new parent
677 }
678 }
679
680
681 void Client::propertyHandler(const XPropertyEvent &e)
682 {
683 otk::EventHandler::propertyHandler(e);
684
685 // validate cuz we query stuff off the client here
686 if (!validate()) return;
687
688 // compress changes to a single property into a single change
689 XEvent ce;
690 while (XCheckTypedEvent(**otk::display, e.type, &ce)) {
691 // XXX: it would be nice to compress ALL changes to a property, not just
692 // changes in a row without other props between.
693 if (ce.xproperty.atom != e.atom) {
694 XPutBackEvent(**otk::display, &ce);
695 break;
696 }
697 }
698
699 if (e.atom == XA_WM_NORMAL_HINTS) {
700 updateNormalHints();
701 setupDecorAndFunctions(); // normal hints can make a window non-resizable
702 } else if (e.atom == XA_WM_HINTS)
703 updateWMHints();
704 else if (e.atom == XA_WM_TRANSIENT_FOR) {
705 updateTransientFor();
706 getType();
707 calcLayer(); // type may have changed, so update the layer
708 setupDecorAndFunctions();
709 }
710 else if (e.atom == otk::Property::atoms.net_wm_name ||
711 e.atom == otk::Property::atoms.wm_name)
712 updateTitle();
713 else if (e.atom == otk::Property::atoms.net_wm_icon_name ||
714 e.atom == otk::Property::atoms.wm_icon_name)
715 updateIconTitle();
716 else if (e.atom == otk::Property::atoms.wm_class)
717 updateClass();
718 else if (e.atom == otk::Property::atoms.wm_protocols) {
719 updateProtocols();
720 setupDecorAndFunctions();
721 }
722 else if (e.atom == otk::Property::atoms.net_wm_strut)
723 updateStrut();
724 }
725
726
727 void Client::setWMState(long state)
728 {
729 if (state == _wmstate) return; // no change
730
731 switch (state) {
732 case IconicState:
733 iconify(true);
734 break;
735 case NormalState:
736 iconify(false);
737 break;
738 }
739 }
740
741
742 void Client::setDesktop(unsigned int target)
743 {
744 if (target == _desktop) return;
745
746 printf("Setting desktop %u\n", target);
747
748 if (!(target < openbox->screen(_screen)->numDesktops() ||
749 target == 0xffffffff))
750 return;
751
752 _desktop = target;
753
754 // set the desktop hint
755 otk::Property::set(_window, otk::Property::atoms.net_wm_desktop,
756 otk::Property::atoms.cardinal, _desktop);
757
758 // 'move' the window to the new desktop
759 showhide();
760
761 openbox->screen(_screen)->updateStruts();
762 }
763
764
765 void Client::showhide()
766 {
767 if (!_iconic &&
768 (_desktop == openbox->screen(_screen)->desktop() ||
769 _desktop == 0xffffffff))
770 frame->show();
771 else
772 frame->hide();
773 }
774
775
776 void Client::setState(StateAction action, long data1, long data2)
777 {
778 bool shadestate = _shaded;
779 bool fsstate = _fullscreen;
780 bool maxh = _max_horz;
781 bool maxv = _max_vert;
782
783 if (!(action == State_Add || action == State_Remove ||
784 action == State_Toggle))
785 return; // an invalid action was passed to the client message, ignore it
786
787 for (int i = 0; i < 2; ++i) {
788 Atom state = i == 0 ? data1 : data2;
789
790 if (! state) continue;
791
792 // if toggling, then pick whether we're adding or removing
793 if (action == State_Toggle) {
794 if (state == otk::Property::atoms.net_wm_state_modal)
795 action = _modal ? State_Remove : State_Add;
796 else if (state == otk::Property::atoms.net_wm_state_maximized_vert)
797 action = _max_vert ? State_Remove : State_Add;
798 else if (state == otk::Property::atoms.net_wm_state_maximized_horz)
799 action = _max_horz ? State_Remove : State_Add;
800 else if (state == otk::Property::atoms.net_wm_state_shaded)
801 action = _shaded ? State_Remove : State_Add;
802 else if (state == otk::Property::atoms.net_wm_state_skip_taskbar)
803 action = _skip_taskbar ? State_Remove : State_Add;
804 else if (state == otk::Property::atoms.net_wm_state_skip_pager)
805 action = _skip_pager ? State_Remove : State_Add;
806 else if (state == otk::Property::atoms.net_wm_state_fullscreen)
807 action = _fullscreen ? State_Remove : State_Add;
808 else if (state == otk::Property::atoms.net_wm_state_above)
809 action = _above ? State_Remove : State_Add;
810 else if (state == otk::Property::atoms.net_wm_state_below)
811 action = _below ? State_Remove : State_Add;
812 }
813
814 if (action == State_Add) {
815 if (state == otk::Property::atoms.net_wm_state_modal) {
816 if (_modal) continue;
817 _modal = true;
818 } else if (state == otk::Property::atoms.net_wm_state_maximized_vert) {
819 maxv = true;
820 } else if (state == otk::Property::atoms.net_wm_state_maximized_horz) {
821 if (_max_horz) continue;
822 maxh = true;
823 } else if (state == otk::Property::atoms.net_wm_state_shaded) {
824 shadestate = true;
825 } else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) {
826 _skip_taskbar = true;
827 } else if (state == otk::Property::atoms.net_wm_state_skip_pager) {
828 _skip_pager = true;
829 } else if (state == otk::Property::atoms.net_wm_state_fullscreen) {
830 fsstate = true;
831 } else if (state == otk::Property::atoms.net_wm_state_above) {
832 if (_above) continue;
833 _above = true;
834 } else if (state == otk::Property::atoms.net_wm_state_below) {
835 if (_below) continue;
836 _below = true;
837 }
838
839 } else { // action == State_Remove
840 if (state == otk::Property::atoms.net_wm_state_modal) {
841 if (!_modal) continue;
842 _modal = false;
843 } else if (state == otk::Property::atoms.net_wm_state_maximized_vert) {
844 maxv = false;
845 } else if (state == otk::Property::atoms.net_wm_state_maximized_horz) {
846 maxh = false;
847 } else if (state == otk::Property::atoms.net_wm_state_shaded) {
848 shadestate = false;
849 } else if (state == otk::Property::atoms.net_wm_state_skip_taskbar) {
850 _skip_taskbar = false;
851 } else if (state == otk::Property::atoms.net_wm_state_skip_pager) {
852 _skip_pager = false;
853 } else if (state == otk::Property::atoms.net_wm_state_fullscreen) {
854 fsstate = false;
855 } else if (state == otk::Property::atoms.net_wm_state_above) {
856 if (!_above) continue;
857 _above = false;
858 } else if (state == otk::Property::atoms.net_wm_state_below) {
859 if (!_below) continue;
860 _below = false;
861 }
862 }
863 }
864 if (maxh != _max_horz || maxv != _max_vert) {
865 if (maxh != _max_horz && maxv != _max_vert) { // toggling both
866 if (maxh == maxv) { // both going the same way
867 maximize(maxh, 0, true);
868 } else {
869 maximize(maxh, 1, true);
870 maximize(maxv, 2, true);
871 }
872 } else { // toggling one
873 if (maxh != _max_horz)
874 maximize(maxh, 1, true);
875 else
876 maximize(maxv, 2, true);
877 }
878 }
879 // change fullscreen state before shading, as it will affect if the window
880 // can shade or not
881 if (fsstate != _fullscreen)
882 fullscreen(fsstate, true);
883 if (shadestate != _shaded)
884 shade(shadestate);
885 calcLayer();
886 changeState(); // change the hint to relect these changes
887 }
888
889
890 void Client::toggleClientBorder(bool addborder)
891 {
892 // adjust our idea of where the client is, based on its border. When the
893 // border is removed, the client should now be considered to be in a
894 // different position.
895 // when re-adding the border to the client, the same operation needs to be
896 // reversed.
897 int oldx = _area.x(), oldy = _area.y();
898 int x = oldx, y = oldy;
899 switch(_gravity) {
900 default:
901 case NorthWestGravity:
902 case WestGravity:
903 case SouthWestGravity:
904 break;
905 case NorthEastGravity:
906 case EastGravity:
907 case SouthEastGravity:
908 if (addborder) x -= _border_width * 2;
909 else x += _border_width * 2;
910 break;
911 case NorthGravity:
912 case SouthGravity:
913 case CenterGravity:
914 case ForgetGravity:
915 case StaticGravity:
916 if (addborder) x -= _border_width;
917 else x += _border_width;
918 break;
919 }
920 switch(_gravity) {
921 default:
922 case NorthWestGravity:
923 case NorthGravity:
924 case NorthEastGravity:
925 break;
926 case SouthWestGravity:
927 case SouthGravity:
928 case SouthEastGravity:
929 if (addborder) y -= _border_width * 2;
930 else y += _border_width * 2;
931 break;
932 case WestGravity:
933 case EastGravity:
934 case CenterGravity:
935 case ForgetGravity:
936 case StaticGravity:
937 if (addborder) y -= _border_width;
938 else y += _border_width;
939 break;
940 }
941 _area = otk::Rect(otk::Point(x, y), _area.size());
942
943 if (addborder) {
944 XSetWindowBorderWidth(**otk::display, _window, _border_width);
945
946 // move the client so it is back it the right spot _with_ its border!
947 if (x != oldx || y != oldy)
948 XMoveWindow(**otk::display, _window, x, y);
949 } else
950 XSetWindowBorderWidth(**otk::display, _window, 0);
951 }
952
953
954 void Client::clientMessageHandler(const XClientMessageEvent &e)
955 {
956 otk::EventHandler::clientMessageHandler(e);
957
958 // validate cuz we query stuff off the client here
959 if (!validate()) return;
960
961 if (e.format != 32) return;
962
963 if (e.message_type == otk::Property::atoms.wm_change_state) {
964 // compress changes into a single change
965 bool compress = false;
966 XEvent ce;
967 while (XCheckTypedEvent(**otk::display, e.type, &ce)) {
968 // XXX: it would be nice to compress ALL messages of a type, not just
969 // messages in a row without other message types between.
970 if (ce.xclient.message_type != e.message_type) {
971 XPutBackEvent(**otk::display, &ce);
972 break;
973 }
974 compress = true;
975 }
976 if (compress)
977 setWMState(ce.xclient.data.l[0]); // use the found event
978 else
979 setWMState(e.data.l[0]); // use the original event
980 } else if (e.message_type == otk::Property::atoms.net_wm_desktop) {
981 // compress changes into a single change
982 bool compress = false;
983 XEvent ce;
984 while (XCheckTypedEvent(**otk::display, e.type, &ce)) {
985 // XXX: it would be nice to compress ALL messages of a type, not just
986 // messages in a row without other message types between.
987 if (ce.xclient.message_type != e.message_type) {
988 XPutBackEvent(**otk::display, &ce);
989 break;
990 }
991 compress = true;
992 }
993 if (compress)
994 setDesktop(e.data.l[0]); // use the found event
995 else
996 setDesktop(e.data.l[0]); // use the original event
997 } else if (e.message_type == otk::Property::atoms.net_wm_state) {
998 // can't compress these
999 #ifdef DEBUG
1000 printf("net_wm_state %s %ld %ld for 0x%lx\n",
1001 (e.data.l[0] == 0 ? "Remove" : e.data.l[0] == 1 ? "Add" :
1002 e.data.l[0] == 2 ? "Toggle" : "INVALID"),
1003 e.data.l[1], e.data.l[2], _window);
1004 #endif
1005 setState((StateAction)e.data.l[0], e.data.l[1], e.data.l[2]);
1006 } else if (e.message_type == otk::Property::atoms.net_close_window) {
1007 #ifdef DEBUG
1008 printf("net_close_window for 0x%lx\n", _window);
1009 #endif
1010 close();
1011 } else if (e.message_type == otk::Property::atoms.net_active_window) {
1012 #ifdef DEBUG
1013 printf("net_active_window for 0x%lx\n", _window);
1014 #endif
1015 if (_iconic)
1016 iconify(false);
1017 if (_shaded)
1018 shade(false);
1019 focus();
1020 openbox->screen(_screen)->raiseWindow(this);
1021 } else if (e.message_type == otk::Property::atoms.openbox_active_window) {
1022 if (_iconic)
1023 iconify(false);
1024 if (e.data.l[0] && _shaded)
1025 shade(false);
1026 focus();
1027 if (e.data.l[1])
1028 openbox->screen(_screen)->raiseWindow(this);
1029 }
1030 }
1031
1032
1033 #if defined(SHAPE)
1034 void Client::shapeHandler(const XShapeEvent &e)
1035 {
1036 otk::EventHandler::shapeHandler(e);
1037
1038 if (e.kind == ShapeBounding) {
1039 _shaped = e.shaped;
1040 frame->adjustShape();
1041 }
1042 }
1043 #endif
1044
1045
1046 void Client::resize(Corner anchor, int w, int h)
1047 {
1048 if (!(_functions & Func_Resize)) return;
1049 internal_resize(anchor, w, h);
1050 }
1051
1052
1053 void Client::internal_resize(Corner anchor, int w, int h,
1054 bool user, int x, int y)
1055 {
1056 w -= _base_size.width();
1057 h -= _base_size.height();
1058
1059 if (user) {
1060 // for interactive resizing. have to move half an increment in each
1061 // direction.
1062 int mw = w % _size_inc.width(); // how far we are towards the next size inc
1063 int mh = h % _size_inc.height();
1064 int aw = _size_inc.width() / 2; // amount to add
1065 int ah = _size_inc.height() / 2;
1066 // don't let us move into a new size increment
1067 if (mw + aw >= _size_inc.width()) aw = _size_inc.width() - mw - 1;
1068 if (mh + ah >= _size_inc.height()) ah = _size_inc.height() - mh - 1;
1069 w += aw;
1070 h += ah;
1071
1072 // if this is a user-requested resize, then check against min/max sizes
1073 // and aspect ratios
1074
1075 // smaller than min size or bigger than max size?
1076 if (w > _max_size.width()) w = _max_size.width();
1077 if (w < _min_size.width()) w = _min_size.width();
1078 if (h > _max_size.height()) h = _max_size.height();
1079 if (h < _min_size.height()) h = _min_size.height();
1080
1081 // adjust the height ot match the width for the aspect ratios
1082 if (_min_ratio)
1083 if (h * _min_ratio > w) h = static_cast<int>(w / _min_ratio);
1084 if (_max_ratio)
1085 if (h * _max_ratio < w) h = static_cast<int>(w / _max_ratio);
1086 }
1087
1088 // keep to the increments
1089 w /= _size_inc.width();
1090 h /= _size_inc.height();
1091
1092 // you cannot resize to nothing
1093 if (w < 1) w = 1;
1094 if (h < 1) h = 1;
1095
1096 // store the logical size
1097 _logical_size = otk::Size(w, h);
1098
1099 w *= _size_inc.width();
1100 h *= _size_inc.height();
1101
1102 w += _base_size.width();
1103 h += _base_size.height();
1104
1105 if (x == INT_MIN || y == INT_MIN) {
1106 x = _area.x();
1107 y = _area.y();
1108 switch (anchor) {
1109 case TopLeft:
1110 break;
1111 case TopRight:
1112 x -= w - _area.width();
1113 break;
1114 case BottomLeft:
1115 y -= h - _area.height();
1116 break;
1117 case BottomRight:
1118 x -= w - _area.width();
1119 y -= h - _area.height();
1120 break;
1121 }
1122 }
1123
1124 _area = otk::Rect(_area.position(), otk::Size(w, h));
1125
1126 XResizeWindow(**otk::display, _window, w, h);
1127
1128 // resize the frame to match the request
1129 frame->adjustSize();
1130 internal_move(x, y);
1131 }
1132
1133
1134 void Client::move(int x, int y)
1135 {
1136 if (!(_functions & Func_Move)) return;
1137 frame->frameGravity(x, y); // get the client's position based on x,y for the
1138 // frame
1139 internal_move(x, y);
1140 }
1141
1142
1143 void Client::internal_move(int x, int y)
1144 {
1145 _area = otk::Rect(otk::Point(x, y), _area.size());
1146
1147 // move the frame to be in the requested position
1148 if (frame) { // this can be called while mapping, before frame exists
1149 frame->adjustPosition();
1150
1151 // send synthetic configure notify (we don't need to if we aren't mapped
1152 // yet)
1153 XEvent event;
1154 event.type = ConfigureNotify;
1155 event.xconfigure.display = **otk::display;
1156 event.xconfigure.event = _window;
1157 event.xconfigure.window = _window;
1158
1159 // root window coords with border in mind
1160 event.xconfigure.x = x - _border_width + frame->size().left;
1161 event.xconfigure.y = y - _border_width + frame->size().top;
1162
1163 event.xconfigure.width = _area.width();
1164 event.xconfigure.height = _area.height();
1165 event.xconfigure.border_width = _border_width;
1166 event.xconfigure.above = frame->plate();
1167 event.xconfigure.override_redirect = False;
1168 XSendEvent(event.xconfigure.display, event.xconfigure.window, False,
1169 StructureNotifyMask, &event);
1170 #if 0//def DEBUG
1171 printf("Sent synthetic ConfigureNotify %d,%d %d,%d to 0x%lx\n",
1172 event.xconfigure.x, event.xconfigure.y, event.xconfigure.width,
1173 event.xconfigure.height, event.xconfigure.window);
1174 #endif
1175 }
1176 }
1177
1178
1179 void Client::close()
1180 {
1181 XEvent ce;
1182
1183 if (!(_functions & Func_Close)) return;
1184
1185 // XXX: itd be cool to do timeouts and shit here for killing the client's
1186 // process off
1187 // like... if the window is around after 5 seconds, then the close button
1188 // turns a nice red, and if this function is called again, the client is
1189 // explicitly killed.
1190
1191 ce.xclient.type = ClientMessage;
1192 ce.xclient.message_type = otk::Property::atoms.wm_protocols;
1193 ce.xclient.display = **otk::display;
1194 ce.xclient.window = _window;
1195 ce.xclient.format = 32;
1196 ce.xclient.data.l[0] = otk::Property::atoms.wm_delete_window;
1197 ce.xclient.data.l[1] = CurrentTime;
1198 ce.xclient.data.l[2] = 0l;
1199 ce.xclient.data.l[3] = 0l;
1200 ce.xclient.data.l[4] = 0l;
1201 XSendEvent(**otk::display, _window, false, NoEventMask, &ce);
1202 }
1203
1204
1205 void Client::changeState()
1206 {
1207 unsigned long state[2];
1208 state[0] = _wmstate;
1209 state[1] = None;
1210 otk::Property::set(_window, otk::Property::atoms.wm_state,
1211 otk::Property::atoms.wm_state, state, 2);
1212
1213 Atom netstate[10];
1214 int num = 0;
1215 if (_modal)
1216 netstate[num++] = otk::Property::atoms.net_wm_state_modal;
1217 if (_shaded)
1218 netstate[num++] = otk::Property::atoms.net_wm_state_shaded;
1219 if (_iconic)
1220 netstate[num++] = otk::Property::atoms.net_wm_state_hidden;
1221 if (_skip_taskbar)
1222 netstate[num++] = otk::Property::atoms.net_wm_state_skip_taskbar;
1223 if (_skip_pager)
1224 netstate[num++] = otk::Property::atoms.net_wm_state_skip_pager;
1225 if (_fullscreen)
1226 netstate[num++] = otk::Property::atoms.net_wm_state_fullscreen;
1227 if (_max_vert)
1228 netstate[num++] = otk::Property::atoms.net_wm_state_maximized_vert;
1229 if (_max_horz)
1230 netstate[num++] = otk::Property::atoms.net_wm_state_maximized_horz;
1231 if (_above)
1232 netstate[num++] = otk::Property::atoms.net_wm_state_above;
1233 if (_below)
1234 netstate[num++] = otk::Property::atoms.net_wm_state_below;
1235 otk::Property::set(_window, otk::Property::atoms.net_wm_state,
1236 otk::Property::atoms.atom, netstate, num);
1237
1238 calcLayer();
1239
1240 if (frame)
1241 frame->adjustState();
1242 }
1243
1244
1245 void Client::changeAllowedActions(void)
1246 {
1247 Atom actions[9];
1248 int num = 0;
1249
1250 actions[num++] = otk::Property::atoms.net_wm_action_change_desktop;
1251
1252 if (_functions & Func_Shade)
1253 actions[num++] = otk::Property::atoms.net_wm_action_shade;
1254 if (_functions & Func_Close)
1255 actions[num++] = otk::Property::atoms.net_wm_action_close;
1256 if (_functions & Func_Move)
1257 actions[num++] = otk::Property::atoms.net_wm_action_move;
1258 if (_functions & Func_Iconify)
1259 actions[num++] = otk::Property::atoms.net_wm_action_minimize;
1260 if (_functions & Func_Resize)
1261 actions[num++] = otk::Property::atoms.net_wm_action_resize;
1262 if (_functions & Func_Fullscreen)
1263 actions[num++] = otk::Property::atoms.net_wm_action_fullscreen;
1264 if (_functions & Func_Maximize) {
1265 actions[num++] = otk::Property::atoms.net_wm_action_maximize_horz;
1266 actions[num++] = otk::Property::atoms.net_wm_action_maximize_vert;
1267 }
1268
1269 otk::Property::set(_window, otk::Property::atoms.net_wm_allowed_actions,
1270 otk::Property::atoms.atom, actions, num);
1271
1272 // make sure the window isn't breaking any rules now
1273
1274 if (!(_functions & Func_Shade) && _shaded)
1275 if (frame) shade(false);
1276 else _shaded = false;
1277 if (!(_functions & Func_Iconify) && _iconic)
1278 if (frame) setDesktop(openbox->screen(_screen)->desktop());
1279 else _iconic = false;
1280 if (!(_functions & Func_Fullscreen) && _fullscreen)
1281 if (frame) fullscreen(false);
1282 else _fullscreen = false;
1283 if (!(_functions & Func_Maximize) && (_max_horz || _max_vert))
1284 if (frame) maximize(false, 0);
1285 else _max_vert = _max_horz = false;
1286 }
1287
1288
1289 void Client::remaximize()
1290 {
1291 int dir;
1292 if (_max_horz && _max_vert)
1293 dir = 0;
1294 else if (_max_horz)
1295 dir = 1;
1296 else if (_max_vert)
1297 dir = 2;
1298 else
1299 return; // not maximized
1300 _max_horz = _max_vert = false;
1301 maximize(true, dir, false);
1302 }
1303
1304
1305 void Client::applyStartupState()
1306 {
1307 // these are in a carefully crafted order..
1308
1309 if (_iconic) {
1310 _iconic = false;
1311 iconify(true);
1312 }
1313 if (_fullscreen) {
1314 _fullscreen = false;
1315 fullscreen(true, false);
1316 }
1317 if (_shaded) {
1318 _shaded = false;
1319 shade(true);
1320 }
1321 if (_urgent)
1322 fireUrgent();
1323
1324 if (_max_vert && _max_horz) {
1325 _max_vert = _max_horz = false;
1326 maximize(true, 0, false);
1327 } else if (_max_vert) {
1328 _max_vert = false;
1329 maximize(true, 2, false);
1330 } else if (_max_horz) {
1331 _max_horz = false;
1332 maximize(true, 1, false);
1333 }
1334
1335 if (_skip_taskbar); // nothing to do for this
1336 if (_skip_pager); // nothing to do for this
1337 if (_modal); // nothing to do for this
1338 if (_above); // nothing to do for this
1339 if (_below); // nothing to do for this
1340 }
1341
1342
1343 void Client::fireUrgent()
1344 {
1345 // call the python UrgentWindow callbacks
1346 EventData data(_screen, this, EventAction::UrgentWindow, 0);
1347 openbox->bindings()->fireEvent(&data);
1348 }
1349
1350
1351 void Client::shade(bool shade)
1352 {
1353 if (!(_functions & Func_Shade) || // can't
1354 _shaded == shade) return; // already done
1355
1356 // when we're iconic, don't change the wmstate
1357 if (!_iconic)
1358 _wmstate = shade ? IconicState : NormalState;
1359 _shaded = shade;
1360 changeState();
1361 frame->adjustSize();
1362 }
1363
1364
1365 void Client::maximize(bool max, int dir, bool savearea)
1366 {
1367 assert(dir == 0 || dir == 1 || dir == 2);
1368 if (!(_functions & Func_Maximize)) return; // can't
1369
1370 // check if already done
1371 if (max) {
1372 if (dir == 0 && _max_horz && _max_vert) return;
1373 if (dir == 1 && _max_horz) return;
1374 if (dir == 2 && _max_vert) return;
1375 } else {
1376 if (dir == 0 && !_max_horz && !_max_vert) return;
1377 if (dir == 1 && !_max_horz) return;
1378 if (dir == 2 && !_max_vert) return;
1379 }
1380
1381 const otk::Rect &a = openbox->screen(_screen)->area(_desktop);
1382 int x = frame->area().x(), y = frame->area().y(),
1383 w = _area.width(), h = _area.height();
1384
1385 if (max) {
1386 if (savearea) {
1387 long dimensions[4];
1388 long *readdim;
1389 unsigned long n = 4;
1390
1391 dimensions[0] = x;
1392 dimensions[1] = y;
1393 dimensions[2] = w;
1394 dimensions[3] = h;
1395
1396 // get the property off the window and use it for the dimentions we are
1397 // already maxed on
1398 if (otk::Property::get(_window, otk::Property::atoms.openbox_premax,
1399 otk::Property::atoms.cardinal, &n,
1400 (long unsigned**) &readdim)) {
1401 if (n >= 4) {
1402 if (_max_horz) {
1403 dimensions[0] = readdim[0];
1404 dimensions[2] = readdim[2];
1405 }
1406 if (_max_vert) {
1407 dimensions[1] = readdim[1];
1408 dimensions[3] = readdim[3];
1409 }
1410 }
1411 delete readdim;
1412 }
1413
1414 otk::Property::set(_window, otk::Property::atoms.openbox_premax,
1415 otk::Property::atoms.cardinal,
1416 (long unsigned*)dimensions, 4);
1417 }
1418 if (dir == 0 || dir == 1) { // horz
1419 x = a.x();
1420 w = a.width();
1421 }
1422 if (dir == 0 || dir == 2) { // vert
1423 y = a.y();
1424 h = a.height() - frame->size().top - frame->size().bottom;
1425 }
1426 } else {
1427 long *dimensions;
1428 long unsigned n = 4;
1429
1430 if (otk::Property::get(_window, otk::Property::atoms.openbox_premax,
1431 otk::Property::atoms.cardinal, &n,
1432 (long unsigned**) &dimensions)) {
1433 if (n >= 4) {
1434 if (dir == 0 || dir == 1) { // horz
1435 x = (signed int)dimensions[0];
1436 w = (signed int)dimensions[2];
1437 }
1438 if (dir == 0 || dir == 2) { // vert
1439 y = (signed int)dimensions[1];
1440 h = (signed int)dimensions[3];
1441 }
1442 }
1443 delete dimensions;
1444 } else {
1445 // pick some fallbacks...
1446 if (dir == 0 || dir == 1) { // horz
1447 x = a.x() + a.width() / 4;
1448 w = a.width() / 2;
1449 }
1450 if (dir == 0 || dir == 2) { // vert
1451 y = a.y() + a.height() / 4;
1452 h = a.height() / 2;
1453 }
1454 }
1455 }
1456
1457 if (dir == 0 || dir == 1) // horz
1458 _max_horz = max;
1459 if (dir == 0 || dir == 2) // vert
1460 _max_vert = max;
1461
1462 if (!_max_horz && !_max_vert)
1463 otk::Property::erase(_window, otk::Property::atoms.openbox_premax);
1464
1465 changeState(); // change the state hints on the client
1466
1467 frame->frameGravity(x, y); // figure out where the client should be going
1468 internal_resize(TopLeft, w, h, true, x, y);
1469 }
1470
1471
1472 void Client::fullscreen(bool fs, bool savearea)
1473 {
1474 static FunctionFlags saved_func;
1475 static DecorationFlags saved_decor;
1476
1477 if (!(_functions & Func_Fullscreen) || // can't
1478 _fullscreen == fs) return; // already done
1479
1480 _fullscreen = fs;
1481 changeState(); // change the state hints on the client
1482
1483 int x = _area.x(), y = _area.y(), w = _area.width(), h = _area.height();
1484
1485 if (fs) {
1486 // save the functions and remove them
1487 saved_func = _functions;
1488 _functions = _functions & (Func_Close | Func_Fullscreen | Func_Iconify);
1489 // save the decorations and remove them
1490 saved_decor = _decorations;
1491 _decorations = 0;
1492 if (savearea) {
1493 long dimensions[4];
1494 dimensions[0] = _area.x();
1495 dimensions[1] = _area.y();
1496 dimensions[2] = _area.width();
1497 dimensions[3] = _area.height();
1498 otk::Property::set(_window, otk::Property::atoms.openbox_premax,
1499 otk::Property::atoms.cardinal,
1500 (long unsigned*)dimensions, 4);
1501 }
1502 const otk::ScreenInfo *info = otk::display->screenInfo(_screen);
1503 x = 0;
1504 y = 0;
1505 w = info->size().width();
1506 h = info->size().height();
1507 } else {
1508 _functions = saved_func;
1509 _decorations = saved_decor;
1510
1511 long *dimensions;
1512 long unsigned n = 4;
1513
1514 if (otk::Property::get(_window, otk::Property::atoms.openbox_premax,
1515 otk::Property::atoms.cardinal, &n,
1516 (long unsigned**) &dimensions)) {
1517 if (n >= 4) {
1518 x = dimensions[0];
1519 y = dimensions[1];
1520 w = dimensions[2];
1521 h = dimensions[3];
1522 }
1523 delete dimensions;
1524 } else {
1525 // pick some fallbacks...
1526 const otk::Rect &a = openbox->screen(_screen)->area(_desktop);
1527 x = a.x() + a.width() / 4;
1528 y = a.y() + a.height() / 4;
1529 w = a.width() / 2;
1530 h = a.height() / 2;
1531 }
1532 }
1533
1534 changeAllowedActions(); // based on the new _functions
1535
1536 // when fullscreening, don't obey things like increments, fill the screen
1537 internal_resize(TopLeft, w, h, !fs, x, y);
1538
1539 // raise (back) into our stacking layer
1540 openbox->screen(_screen)->raiseWindow(this);
1541
1542 // try focus us when we go into fullscreen mode
1543 if (fs) focus();
1544 }
1545
1546
1547 void Client::iconify(bool iconic, bool curdesk)
1548 {
1549 if (_iconic == iconic) return; // nothing to do
1550
1551 _iconic = iconic;
1552
1553 if (_iconic) {
1554 _wmstate = IconicState;
1555 ignore_unmaps++;
1556 // we unmap the client itself so that we can get MapRequest events, and
1557 // because the ICCCM tells us to!
1558 XUnmapWindow(**otk::display, _window);
1559 } else {
1560 if (curdesk)
1561 setDesktop(openbox->screen(_screen)->desktop());
1562 _wmstate = NormalState;
1563 XMapWindow(**otk::display, _window);
1564 }
1565 changeState();
1566
1567 showhide();
1568
1569 openbox->screen(_screen)->updateStruts();
1570 }
1571
1572
1573 void Client::disableDecorations(DecorationFlags flags)
1574 {
1575 _disabled_decorations = flags;
1576 setupDecorAndFunctions();
1577 }
1578
1579
1580 void Client::installColormap(bool install) const
1581 {
1582 XWindowAttributes wa;
1583 if (XGetWindowAttributes(**otk::display, _window, &wa)) {
1584 if (install)
1585 XInstallColormap(**otk::display, wa.colormap);
1586 else
1587 XUninstallColormap(**otk::display, wa.colormap);
1588 }
1589 }
1590
1591
1592 // recursively searches the client 'tree' for a modal client, always skips the
1593 // topmost node (the window you're starting with)
1594 Client *Client::searchModalTree(Client *node, Client *skip)
1595 {
1596 List::const_iterator it, end = node->_transients.end();
1597 Client *ret;
1598
1599 for (it = node->_transients.begin(); it != end; ++it) {
1600 if (*it == skip) continue; // circular?
1601 if ((ret = searchModalTree(*it, skip))) return ret; // got one
1602 if ((*it)->_modal) return *it; // got one
1603 }
1604 return 0;
1605 }
1606
1607 Client *Client::findModalChild()
1608 {
1609 return searchModalTree(this, this);
1610 }
1611
1612
1613 bool Client::focus()
1614 {
1615 // if we have a modal child, then focus it, not us
1616 Client *c = findModalChild();
1617 if (c) return c->focus();
1618
1619 // won't try focus if the client doesn't want it, or if the window isn't
1620 // visible on the screen
1621 if (!(frame->visible() && (_can_focus || _focus_notify))) return false;
1622
1623 if (_focused) return true;
1624
1625 // do a check to see if the window has already been unmapped or destroyed
1626 // do this intelligently while watching out for unmaps we've generated
1627 // (ignore_unmaps > 0)
1628 XEvent ev;
1629 if (XCheckTypedWindowEvent(**otk::display, _window, DestroyNotify, &ev)) {
1630 XPutBackEvent(**otk::display, &ev);
1631 return false;
1632 }
1633 while (XCheckTypedWindowEvent(**otk::display, _window, UnmapNotify, &ev)) {
1634 if (ignore_unmaps) {
1635 unmapHandler(ev.xunmap);
1636 } else {
1637 XPutBackEvent(**otk::display, &ev);
1638 return false;
1639 }
1640 }
1641
1642 if (_can_focus)
1643 XSetInputFocus(**otk::display, _window,
1644 RevertToNone, CurrentTime);
1645
1646 if (_focus_notify) {
1647 XEvent ce;
1648 ce.xclient.type = ClientMessage;
1649 ce.xclient.message_type = otk::Property::atoms.wm_protocols;
1650 ce.xclient.display = **otk::display;
1651 ce.xclient.window = _window;
1652 ce.xclient.format = 32;
1653 ce.xclient.data.l[0] = otk::Property::atoms.wm_take_focus;
1654 ce.xclient.data.l[1] = openbox->lastTime();
1655 ce.xclient.data.l[2] = 0l;
1656 ce.xclient.data.l[3] = 0l;
1657 ce.xclient.data.l[4] = 0l;
1658 XSendEvent(**otk::display, _window, False, NoEventMask, &ce);
1659 }
1660
1661 XSync(**otk::display, False);
1662 return true;
1663 }
1664
1665
1666 void Client::unfocus() const
1667 {
1668 if (!_focused) return;
1669
1670 assert(openbox->focusedClient() == this);
1671 openbox->setFocusedClient(0);
1672 }
1673
1674
1675 void Client::focusHandler(const XFocusChangeEvent &e)
1676 {
1677 #ifdef DEBUG
1678 // printf("FocusIn for 0x%lx\n", e.window);
1679 #endif // DEBUG
1680
1681 otk::EventHandler::focusHandler(e);
1682
1683 _focused = true;
1684 frame->adjustFocus();
1685
1686 openbox->setFocusedClient(this);
1687 }
1688
1689
1690 void Client::unfocusHandler(const XFocusChangeEvent &e)
1691 {
1692 #ifdef DEBUG
1693 // printf("FocusOut for 0x%lx\n", e.window);
1694 #endif // DEBUG
1695
1696 otk::EventHandler::unfocusHandler(e);
1697
1698 _focused = false;
1699 frame->adjustFocus();
1700
1701 if (openbox->focusedClient() == this)
1702 openbox->setFocusedClient(0);
1703 }
1704
1705
1706 void Client::configureRequestHandler(const XConfigureRequestEvent &ec)
1707 {
1708 #ifdef DEBUG
1709 printf("ConfigureRequest for 0x%lx\n", ec.window);
1710 #endif // DEBUG
1711
1712 otk::EventHandler::configureRequestHandler(ec);
1713
1714 // compress these
1715 XConfigureRequestEvent e = ec;
1716 XEvent ev;
1717 while (XCheckTypedWindowEvent(**otk::display, window(), ConfigureRequest,
1718 &ev)) {
1719 // XXX if this causes bad things.. we can compress config req's with the
1720 // same mask.
1721 e.value_mask |= ev.xconfigurerequest.value_mask;
1722 if (ev.xconfigurerequest.value_mask & CWX)
1723 e.x = ev.xconfigurerequest.x;
1724 if (ev.xconfigurerequest.value_mask & CWY)
1725 e.y = ev.xconfigurerequest.y;
1726 if (ev.xconfigurerequest.value_mask & CWWidth)
1727 e.width = ev.xconfigurerequest.width;
1728 if (ev.xconfigurerequest.value_mask & CWHeight)
1729 e.height = ev.xconfigurerequest.height;
1730 if (ev.xconfigurerequest.value_mask & CWBorderWidth)
1731 e.border_width = ev.xconfigurerequest.border_width;
1732 if (ev.xconfigurerequest.value_mask & CWStackMode)
1733 e.detail = ev.xconfigurerequest.detail;
1734 }
1735
1736 // if we are iconic (or shaded (fvwm does this)) ignore the event
1737 if (_iconic || _shaded) return;
1738
1739 if (e.value_mask & CWBorderWidth)
1740 _border_width = e.border_width;
1741
1742 // resize, then move, as specified in the EWMH section 7.7
1743 if (e.value_mask & (CWWidth | CWHeight)) {
1744 int w = (e.value_mask & CWWidth) ? e.width : _area.width();
1745 int h = (e.value_mask & CWHeight) ? e.height : _area.height();
1746
1747 Corner corner;
1748 switch (_gravity) {
1749 case NorthEastGravity:
1750 case EastGravity:
1751 corner = TopRight;
1752 break;
1753 case SouthWestGravity:
1754 case SouthGravity:
1755 corner = BottomLeft;
1756 break;
1757 case SouthEastGravity:
1758 corner = BottomRight;
1759 break;
1760 default: // NorthWest, Static, etc
1761 corner = TopLeft;
1762 }
1763
1764 // if moving AND resizing ...
1765 if (e.value_mask & (CWX | CWY)) {
1766 int x = (e.value_mask & CWX) ? e.x : _area.x();
1767 int y = (e.value_mask & CWY) ? e.y : _area.y();
1768 internal_resize(corner, w, h, false, x, y);
1769 } else // if JUST resizing...
1770 internal_resize(corner, w, h, false);
1771 } else if (e.value_mask & (CWX | CWY)) { // if JUST moving...
1772 int x = (e.value_mask & CWX) ? e.x : _area.x();
1773 int y = (e.value_mask & CWY) ? e.y : _area.y();
1774 internal_move(x, y);
1775 }
1776
1777 if (e.value_mask & CWStackMode) {
1778 switch (e.detail) {
1779 case Below:
1780 case BottomIf:
1781 openbox->screen(_screen)->lowerWindow(this);
1782 break;
1783
1784 case Above:
1785 case TopIf:
1786 default:
1787 openbox->screen(_screen)->raiseWindow(this);
1788 break;
1789 }
1790 }
1791 }
1792
1793
1794 void Client::unmapHandler(const XUnmapEvent &e)
1795 {
1796 if (ignore_unmaps) {
1797 #ifdef DEBUG
1798 // printf("Ignored UnmapNotify for 0x%lx (event 0x%lx)\n", e.window, e.event);
1799 #endif // DEBUG
1800 ignore_unmaps--;
1801 return;
1802 }
1803
1804 #ifdef DEBUG
1805 printf("UnmapNotify for 0x%lx\n", e.window);
1806 #endif // DEBUG
1807
1808 otk::EventHandler::unmapHandler(e);
1809
1810 // this deletes us etc
1811 openbox->screen(_screen)->unmanageWindow(this);
1812 }
1813
1814
1815 void Client::destroyHandler(const XDestroyWindowEvent &e)
1816 {
1817 #ifdef DEBUG
1818 printf("DestroyNotify for 0x%lx\n", e.window);
1819 #endif // DEBUG
1820
1821 otk::EventHandler::destroyHandler(e);
1822
1823 // this deletes us etc
1824 openbox->screen(_screen)->unmanageWindow(this);
1825 }
1826
1827
1828 void Client::reparentHandler(const XReparentEvent &e)
1829 {
1830 // this is when the client is first taken captive in the frame
1831 if (e.parent == frame->plate()) return;
1832
1833 #ifdef DEBUG
1834 printf("ReparentNotify for 0x%lx\n", e.window);
1835 #endif // DEBUG
1836
1837 otk::EventHandler::reparentHandler(e);
1838
1839 /*
1840 This event is quite rare and is usually handled in unmapHandler.
1841 However, if the window is unmapped when the reparent event occurs,
1842 the window manager never sees it because an unmap event is not sent
1843 to an already unmapped window.
1844 */
1845
1846 // we don't want the reparent event, put it back on the stack for the X
1847 // server to deal with after we unmanage the window
1848 XEvent ev;
1849 ev.xreparent = e;
1850 XPutBackEvent(**otk::display, &ev);
1851
1852 // this deletes us etc
1853 openbox->screen(_screen)->unmanageWindow(this);
1854 }
1855
1856 void Client::mapRequestHandler(const XMapRequestEvent &e)
1857 {
1858 #ifdef DEBUG
1859 printf("MapRequest for already managed 0x%lx\n", e.window);
1860 #endif // DEBUG
1861
1862 assert(_iconic); // we shouldn't be able to get this unless we're iconic
1863
1864 // move to the current desktop (uniconify)
1865 iconify(false);
1866 // XXX: should we focus/raise the window? (basically a net_wm_active_window)
1867 }
1868
1869 }
This page took 0.119773 seconds and 5 git commands to generate.