1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2 // Window.cc for Blackbox - an X11 Window manager
3 // Copyright (c) 2001 - 2002 Sean 'Shaleh' Perry <shaleh at debian.org>
4 // Copyright (c) 1997 - 2000, 2002 Brad Hughes <bhughes at trolltech.com>
6 // Permission is hereby granted, free of charge, to any person obtaining a
7 // copy of this software and associated documentation files (the "Software"),
8 // to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 // and/or sell copies of the Software, and to permit persons to whom the
11 // Software is furnished to do so, subject to the following conditions:
13 // The above copyright notice and this permission notice shall be included in
14 // all copies or substantial portions of the Software.
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 // DEALINGS IN THE SOFTWARE.
25 # include "../config.h"
26 #endif // HAVE_CONFIG_H
29 #include <X11/Xatom.h>
30 #include <X11/keysym.h>
34 #endif // HAVE_STRING_H
39 # endif // HAVE_STDIO_H
44 #endif // HAVE_STDLIB_H
48 #include "blackbox.hh"
49 #include "Clientmenu.hh"
52 #include "Iconmenu.hh"
58 #include "Windowmenu.hh"
59 #include "Workspace.hh"
66 * Initializes the class with default values/the window's set initial values.
68 BlackboxWindow::BlackboxWindow(Blackbox
*b
, Window w
, BScreen
*s
) {
69 // fprintf(stderr, "BlackboxWindow size: %d bytes\n",
70 // sizeof(BlackboxWindow));
73 fprintf(stderr
, "BlackboxWindow::BlackboxWindow(): creating 0x%lx\n", w
);
77 set timer to zero... it is initialized properly later, so we check
78 if timer is zero in the destructor, and assume that the window is not
79 fully constructed if timer is zero...
85 xatom
= blackbox
->getXAtom();
87 if (! validateClient()) {
92 // fetch client size and placement
93 XWindowAttributes wattrib
;
94 if (! XGetWindowAttributes(blackbox
->getXDisplay(),
95 client
.window
, &wattrib
) ||
96 ! wattrib
.screen
|| wattrib
.override_redirect
) {
99 "BlackboxWindow::BlackboxWindow(): XGetWindowAttributes failed\n");
106 // set the eventmask early in the game so that we make sure we get
107 // all the events we are interested in
108 XSetWindowAttributes attrib_set
;
109 attrib_set
.event_mask
= PropertyChangeMask
| FocusChangeMask
|
111 attrib_set
.do_not_propagate_mask
= ButtonPressMask
| ButtonReleaseMask
|
113 XChangeWindowAttributes(blackbox
->getXDisplay(), client
.window
,
114 CWEventMask
|CWDontPropagate
, &attrib_set
);
116 flags
.moving
= flags
.resizing
= flags
.shaded
= flags
.visible
=
117 flags
.iconic
= flags
.focused
= flags
.stuck
= flags
.modal
=
118 flags
.send_focus_message
= flags
.shaped
= flags
.skip_taskbar
=
119 flags
.skip_pager
= flags
.fullscreen
= False
;
122 blackbox_attrib
.workspace
= window_number
= BSENTINEL
;
124 blackbox_attrib
.flags
= blackbox_attrib
.attrib
= blackbox_attrib
.stack
= 0l;
125 blackbox_attrib
.decoration
= DecorNormal
;
126 blackbox_attrib
.premax_x
= blackbox_attrib
.premax_y
= 0;
127 blackbox_attrib
.premax_w
= blackbox_attrib
.premax_h
= 0;
130 frame
.window
= frame
.plate
= frame
.title
= frame
.handle
= None
;
131 frame
.close_button
= frame
.iconify_button
= frame
.maximize_button
=
132 frame
.stick_button
= None
;
133 frame
.right_grip
= frame
.left_grip
= None
;
135 frame
.ulabel_pixel
= frame
.flabel_pixel
= frame
.utitle_pixel
=
136 frame
.ftitle_pixel
= frame
.uhandle_pixel
= frame
.fhandle_pixel
=
137 frame
.ubutton_pixel
= frame
.fbutton_pixel
= frame
.uborder_pixel
=
138 frame
.fborder_pixel
= frame
.ugrip_pixel
= frame
.fgrip_pixel
= 0;
139 frame
.utitle
= frame
.ftitle
= frame
.uhandle
= frame
.fhandle
= None
;
140 frame
.ulabel
= frame
.flabel
= frame
.ubutton
= frame
.fbutton
= None
;
141 frame
.ugrip
= frame
.fgrip
= None
;
143 functions
= Func_Resize
| Func_Move
| Func_Iconify
| Func_Maximize
;
144 mwm_decorations
= Decor_Titlebar
| Decor_Handle
| Decor_Border
|
145 Decor_Iconify
| Decor_Maximize
;
147 client
.normal_hint_flags
= 0;
148 client
.window_group
= None
;
149 client
.transient_for
= 0;
151 current_state
= NormalState
;
156 set the initial size and location of client window (relative to the
157 _root window_). This position is the reference point used with the
158 window's gravity to find the window's initial position.
160 client
.rect
.setRect(wattrib
.x
, wattrib
.y
, wattrib
.width
, wattrib
.height
);
161 client
.old_bw
= wattrib
.border_width
;
163 lastButtonPressTime
= 0;
165 timer
= new BTimer(blackbox
, this);
166 timer
->setTimeout(blackbox
->getAutoRaiseDelay());
168 // get size, aspect, minimum/maximum size and other hints set by the
171 if (! getBlackboxHints())
178 frame
.window
= createToplevelWindow();
180 blackbox
->saveWindowSearch(frame
.window
, this);
182 frame
.plate
= createChildWindow(frame
.window
, ExposureMask
);
183 blackbox
->saveWindowSearch(frame
.plate
, this);
185 // determine if this is a transient window
188 // determine the window's type, so we can decide its decorations and
189 // functionality, or if we should not manage it at all
190 if (getWindowType()) {
191 // adjust the window decorations/behavior based on the window type
192 switch (window_type
) {
196 blackbox_attrib
.workspace
= 0; // we do need to belong to a workspace
197 flags
.stuck
= True
; // we show up on all workspaces
199 // none of these windows are manipulated by the window manager
205 // these windows get less functionality
206 functions
&= ~(Func_Maximize
| Func_Resize
| Func_Iconify
);
210 // dialogs cannot be maximized
211 functions
&= ~Func_Maximize
;
215 // normal windows retain all of the possible decorations and
223 // further adjeust the window's decorations/behavior based on window sizes
224 if ((client
.normal_hint_flags
& PMinSize
) &&
225 (client
.normal_hint_flags
& PMaxSize
) &&
226 client
.max_width
<= client
.min_width
&&
227 client
.max_height
<= client
.min_height
) {
228 functions
&= ~(Func_Resize
| Func_Maximize
);
235 if (decorations
& Decor_Titlebar
)
238 if (decorations
& Decor_Handle
)
241 // apply the size and gravity hint to the frame
245 bool place_window
= True
;
246 if (blackbox
->isStartup() || isTransient() ||
247 client
.normal_hint_flags
& (PPosition
|USPosition
)) {
248 applyGravity(frame
.rect
);
250 if (blackbox
->isStartup() || client
.rect
.intersects(screen
->getRect()))
251 place_window
= False
;
254 // add the window's strut. note this is done *after* placing the window.
255 screen
->addStrut(&client
.strut
);
259 the server needs to be grabbed here to prevent client's from sending
260 events while we are in the process of configuring their window.
261 We hold the grab until after we are done moving the window around.
264 XGrabServer(blackbox
->getXDisplay());
266 associateClientWindow();
268 blackbox
->saveWindowSearch(client
.window
, this);
270 if (blackbox_attrib
.workspace
>= screen
->getWorkspaceCount())
271 screen
->getCurrentWorkspace()->addWindow(this, place_window
);
273 screen
->getWorkspace(blackbox_attrib
.workspace
)->
274 addWindow(this, place_window
);
276 if (! place_window
) {
277 // don't need to call configure if we are letting the workspace
279 configure(frame
.rect
.x(), frame
.rect
.y(),
280 frame
.rect
.width(), frame
.rect
.height());
286 XUngrabServer(blackbox
->getXDisplay());
289 if (blackbox
->hasShapeExtensions() && flags
.shaped
)
293 // now that we know where to put the window and what it should look like
294 // we apply the decorations
299 XMapSubwindows(blackbox
->getXDisplay(), frame
.window
);
301 // this ensures the title, buttons, and other decor are properly displayed
304 // preserve the window's initial state on first map, and its current state
306 unsigned long initial_state
= current_state
;
308 current_state
= initial_state
;
310 // get sticky state from our parent window if we've got one
311 if (isTransient() && client
.transient_for
!= (BlackboxWindow
*) ~0ul &&
312 client
.transient_for
->isStuck() != flags
.stuck
)
316 flags
.shaded
= False
;
317 initial_state
= current_state
;
321 At this point in the life of a window, current_state should only be set
322 to IconicState if the window was an *icon*, not if it was shaded.
324 if (initial_state
!= IconicState
)
325 current_state
= NormalState
;
333 if (flags
.maximized
&& (functions
& Func_Maximize
))
336 // create this last so it only needs to be configured once
337 windowmenu
= new Windowmenu(this);
341 BlackboxWindow::~BlackboxWindow(void) {
343 fprintf(stderr
, "BlackboxWindow::~BlackboxWindow: destroying 0x%lx\n",
347 if (! timer
) // window not managed...
353 screen
->removeStrut(&client
.strut
);
354 screen
->updateAvailableArea();
356 // We don't need to worry about resizing because resizing always grabs the X
357 // server. This should only ever happen if using opaque moving.
365 if (client
.window_group
) {
366 BWindowGroup
*group
= blackbox
->searchGroup(client
.window_group
);
367 if (group
) group
->removeWindow(this);
370 // remove ourselves from our transient_for
372 if (client
.transient_for
!= (BlackboxWindow
*) ~0ul)
373 client
.transient_for
->client
.transientList
.remove(this);
374 client
.transient_for
= (BlackboxWindow
*) 0;
377 if (client
.transientList
.size() > 0) {
378 // reset transient_for for all transients
379 BlackboxWindowList::iterator it
, end
= client
.transientList
.end();
380 for (it
= client
.transientList
.begin(); it
!= end
; ++it
)
381 (*it
)->client
.transient_for
= (BlackboxWindow
*) 0;
391 blackbox
->removeWindowSearch(frame
.plate
);
392 XDestroyWindow(blackbox
->getXDisplay(), frame
.plate
);
396 blackbox
->removeWindowSearch(frame
.window
);
397 XDestroyWindow(blackbox
->getXDisplay(), frame
.window
);
400 blackbox
->removeWindowSearch(client
.window
);
404 void BlackboxWindow::enableDecor(bool enable
) {
405 blackbox_attrib
.flags
|= AttribDecoration
;
406 blackbox_attrib
.decoration
= enable
? DecorNormal
: DecorNone
;
409 // we can not be shaded if we lack a titlebar
410 if (! (decorations
& Decor_Titlebar
) && flags
.shaded
)
413 if (flags
.visible
&& frame
.window
) {
414 XMapSubwindows(blackbox
->getXDisplay(), frame
.window
);
415 XMapWindow(blackbox
->getXDisplay(), frame
.window
);
419 setState(current_state
);
423 void BlackboxWindow::setupDecor() {
424 if (blackbox_attrib
.decoration
!= DecorNone
) {
425 // start with everything on
426 decorations
= Decor_Close
|
427 (mwm_decorations
& Decor_Titlebar
? Decor_Titlebar
: 0) |
428 (mwm_decorations
& Decor_Border
? Decor_Border
: 0) |
429 (mwm_decorations
& Decor_Handle
? Decor_Handle
: 0) |
430 (mwm_decorations
& Decor_Iconify
? Decor_Iconify
: 0) |
431 (mwm_decorations
& Decor_Maximize
? Decor_Maximize
: 0);
433 if (! (functions
& Func_Close
)) decorations
&= ~Decor_Close
;
434 if (! (functions
& Func_Maximize
)) decorations
&= ~Decor_Maximize
;
435 if (! (functions
& Func_Iconify
)) decorations
&= ~Decor_Iconify
;
436 if (! (functions
& Func_Resize
)) decorations
&= ~Decor_Handle
;
438 switch (window_type
) {
443 // none of these windows are decorated by the window manager at all
449 decorations
&= ~(Decor_Border
);
453 decorations
&= ~Decor_Handle
;
465 * Creates a new top level window, with a given location, size, and border
467 * Returns: the newly created window
469 Window
BlackboxWindow::createToplevelWindow(void) {
470 XSetWindowAttributes attrib_create
;
471 unsigned long create_mask
= CWBackPixmap
| CWBorderPixel
| CWColormap
|
472 CWOverrideRedirect
| CWEventMask
;
474 attrib_create
.background_pixmap
= None
;
475 attrib_create
.colormap
= screen
->getColormap();
476 attrib_create
.override_redirect
= True
;
477 attrib_create
.event_mask
= EnterWindowMask
| LeaveWindowMask
|
480 We catch button presses because other wise they get passed down to the
481 root window, which will then cause root menus to show when you click the
485 return XCreateWindow(blackbox
->getXDisplay(), screen
->getRootWindow(),
486 0, 0, 1, 1, frame
.border_w
, screen
->getDepth(),
487 InputOutput
, screen
->getVisual(), create_mask
,
493 * Creates a child window, and optionally associates a given cursor with
496 Window
BlackboxWindow::createChildWindow(Window parent
,
497 unsigned long event_mask
,
499 XSetWindowAttributes attrib_create
;
500 unsigned long create_mask
= CWBackPixmap
| CWBorderPixel
|
503 attrib_create
.background_pixmap
= None
;
504 attrib_create
.event_mask
= event_mask
;
507 create_mask
|= CWCursor
;
508 attrib_create
.cursor
= cursor
;
511 return XCreateWindow(blackbox
->getXDisplay(), parent
, 0, 0, 1, 1, 0,
512 screen
->getDepth(), InputOutput
, screen
->getVisual(),
513 create_mask
, &attrib_create
);
517 void BlackboxWindow::associateClientWindow(void) {
518 XSetWindowBorderWidth(blackbox
->getXDisplay(), client
.window
, 0);
522 XChangeSaveSet(blackbox
->getXDisplay(), client
.window
, SetModeInsert
);
524 XSelectInput(blackbox
->getXDisplay(), frame
.plate
, SubstructureRedirectMask
);
527 note we used to grab around this call to XReparentWindow however the
528 server is now grabbed before this method is called
530 unsigned long event_mask
= PropertyChangeMask
| FocusChangeMask
|
532 XSelectInput(blackbox
->getXDisplay(), client
.window
,
533 event_mask
& ~StructureNotifyMask
);
534 XReparentWindow(blackbox
->getXDisplay(), client
.window
, frame
.plate
, 0, 0);
535 XSelectInput(blackbox
->getXDisplay(), client
.window
, event_mask
);
537 XRaiseWindow(blackbox
->getXDisplay(), frame
.plate
);
538 XMapSubwindows(blackbox
->getXDisplay(), frame
.plate
);
541 if (blackbox
->hasShapeExtensions()) {
542 XShapeSelectInput(blackbox
->getXDisplay(), client
.window
,
549 XShapeQueryExtents(blackbox
->getXDisplay(), client
.window
, &shaped
,
550 &foo
, &foo
, &ufoo
, &ufoo
, &foo
, &foo
, &foo
,
552 flags
.shaped
= shaped
;
558 void BlackboxWindow::decorate(void) {
561 texture
= &(screen
->getWindowStyle()->b_focus
);
562 frame
.fbutton
= texture
->render(frame
.button_w
, frame
.button_w
,
565 frame
.fbutton_pixel
= texture
->color().pixel();
567 texture
= &(screen
->getWindowStyle()->b_unfocus
);
568 frame
.ubutton
= texture
->render(frame
.button_w
, frame
.button_w
,
571 frame
.ubutton_pixel
= texture
->color().pixel();
573 unsigned char needsPressed
= 0;
575 texture
= &(screen
->getWindowStyle()->b_pressed_focus
);
577 if (texture
->texture() != BTexture::NoTexture
) {
578 frame
.pfbutton
= texture
->render(frame
.button_w
, frame
.button_w
,
580 if (! frame
.pfbutton
)
581 frame
.pfbutton_pixel
= texture
->color().pixel();
586 texture
= &(screen
->getWindowStyle()->b_pressed_unfocus
);
588 if (texture
->texture() != BTexture::NoTexture
) {
589 frame
.pubutton
= texture
->render(frame
.button_w
, frame
.button_w
,
591 if (! frame
.pubutton
)
592 frame
.pubutton
= texture
->color().pixel();
597 // if we either pressed unfocused, or pressed focused were undefined,
598 // make them inherit from the old resource. It's a hack for sure, but
599 // it allows for some backwards and forwards compatibility.
601 texture
= &(screen
->getWindowStyle()->b_pressed
);
603 Pixmap pbutton
= texture
->render(frame
.button_w
, frame
.button_w
,
608 pixel
= texture
->color().pixel();
609 if (needsPressed
& 0x1)
610 frame
.pfbutton_pixel
= pixel
;
611 if (needsPressed
& 0x2)
612 frame
.pubutton_pixel
= pixel
;
614 if (needsPressed
& 0x1)
615 frame
.pfbutton
= pbutton
;
616 if (needsPressed
& 0x2)
617 frame
.pubutton
= pbutton
;
622 if (decorations
& Decor_Titlebar
) {
623 texture
= &(screen
->getWindowStyle()->t_focus
);
624 frame
.ftitle
= texture
->render(frame
.inside_w
, frame
.title_h
,
627 frame
.ftitle_pixel
= texture
->color().pixel();
629 texture
= &(screen
->getWindowStyle()->t_unfocus
);
630 frame
.utitle
= texture
->render(frame
.inside_w
, frame
.title_h
,
633 frame
.utitle_pixel
= texture
->color().pixel();
635 XSetWindowBorder(blackbox
->getXDisplay(), frame
.title
,
636 screen
->getBorderColor()->pixel());
641 if (decorations
& Decor_Border
) {
642 frame
.fborder_pixel
= screen
->getWindowStyle()->f_focus
.color().pixel();
643 frame
.uborder_pixel
= screen
->getWindowStyle()->f_unfocus
.color().pixel();
646 if (decorations
& Decor_Handle
) {
647 texture
= &(screen
->getWindowStyle()->h_focus
);
648 frame
.fhandle
= texture
->render(frame
.inside_w
, frame
.handle_h
,
651 frame
.fhandle_pixel
= texture
->color().pixel();
653 texture
= &(screen
->getWindowStyle()->h_unfocus
);
654 frame
.uhandle
= texture
->render(frame
.inside_w
, frame
.handle_h
,
657 frame
.uhandle_pixel
= texture
->color().pixel();
659 texture
= &(screen
->getWindowStyle()->g_focus
);
660 frame
.fgrip
= texture
->render(frame
.grip_w
, frame
.handle_h
, frame
.fgrip
);
662 frame
.fgrip_pixel
= texture
->color().pixel();
664 texture
= &(screen
->getWindowStyle()->g_unfocus
);
665 frame
.ugrip
= texture
->render(frame
.grip_w
, frame
.handle_h
, frame
.ugrip
);
667 frame
.ugrip_pixel
= texture
->color().pixel();
669 XSetWindowBorder(blackbox
->getXDisplay(), frame
.handle
,
670 screen
->getBorderColor()->pixel());
671 XSetWindowBorder(blackbox
->getXDisplay(), frame
.left_grip
,
672 screen
->getBorderColor()->pixel());
673 XSetWindowBorder(blackbox
->getXDisplay(), frame
.right_grip
,
674 screen
->getBorderColor()->pixel());
677 XSetWindowBorder(blackbox
->getXDisplay(), frame
.window
,
678 screen
->getBorderColor()->pixel());
682 void BlackboxWindow::decorateLabel(void) {
685 texture
= &(screen
->getWindowStyle()->l_focus
);
686 frame
.flabel
= texture
->render(frame
.label_w
, frame
.label_h
, frame
.flabel
);
688 frame
.flabel_pixel
= texture
->color().pixel();
690 texture
= &(screen
->getWindowStyle()->l_unfocus
);
691 frame
.ulabel
= texture
->render(frame
.label_w
, frame
.label_h
, frame
.ulabel
);
693 frame
.ulabel_pixel
= texture
->color().pixel();
697 void BlackboxWindow::createHandle(void) {
698 frame
.handle
= createChildWindow(frame
.window
,
699 ButtonPressMask
| ButtonReleaseMask
|
700 ButtonMotionMask
| ExposureMask
);
701 blackbox
->saveWindowSearch(frame
.handle
, this);
704 createChildWindow(frame
.handle
,
705 ButtonPressMask
| ButtonReleaseMask
|
706 ButtonMotionMask
| ExposureMask
,
707 blackbox
->getLowerLeftAngleCursor());
708 blackbox
->saveWindowSearch(frame
.left_grip
, this);
711 createChildWindow(frame
.handle
,
712 ButtonPressMask
| ButtonReleaseMask
|
713 ButtonMotionMask
| ExposureMask
,
714 blackbox
->getLowerRightAngleCursor());
715 blackbox
->saveWindowSearch(frame
.right_grip
, this);
719 void BlackboxWindow::destroyHandle(void) {
721 screen
->getImageControl()->removeImage(frame
.fhandle
);
724 screen
->getImageControl()->removeImage(frame
.uhandle
);
727 screen
->getImageControl()->removeImage(frame
.fgrip
);
730 screen
->getImageControl()->removeImage(frame
.ugrip
);
732 blackbox
->removeWindowSearch(frame
.left_grip
);
733 blackbox
->removeWindowSearch(frame
.right_grip
);
735 XDestroyWindow(blackbox
->getXDisplay(), frame
.left_grip
);
736 XDestroyWindow(blackbox
->getXDisplay(), frame
.right_grip
);
737 frame
.left_grip
= frame
.right_grip
= None
;
739 blackbox
->removeWindowSearch(frame
.handle
);
740 XDestroyWindow(blackbox
->getXDisplay(), frame
.handle
);
745 void BlackboxWindow::createTitlebar(void) {
746 frame
.title
= createChildWindow(frame
.window
,
747 ButtonPressMask
| ButtonReleaseMask
|
748 ButtonMotionMask
| ExposureMask
);
749 frame
.label
= createChildWindow(frame
.title
,
750 ButtonPressMask
| ButtonReleaseMask
|
751 ButtonMotionMask
| ExposureMask
);
752 blackbox
->saveWindowSearch(frame
.title
, this);
753 blackbox
->saveWindowSearch(frame
.label
, this);
755 if (decorations
& Decor_Iconify
) createIconifyButton();
756 if (decorations
& Decor_Maximize
) createMaximizeButton();
757 if (decorations
& Decor_Close
) createCloseButton();
761 void BlackboxWindow::destroyTitlebar(void) {
762 if (frame
.close_button
)
763 destroyCloseButton();
765 if (frame
.iconify_button
)
766 destroyIconifyButton();
768 if (frame
.maximize_button
)
769 destroyMaximizeButton();
771 if (frame
.stick_button
)
772 destroyStickyButton();
775 screen
->getImageControl()->removeImage(frame
.ftitle
);
778 screen
->getImageControl()->removeImage(frame
.utitle
);
781 screen
->getImageControl()->removeImage(frame
.flabel
);
784 screen
->getImageControl()->removeImage(frame
.ulabel
);
787 screen
->getImageControl()->removeImage(frame
.fbutton
);
790 screen
->getImageControl()->removeImage(frame
.ubutton
);
792 blackbox
->removeWindowSearch(frame
.title
);
793 blackbox
->removeWindowSearch(frame
.label
);
795 XDestroyWindow(blackbox
->getXDisplay(), frame
.label
);
796 XDestroyWindow(blackbox
->getXDisplay(), frame
.title
);
797 frame
.title
= frame
.label
= None
;
801 void BlackboxWindow::createCloseButton(void) {
802 if (frame
.title
!= None
) {
803 frame
.close_button
= createChildWindow(frame
.title
,
806 ButtonMotionMask
| ExposureMask
);
807 blackbox
->saveWindowSearch(frame
.close_button
, this);
812 void BlackboxWindow::destroyCloseButton(void) {
813 blackbox
->removeWindowSearch(frame
.close_button
);
814 XDestroyWindow(blackbox
->getXDisplay(), frame
.close_button
);
815 frame
.close_button
= None
;
819 void BlackboxWindow::createIconifyButton(void) {
820 if (frame
.title
!= None
) {
821 frame
.iconify_button
= createChildWindow(frame
.title
,
824 ButtonMotionMask
| ExposureMask
);
825 blackbox
->saveWindowSearch(frame
.iconify_button
, this);
830 void BlackboxWindow::destroyIconifyButton(void) {
831 blackbox
->removeWindowSearch(frame
.iconify_button
);
832 XDestroyWindow(blackbox
->getXDisplay(), frame
.iconify_button
);
833 frame
.iconify_button
= None
;
837 void BlackboxWindow::createMaximizeButton(void) {
838 if (frame
.title
!= None
) {
839 frame
.maximize_button
= createChildWindow(frame
.title
,
842 ButtonMotionMask
| ExposureMask
);
843 blackbox
->saveWindowSearch(frame
.maximize_button
, this);
848 void BlackboxWindow::destroyMaximizeButton(void) {
849 blackbox
->removeWindowSearch(frame
.maximize_button
);
850 XDestroyWindow(blackbox
->getXDisplay(), frame
.maximize_button
);
851 frame
.maximize_button
= None
;
854 void BlackboxWindow::createStickyButton(void) {
855 if (frame
.title
!= None
) {
856 frame
.stick_button
= createChildWindow(frame
.title
,
859 ButtonMotionMask
| ExposureMask
);
860 blackbox
->saveWindowSearch(frame
.stick_button
, this);
864 void BlackboxWindow::destroyStickyButton(void) {
865 blackbox
->removeWindowSearch(frame
.stick_button
);
866 XDestroyWindow(blackbox
->getXDisplay(), frame
.stick_button
);
867 frame
.stick_button
= None
;
870 void BlackboxWindow::positionButtons(bool redecorate_label
) {
871 string layout
= blackbox
->getTitlebarLayout();
874 bool hasclose
, hasiconify
, hasmaximize
, haslabel
, hasstick
;
875 hasclose
= hasiconify
= hasmaximize
= haslabel
= hasstick
= false;
877 string::const_iterator it
, end
;
878 for (it
= layout
.begin(), end
= layout
.end(); it
!= end
; ++it
) {
881 if (! hasclose
&& (decorations
& Decor_Close
)) {
887 if (! hasiconify
&& (decorations
& Decor_Iconify
)) {
899 if (! hasmaximize
&& (decorations
& Decor_Maximize
)) {
913 if (! hasclose
&& frame
.close_button
)
914 destroyCloseButton();
915 if (! hasiconify
&& frame
.iconify_button
)
916 destroyIconifyButton();
917 if (! hasmaximize
&& frame
.maximize_button
)
918 destroyMaximizeButton();
919 if (! hasstick
&& frame
.stick_button
)
920 destroyStickyButton();
922 parsed
+= 'L'; // require that the label be in the layout
924 const unsigned int bsep
= frame
.bevel_w
+ 1; // separation between elements
925 const unsigned int by
= frame
.bevel_w
+ 1;
926 const unsigned int ty
= frame
.bevel_w
;
928 frame
.label_w
= frame
.inside_w
- bsep
* 2 -
929 (frame
.button_w
+ bsep
) * (parsed
.size() - 1);
931 unsigned int x
= bsep
;
932 for (it
= parsed
.begin(), end
= parsed
.end(); it
!= end
; ++it
) {
935 if (! frame
.close_button
) createCloseButton();
936 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.close_button
, x
, by
,
937 frame
.button_w
, frame
.button_w
);
938 x
+= frame
.button_w
+ bsep
;
941 if (! frame
.iconify_button
) createIconifyButton();
942 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.iconify_button
, x
, by
,
943 frame
.button_w
, frame
.button_w
);
944 x
+= frame
.button_w
+ bsep
;
947 if (! frame
.stick_button
) createStickyButton();
948 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.stick_button
, x
, by
,
949 frame
.button_w
, frame
.button_w
);
950 x
+= frame
.button_w
+ bsep
;
953 if (! frame
.maximize_button
) createMaximizeButton();
954 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.maximize_button
, x
, by
,
955 frame
.button_w
, frame
.button_w
);
956 x
+= frame
.button_w
+ bsep
;
959 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.label
, x
, ty
,
960 frame
.label_w
, frame
.label_h
);
961 x
+= frame
.label_w
+ bsep
;
966 if (redecorate_label
) decorateLabel();
972 void BlackboxWindow::reconfigure(void) {
973 restoreGravity(client
.rect
);
975 applyGravity(frame
.rect
);
984 windowmenu
->move(windowmenu
->getX(), frame
.rect
.y() + frame
.title_h
);
985 windowmenu
->reconfigure();
990 void BlackboxWindow::grabButtons(void) {
991 mod_mask
= blackbox
->getMouseModMask();
993 if (! screen
->isSloppyFocus() || screen
->doClickRaise())
994 // grab button 1 for changing focus/raising
995 blackbox
->grabButton(Button1
, 0, frame
.plate
, True
, ButtonPressMask
,
996 GrabModeSync
, GrabModeSync
, frame
.plate
, None
,
997 screen
->allowScrollLock());
999 if (functions
& Func_Move
)
1000 blackbox
->grabButton(Button1
, mod_mask
, frame
.window
, True
,
1001 ButtonReleaseMask
| ButtonMotionMask
, GrabModeAsync
,
1002 GrabModeAsync
, frame
.window
, None
,
1003 screen
->allowScrollLock());
1004 if (functions
& Func_Resize
)
1005 blackbox
->grabButton(Button3
, mod_mask
, frame
.window
, True
,
1006 ButtonReleaseMask
| ButtonMotionMask
, GrabModeAsync
,
1007 GrabModeAsync
, frame
.window
, None
,
1008 screen
->allowScrollLock());
1009 // alt+middle lowers the window
1010 blackbox
->grabButton(Button2
, mod_mask
, frame
.window
, True
,
1011 ButtonReleaseMask
, GrabModeAsync
, GrabModeAsync
,
1012 frame
.window
, None
, screen
->allowScrollLock());
1016 void BlackboxWindow::ungrabButtons(void) {
1017 blackbox
->ungrabButton(Button1
, 0, frame
.plate
);
1018 blackbox
->ungrabButton(Button1
, mod_mask
, frame
.window
);
1019 blackbox
->ungrabButton(Button2
, mod_mask
, frame
.window
);
1020 blackbox
->ungrabButton(Button3
, mod_mask
, frame
.window
);
1024 void BlackboxWindow::positionWindows(void) {
1025 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.window
,
1026 frame
.rect
.x(), frame
.rect
.y(), frame
.inside_w
,
1027 (flags
.shaded
) ? frame
.title_h
: frame
.inside_h
);
1028 XSetWindowBorderWidth(blackbox
->getXDisplay(), frame
.window
,
1030 XSetWindowBorderWidth(blackbox
->getXDisplay(), frame
.plate
,
1031 frame
.mwm_border_w
);
1032 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.plate
,
1033 frame
.margin
.left
- frame
.mwm_border_w
- frame
.border_w
,
1034 frame
.margin
.top
- frame
.mwm_border_w
- frame
.border_w
,
1035 client
.rect
.width(), client
.rect
.height());
1036 XMoveResizeWindow(blackbox
->getXDisplay(), client
.window
,
1037 0, 0, client
.rect
.width(), client
.rect
.height());
1038 // ensure client.rect contains the real location
1039 client
.rect
.setPos(frame
.rect
.left() + frame
.margin
.left
,
1040 frame
.rect
.top() + frame
.margin
.top
);
1042 if (decorations
& Decor_Titlebar
) {
1043 if (frame
.title
== None
) createTitlebar();
1045 XSetWindowBorderWidth(blackbox
->getXDisplay(), frame
.title
,
1047 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.title
, -frame
.border_w
,
1048 -frame
.border_w
, frame
.inside_w
, frame
.title_h
);
1051 XMapSubwindows(blackbox
->getXDisplay(), frame
.title
);
1052 XMapWindow(blackbox
->getXDisplay(), frame
.title
);
1053 } else if (frame
.title
) {
1056 if (decorations
& Decor_Handle
) {
1057 if (frame
.handle
== None
) createHandle();
1058 XSetWindowBorderWidth(blackbox
->getXDisplay(), frame
.handle
,
1060 XSetWindowBorderWidth(blackbox
->getXDisplay(), frame
.left_grip
,
1062 XSetWindowBorderWidth(blackbox
->getXDisplay(), frame
.right_grip
,
1065 // use client.rect here so the value is correct even if shaded
1066 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.handle
,
1068 client
.rect
.height() + frame
.margin
.top
+
1069 frame
.mwm_border_w
- frame
.border_w
,
1070 frame
.inside_w
, frame
.handle_h
);
1071 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.left_grip
,
1072 -frame
.border_w
, -frame
.border_w
,
1073 frame
.grip_w
, frame
.handle_h
);
1074 XMoveResizeWindow(blackbox
->getXDisplay(), frame
.right_grip
,
1075 frame
.inside_w
- frame
.grip_w
- frame
.border_w
,
1076 -frame
.border_w
, frame
.grip_w
, frame
.handle_h
);
1078 XMapSubwindows(blackbox
->getXDisplay(), frame
.handle
);
1079 XMapWindow(blackbox
->getXDisplay(), frame
.handle
);
1080 } else if (frame
.handle
) {
1083 XSync(blackbox
->getXDisplay(), False
);
1087 void BlackboxWindow::updateStrut(void) {
1088 unsigned long num
= 4;
1089 unsigned long *data
;
1090 if (! xatom
->getValue(client
.window
, XAtom::net_wm_strut
, XAtom::cardinal
,
1095 client
.strut
.left
= data
[0];
1096 client
.strut
.right
= data
[1];
1097 client
.strut
.top
= data
[2];
1098 client
.strut
.bottom
= data
[3];
1100 screen
->updateAvailableArea();
1107 bool BlackboxWindow::getWindowType(void) {
1108 window_type
= (WindowType
) -1;
1111 unsigned long num
= (unsigned) -1;
1112 if (xatom
->getValue(client
.window
, XAtom::net_wm_window_type
, XAtom::atom
,
1114 for (unsigned long i
= 0; i
< num
; ++i
) {
1115 if (val
[i
] == xatom
->getAtom(XAtom::net_wm_window_type_desktop
))
1116 window_type
= Type_Desktop
;
1117 else if (val
[i
] == xatom
->getAtom(XAtom::net_wm_window_type_dock
))
1118 window_type
= Type_Dock
;
1119 else if (val
[i
] == xatom
->getAtom(XAtom::net_wm_window_type_toolbar
))
1120 window_type
= Type_Toolbar
;
1121 else if (val
[i
] == xatom
->getAtom(XAtom::net_wm_window_type_menu
))
1122 window_type
= Type_Menu
;
1123 else if (val
[i
] == xatom
->getAtom(XAtom::net_wm_window_type_utility
))
1124 window_type
= Type_Utility
;
1125 else if (val
[i
] == xatom
->getAtom(XAtom::net_wm_window_type_splash
))
1126 window_type
= Type_Splash
;
1127 else if (val
[i
] == xatom
->getAtom(XAtom::net_wm_window_type_dialog
))
1128 window_type
= Type_Dialog
;
1129 else if (val
[i
] == xatom
->getAtom(XAtom::net_wm_window_type_normal
))
1130 window_type
= Type_Normal
;
1132 xatom
->getAtom(XAtom::kde_net_wm_window_type_override
))
1133 mwm_decorations
= 0; // prevent this window from getting any decor
1138 if (window_type
== (WindowType
) -1) {
1140 * the window type hint was not set, which means we either classify ourself
1141 * as a normal window or a dialog, depending on if we are a transient.
1144 window_type
= Type_Dialog
;
1146 window_type
= Type_Normal
;
1155 void BlackboxWindow::getWMName(void) {
1156 if (xatom
->getValue(client
.window
, XAtom::net_wm_name
,
1157 XAtom::utf8
, client
.title
) &&
1158 !client
.title
.empty()) {
1159 xatom
->eraseValue(client
.window
, XAtom::net_wm_visible_name
);
1162 //fall through to using WM_NAME
1163 if (xatom
->getValue(client
.window
, XAtom::wm_name
, XAtom::ansi
, client
.title
)
1164 && !client
.title
.empty()) {
1165 xatom
->eraseValue(client
.window
, XAtom::net_wm_visible_name
);
1168 // fall back to an internal default
1169 client
.title
= i18n(WindowSet
, WindowUnnamed
, "Unnamed");
1170 xatom
->setValue(client
.window
, XAtom::net_wm_visible_name
, XAtom::utf8
,
1173 #ifdef DEBUG_WITH_ID
1174 // the 16 is the 8 chars of the debug text plus the number
1175 char *tmp
= new char[client
.title
.length() + 16];
1176 sprintf(tmp
, "%s; id: 0x%lx", client
.title
.c_str(), client
.window
);
1183 void BlackboxWindow::getWMIconName(void) {
1184 if (xatom
->getValue(client
.window
, XAtom::net_wm_icon_name
,
1185 XAtom::utf8
, client
.icon_title
) &&
1186 !client
.icon_title
.empty()) {
1187 xatom
->eraseValue(client
.window
, XAtom::net_wm_visible_icon_name
);
1190 //fall through to using WM_ICON_NAME
1191 if (xatom
->getValue(client
.window
, XAtom::wm_icon_name
, XAtom::ansi
,
1192 client
.icon_title
) &&
1193 !client
.icon_title
.empty()) {
1194 xatom
->eraseValue(client
.window
, XAtom::net_wm_visible_icon_name
);
1197 // fall back to using the main name
1198 client
.icon_title
= client
.title
;
1199 xatom
->setValue(client
.window
, XAtom::net_wm_visible_icon_name
, XAtom::utf8
,
1205 * Retrieve which WM Protocols are supported by the client window.
1206 * If the WM_DELETE_WINDOW protocol is supported, add the close button to the
1207 * window's decorations and allow the close behavior.
1208 * If the WM_TAKE_FOCUS protocol is supported, save a value that indicates
1211 void BlackboxWindow::getWMProtocols(void) {
1215 if (XGetWMProtocols(blackbox
->getXDisplay(), client
.window
,
1216 &proto
, &num_return
)) {
1217 for (int i
= 0; i
< num_return
; ++i
) {
1218 if (proto
[i
] == xatom
->getAtom(XAtom::wm_delete_window
)) {
1219 decorations
|= Decor_Close
;
1220 functions
|= Func_Close
;
1221 } else if (proto
[i
] == xatom
->getAtom(XAtom::wm_take_focus
))
1222 flags
.send_focus_message
= True
;
1223 else if (proto
[i
] == xatom
->getAtom(XAtom::blackbox_structure_messages
))
1224 screen
->addNetizen(new Netizen(screen
, client
.window
));
1233 * Gets the value of the WM_HINTS property.
1234 * If the property is not set, then use a set of default values.
1236 void BlackboxWindow::getWMHints(void) {
1237 focus_mode
= F_Passive
;
1239 // remove from current window group
1240 if (client
.window_group
) {
1241 BWindowGroup
*group
= blackbox
->searchGroup(client
.window_group
);
1242 if (group
) group
->removeWindow(this);
1244 client
.window_group
= None
;
1246 XWMHints
*wmhint
= XGetWMHints(blackbox
->getXDisplay(), client
.window
);
1251 if (wmhint
->flags
& InputHint
) {
1252 if (wmhint
->input
== True
) {
1253 if (flags
.send_focus_message
)
1254 focus_mode
= F_LocallyActive
;
1256 if (flags
.send_focus_message
)
1257 focus_mode
= F_GloballyActive
;
1259 focus_mode
= F_NoInput
;
1263 if (wmhint
->flags
& StateHint
)
1264 current_state
= wmhint
->initial_state
;
1266 if (wmhint
->flags
& WindowGroupHint
) {
1267 client
.window_group
= wmhint
->window_group
;
1269 // add window to the appropriate group
1270 BWindowGroup
*group
= blackbox
->searchGroup(client
.window_group
);
1271 if (! group
) { // no group found, create it!
1272 new BWindowGroup(blackbox
, client
.window_group
);
1273 group
= blackbox
->searchGroup(client
.window_group
);
1276 group
->addWindow(this);
1284 * Gets the value of the WM_NORMAL_HINTS property.
1285 * If the property is not set, then use a set of default values.
1287 void BlackboxWindow::getWMNormalHints(void) {
1289 XSizeHints sizehint
;
1291 client
.min_width
= client
.min_height
=
1292 client
.width_inc
= client
.height_inc
= 1;
1293 client
.base_width
= client
.base_height
= 0;
1294 client
.win_gravity
= NorthWestGravity
;
1296 client
.min_aspect_x
= client
.min_aspect_y
=
1297 client
.max_aspect_x
= client
.max_aspect_y
= 1;
1300 // don't limit the size of a window, the default max width is the biggest
1302 client
.max_width
= (unsigned) -1;
1303 client
.max_height
= (unsigned) -1;
1306 if (! XGetWMNormalHints(blackbox
->getXDisplay(), client
.window
,
1307 &sizehint
, &icccm_mask
))
1310 client
.normal_hint_flags
= sizehint
.flags
;
1312 if (sizehint
.flags
& PMinSize
) {
1313 if (sizehint
.min_width
>= 0)
1314 client
.min_width
= sizehint
.min_width
;
1315 if (sizehint
.min_height
>= 0)
1316 client
.min_height
= sizehint
.min_height
;
1319 if (sizehint
.flags
& PMaxSize
) {
1320 if (sizehint
.max_width
> static_cast<signed>(client
.min_width
))
1321 client
.max_width
= sizehint
.max_width
;
1323 client
.max_width
= client
.min_width
;
1325 if (sizehint
.max_height
> static_cast<signed>(client
.min_height
))
1326 client
.max_height
= sizehint
.max_height
;
1328 client
.max_height
= client
.min_height
;
1331 if (sizehint
.flags
& PResizeInc
) {
1332 client
.width_inc
= sizehint
.width_inc
;
1333 client
.height_inc
= sizehint
.height_inc
;
1336 #if 0 // we do not support this at the moment
1337 if (sizehint
.flags
& PAspect
) {
1338 client
.min_aspect_x
= sizehint
.min_aspect
.x
;
1339 client
.min_aspect_y
= sizehint
.min_aspect
.y
;
1340 client
.max_aspect_x
= sizehint
.max_aspect
.x
;
1341 client
.max_aspect_y
= sizehint
.max_aspect
.y
;
1345 if (sizehint
.flags
& PBaseSize
) {
1346 client
.base_width
= sizehint
.base_width
;
1347 client
.base_height
= sizehint
.base_height
;
1350 if (sizehint
.flags
& PWinGravity
)
1351 client
.win_gravity
= sizehint
.win_gravity
;
1356 * Gets the NETWM hints for the class' contained window.
1358 void BlackboxWindow::getNetWMHints(void) {
1359 unsigned long workspace
;
1361 if (xatom
->getValue(client
.window
, XAtom::net_wm_desktop
, XAtom::cardinal
,
1363 if (workspace
== 0xffffffff)
1366 blackbox_attrib
.workspace
= workspace
;
1369 unsigned long *state
;
1370 unsigned long num
= (unsigned) -1;
1371 if (xatom
->getValue(client
.window
, XAtom::net_wm_state
, XAtom::atom
,
1375 for (unsigned long i
= 0; i
< num
; ++i
) {
1376 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
))
1378 else if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_shaded
))
1379 flags
.shaded
= True
;
1380 else if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
))
1381 flags
.skip_taskbar
= True
;
1382 else if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_skip_pager
))
1383 flags
.skip_pager
= True
;
1384 else if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_fullscreen
))
1385 flags
.fullscreen
= True
;
1386 else if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_hidden
))
1387 setState(IconicState
);
1388 else if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_maximized_vert
))
1390 else if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_maximized_horz
))
1394 flags
.maximized
= 1;
1396 flags
.maximized
= 2;
1398 flags
.maximized
= 3;
1406 * Gets the MWM hints for the class' contained window.
1407 * This is used while initializing the window to its first state, and not
1409 * Returns: true if the MWM hints are successfully retreived and applied;
1410 * false if they are not.
1412 void BlackboxWindow::getMWMHints(void) {
1416 num
= PropMwmHintsElements
;
1417 if (! xatom
->getValue(client
.window
, XAtom::motif_wm_hints
,
1418 XAtom::motif_wm_hints
, num
,
1419 (unsigned long **)&mwm_hint
))
1421 if (num
< PropMwmHintsElements
) {
1426 if (mwm_hint
->flags
& MwmHintsDecorations
) {
1427 if (mwm_hint
->decorations
& MwmDecorAll
) {
1428 mwm_decorations
= Decor_Titlebar
| Decor_Handle
| Decor_Border
|
1429 Decor_Iconify
| Decor_Maximize
;
1431 mwm_decorations
= 0;
1433 if (mwm_hint
->decorations
& MwmDecorBorder
)
1434 mwm_decorations
|= Decor_Border
;
1435 if (mwm_hint
->decorations
& MwmDecorHandle
)
1436 mwm_decorations
|= Decor_Handle
;
1437 if (mwm_hint
->decorations
& MwmDecorTitle
)
1438 mwm_decorations
|= Decor_Titlebar
;
1439 if (mwm_hint
->decorations
& MwmDecorIconify
)
1440 mwm_decorations
|= Decor_Iconify
;
1441 if (mwm_hint
->decorations
& MwmDecorMaximize
)
1442 mwm_decorations
|= Decor_Maximize
;
1446 if (mwm_hint
->flags
& MwmHintsFunctions
) {
1447 if (mwm_hint
->functions
& MwmFuncAll
) {
1448 functions
= Func_Resize
| Func_Move
| Func_Iconify
| Func_Maximize
|
1453 if (mwm_hint
->functions
& MwmFuncResize
)
1454 functions
|= Func_Resize
;
1455 if (mwm_hint
->functions
& MwmFuncMove
)
1456 functions
|= Func_Move
;
1457 if (mwm_hint
->functions
& MwmFuncIconify
)
1458 functions
|= Func_Iconify
;
1459 if (mwm_hint
->functions
& MwmFuncMaximize
)
1460 functions
|= Func_Maximize
;
1461 if (mwm_hint
->functions
& MwmFuncClose
)
1462 functions
|= Func_Close
;
1470 * Gets the blackbox hints from the class' contained window.
1471 * This is used while initializing the window to its first state, and not
1473 * Returns: true if the hints are successfully retreived and applied; false if
1476 bool BlackboxWindow::getBlackboxHints(void) {
1478 BlackboxHints
*blackbox_hint
;
1480 num
= PropBlackboxHintsElements
;
1481 if (! xatom
->getValue(client
.window
, XAtom::blackbox_hints
,
1482 XAtom::blackbox_hints
, num
,
1483 (unsigned long **)&blackbox_hint
))
1485 if (num
< PropBlackboxHintsElements
) {
1486 delete [] blackbox_hint
;
1490 if (blackbox_hint
->flags
& AttribShaded
)
1491 flags
.shaded
= (blackbox_hint
->attrib
& AttribShaded
);
1493 if ((blackbox_hint
->flags
& AttribMaxHoriz
) &&
1494 (blackbox_hint
->flags
& AttribMaxVert
))
1495 flags
.maximized
= (blackbox_hint
->attrib
&
1496 (AttribMaxHoriz
| AttribMaxVert
)) ? 1 : 0;
1497 else if (blackbox_hint
->flags
& AttribMaxVert
)
1498 flags
.maximized
= (blackbox_hint
->attrib
& AttribMaxVert
) ? 2 : 0;
1499 else if (blackbox_hint
->flags
& AttribMaxHoriz
)
1500 flags
.maximized
= (blackbox_hint
->attrib
& AttribMaxHoriz
) ? 3 : 0;
1502 if (blackbox_hint
->flags
& AttribOmnipresent
)
1503 flags
.stuck
= (blackbox_hint
->attrib
& AttribOmnipresent
);
1505 if (blackbox_hint
->flags
& AttribWorkspace
)
1506 blackbox_attrib
.workspace
= blackbox_hint
->workspace
;
1508 // if (blackbox_hint->flags & AttribStack)
1509 // don't yet have always on top/bottom for blackbox yet... working
1512 if (blackbox_hint
->flags
& AttribDecoration
) {
1513 switch (blackbox_hint
->decoration
) {
1515 blackbox_attrib
.decoration
= DecorNone
;
1522 // blackbox_attrib.decoration defaults to DecorNormal
1527 delete [] blackbox_hint
;
1533 void BlackboxWindow::getTransientInfo(void) {
1534 if (client
.transient_for
&&
1535 client
.transient_for
!= (BlackboxWindow
*) ~0ul) {
1536 // reset transient_for in preparation of looking for a new owner
1537 client
.transient_for
->client
.transientList
.remove(this);
1540 // we have no transient_for until we find a new one
1541 client
.transient_for
= (BlackboxWindow
*) 0;
1544 if (! XGetTransientForHint(blackbox
->getXDisplay(), client
.window
,
1546 // transient_for hint not set
1550 if (trans_for
== client
.window
) {
1551 // wierd client... treat this window as a normal window
1555 if (trans_for
== None
|| trans_for
== screen
->getRootWindow()) {
1556 // this is an undocumented interpretation of the ICCCM. a transient
1557 // associated with None/Root/itself is assumed to be a modal root
1558 // transient. we don't support the concept of a global transient,
1559 // so we just associate this transient with nothing, and perhaps
1560 // we will add support later for global modality.
1561 client
.transient_for
= (BlackboxWindow
*) ~0ul;
1566 client
.transient_for
= blackbox
->searchWindow(trans_for
);
1567 if (! client
.transient_for
&&
1568 client
.window_group
&& trans_for
== client
.window_group
) {
1569 // no direct transient_for, perhaps this is a group transient?
1570 BWindowGroup
*group
= blackbox
->searchGroup(client
.window_group
);
1571 if (group
) client
.transient_for
= group
->find(screen
);
1574 if (! client
.transient_for
|| client
.transient_for
== this) {
1575 // no transient_for found, or we have a wierd client that wants to be
1576 // a transient for itself, so we treat this window as a normal window
1577 client
.transient_for
= (BlackboxWindow
*) 0;
1581 // Check for a circular transient state: this can lock up Blackbox
1582 // when it tries to find the non-transient window for a transient.
1583 BlackboxWindow
*w
= this;
1584 while(w
->client
.transient_for
&&
1585 w
->client
.transient_for
!= (BlackboxWindow
*) ~0ul) {
1586 if(w
->client
.transient_for
== this) {
1587 client
.transient_for
= (BlackboxWindow
*) 0;
1590 w
= w
->client
.transient_for
;
1593 if (client
.transient_for
&&
1594 client
.transient_for
!= (BlackboxWindow
*) ~0ul) {
1595 // register ourselves with our new transient_for
1596 client
.transient_for
->client
.transientList
.push_back(this);
1597 flags
.stuck
= client
.transient_for
->flags
.stuck
;
1602 BlackboxWindow
*BlackboxWindow::getTransientFor(void) const {
1603 if (client
.transient_for
&&
1604 client
.transient_for
!= (BlackboxWindow
*) ~0ul)
1605 return client
.transient_for
;
1611 * This function is responsible for updating both the client and the frame
1613 * According to the ICCCM a client message is not sent for a resize, only a
1616 void BlackboxWindow::configure(int dx
, int dy
,
1617 unsigned int dw
, unsigned int dh
) {
1618 bool send_event
= ((frame
.rect
.x() != dx
|| frame
.rect
.y() != dy
) &&
1621 if (dw
!= frame
.rect
.width() || dh
!= frame
.rect
.height()) {
1622 frame
.rect
.setRect(dx
, dy
, dw
, dh
);
1623 frame
.inside_w
= frame
.rect
.width() - (frame
.border_w
* 2);
1624 frame
.inside_h
= frame
.rect
.height() - (frame
.border_w
* 2);
1626 if (frame
.rect
.right() <= 0 || frame
.rect
.bottom() <= 0)
1627 frame
.rect
.setPos(0, 0);
1629 client
.rect
.setCoords(frame
.rect
.left() + frame
.margin
.left
,
1630 frame
.rect
.top() + frame
.margin
.top
,
1631 frame
.rect
.right() - frame
.margin
.right
,
1632 frame
.rect
.bottom() - frame
.margin
.bottom
);
1635 if (blackbox
->hasShapeExtensions() && flags
.shaped
) {
1642 redrawWindowFrame();
1644 frame
.rect
.setPos(dx
, dy
);
1646 XMoveWindow(blackbox
->getXDisplay(), frame
.window
,
1647 frame
.rect
.x(), frame
.rect
.y());
1649 we may have been called just after an opaque window move, so even though
1650 the old coords match the new ones no ConfigureNotify has been sent yet.
1651 There are likely other times when this will be relevant as well.
1653 if (! flags
.moving
) send_event
= True
;
1657 // if moving, the update and event will occur when the move finishes
1658 client
.rect
.setPos(frame
.rect
.left() + frame
.margin
.left
,
1659 frame
.rect
.top() + frame
.margin
.top
);
1662 event
.type
= ConfigureNotify
;
1664 event
.xconfigure
.display
= blackbox
->getXDisplay();
1665 event
.xconfigure
.event
= client
.window
;
1666 event
.xconfigure
.window
= client
.window
;
1667 event
.xconfigure
.x
= client
.rect
.x();
1668 event
.xconfigure
.y
= client
.rect
.y();
1669 event
.xconfigure
.width
= client
.rect
.width();
1670 event
.xconfigure
.height
= client
.rect
.height();
1671 event
.xconfigure
.border_width
= client
.old_bw
;
1672 event
.xconfigure
.above
= frame
.window
;
1673 event
.xconfigure
.override_redirect
= False
;
1675 XSendEvent(blackbox
->getXDisplay(), client
.window
, False
,
1676 StructureNotifyMask
, &event
);
1677 screen
->updateNetizenConfigNotify(&event
);
1678 XFlush(blackbox
->getXDisplay());
1684 void BlackboxWindow::configureShape(void) {
1685 XShapeCombineShape(blackbox
->getXDisplay(), frame
.window
, ShapeBounding
,
1686 frame
.margin
.left
- frame
.border_w
,
1687 frame
.margin
.top
- frame
.border_w
,
1688 client
.window
, ShapeBounding
, ShapeSet
);
1691 XRectangle xrect
[2];
1693 if (decorations
& Decor_Titlebar
) {
1694 xrect
[0].x
= xrect
[0].y
= -frame
.border_w
;
1695 xrect
[0].width
= frame
.rect
.width();
1696 xrect
[0].height
= frame
.title_h
+ (frame
.border_w
* 2);
1700 if (decorations
& Decor_Handle
) {
1701 xrect
[1].x
= -frame
.border_w
;
1702 xrect
[1].y
= frame
.rect
.height() - frame
.margin
.bottom
+
1703 frame
.mwm_border_w
- frame
.border_w
;
1704 xrect
[1].width
= frame
.rect
.width();
1705 xrect
[1].height
= frame
.handle_h
+ (frame
.border_w
* 2);
1709 XShapeCombineRectangles(blackbox
->getXDisplay(), frame
.window
,
1710 ShapeBounding
, 0, 0, xrect
, num
,
1711 ShapeUnion
, Unsorted
);
1715 void BlackboxWindow::clearShape(void) {
1716 XShapeCombineMask(blackbox
->getXDisplay(), frame
.window
, ShapeBounding
,
1717 frame
.margin
.left
- frame
.border_w
,
1718 frame
.margin
.top
- frame
.border_w
,
1724 bool BlackboxWindow::setInputFocus(void) {
1725 if (flags
.focused
) return True
;
1727 assert(flags
.stuck
|| // window must be on the current workspace or sticky
1728 blackbox_attrib
.workspace
== screen
->getCurrentWorkspaceID());
1731 We only do this check for normal windows and dialogs because other windows
1732 do this on purpose, such as kde's kicker, and we don't want to go moving
1735 if (window_type
== Type_Normal
|| window_type
== Type_Dialog
)
1736 if (! frame
.rect
.intersects(screen
->getRect())) {
1737 // client is outside the screen, move it to the center
1738 configure((screen
->getWidth() - frame
.rect
.width()) / 2,
1739 (screen
->getHeight() - frame
.rect
.height()) / 2,
1740 frame
.rect
.width(), frame
.rect
.height());
1743 if (client
.transientList
.size() > 0) {
1744 // transfer focus to any modal transients
1745 BlackboxWindowList::iterator it
, end
= client
.transientList
.end();
1746 for (it
= client
.transientList
.begin(); it
!= end
; ++it
)
1747 if ((*it
)->flags
.modal
) return (*it
)->setInputFocus();
1751 if (focus_mode
== F_LocallyActive
|| focus_mode
== F_Passive
) {
1752 XSetInputFocus(blackbox
->getXDisplay(), client
.window
,
1753 RevertToPointerRoot
, CurrentTime
);
1755 /* we could set the focus to none, since the window doesn't accept focus,
1756 * but we shouldn't set focus to nothing since this would surely make
1762 if (flags
.send_focus_message
) {
1764 ce
.xclient
.type
= ClientMessage
;
1765 ce
.xclient
.message_type
= xatom
->getAtom(XAtom::wm_protocols
);
1766 ce
.xclient
.display
= blackbox
->getXDisplay();
1767 ce
.xclient
.window
= client
.window
;
1768 ce
.xclient
.format
= 32;
1769 ce
.xclient
.data
.l
[0] = xatom
->getAtom(XAtom::wm_take_focus
);
1770 ce
.xclient
.data
.l
[1] = blackbox
->getLastTime();
1771 ce
.xclient
.data
.l
[2] = 0l;
1772 ce
.xclient
.data
.l
[3] = 0l;
1773 ce
.xclient
.data
.l
[4] = 0l;
1774 XSendEvent(blackbox
->getXDisplay(), client
.window
, False
,
1776 XFlush(blackbox
->getXDisplay());
1783 void BlackboxWindow::iconify(void) {
1784 if (flags
.iconic
|| ! (functions
& Func_Iconify
)) return;
1786 // We don't need to worry about resizing because resizing always grabs the X
1787 // server. This should only ever happen if using opaque moving.
1791 if (windowmenu
) windowmenu
->hide();
1794 * we don't want this XUnmapWindow call to generate an UnmapNotify event, so
1795 * we need to clear the event mask on client.window for a split second.
1796 * HOWEVER, since X11 is asynchronous, the window could be destroyed in that
1797 * split second, leaving us with a ghost window... so, we need to do this
1798 * while the X server is grabbed
1800 unsigned long event_mask
= PropertyChangeMask
| FocusChangeMask
|
1801 StructureNotifyMask
;
1802 XGrabServer(blackbox
->getXDisplay());
1803 XSelectInput(blackbox
->getXDisplay(), client
.window
,
1804 event_mask
& ~StructureNotifyMask
);
1805 XUnmapWindow(blackbox
->getXDisplay(), client
.window
);
1806 XSelectInput(blackbox
->getXDisplay(), client
.window
, event_mask
);
1807 XUngrabServer(blackbox
->getXDisplay());
1809 XUnmapWindow(blackbox
->getXDisplay(), frame
.window
);
1810 flags
.visible
= False
;
1811 flags
.iconic
= True
;
1813 setState(IconicState
);
1815 screen
->getWorkspace(blackbox_attrib
.workspace
)->removeWindow(this);
1817 for (unsigned int i
= 0; i
< screen
->getNumberOfWorkspaces(); ++i
)
1818 if (i
!= blackbox_attrib
.workspace
)
1819 screen
->getWorkspace(i
)->removeWindow(this, True
);
1822 if (isTransient()) {
1823 if (client
.transient_for
!= (BlackboxWindow
*) ~0ul &&
1824 ! client
.transient_for
->flags
.iconic
) {
1825 // iconify our transient_for
1826 client
.transient_for
->iconify();
1830 screen
->addIcon(this);
1832 if (client
.transientList
.size() > 0) {
1833 // iconify all transients
1834 BlackboxWindowList::iterator it
, end
= client
.transientList
.end();
1835 for (it
= client
.transientList
.begin(); it
!= end
; ++it
) {
1836 if (! (*it
)->flags
.iconic
) (*it
)->iconify();
1839 screen
->updateStackingList();
1843 void BlackboxWindow::show(void) {
1844 flags
.visible
= True
;
1845 flags
.iconic
= False
;
1847 current_state
= (flags
.shaded
) ? IconicState
: NormalState
;
1848 setState(current_state
);
1850 XMapWindow(blackbox
->getXDisplay(), client
.window
);
1851 XMapSubwindows(blackbox
->getXDisplay(), frame
.window
);
1852 XMapWindow(blackbox
->getXDisplay(), frame
.window
);
1857 XTranslateCoordinates(blackbox
->getXDisplay(), client
.window
,
1858 screen
->getRootWindow(),
1859 0, 0, &real_x
, &real_y
, &child
);
1860 fprintf(stderr
, "%s -- assumed: (%d, %d), real: (%d, %d)\n", getTitle(),
1861 client
.rect
.left(), client
.rect
.top(), real_x
, real_y
);
1862 assert(client
.rect
.left() == real_x
&& client
.rect
.top() == real_y
);
1867 void BlackboxWindow::deiconify(bool reassoc
, bool raise
) {
1868 if (flags
.iconic
|| reassoc
)
1869 screen
->reassociateWindow(this, BSENTINEL
, False
);
1870 else if (blackbox_attrib
.workspace
!= screen
->getCurrentWorkspaceID())
1875 // reassociate and deiconify all transients
1876 if (reassoc
&& client
.transientList
.size() > 0) {
1877 BlackboxWindowList::iterator it
, end
= client
.transientList
.end();
1878 for (it
= client
.transientList
.begin(); it
!= end
; ++it
)
1879 (*it
)->deiconify(True
, False
);
1883 screen
->getWorkspace(blackbox_attrib
.workspace
)->raiseWindow(this);
1887 void BlackboxWindow::close(void) {
1888 if (! (functions
& Func_Close
)) return;
1891 ce
.xclient
.type
= ClientMessage
;
1892 ce
.xclient
.message_type
= xatom
->getAtom(XAtom::wm_protocols
);
1893 ce
.xclient
.display
= blackbox
->getXDisplay();
1894 ce
.xclient
.window
= client
.window
;
1895 ce
.xclient
.format
= 32;
1896 ce
.xclient
.data
.l
[0] = xatom
->getAtom(XAtom::wm_delete_window
);
1897 ce
.xclient
.data
.l
[1] = CurrentTime
;
1898 ce
.xclient
.data
.l
[2] = 0l;
1899 ce
.xclient
.data
.l
[3] = 0l;
1900 ce
.xclient
.data
.l
[4] = 0l;
1901 XSendEvent(blackbox
->getXDisplay(), client
.window
, False
, NoEventMask
, &ce
);
1902 XFlush(blackbox
->getXDisplay());
1906 void BlackboxWindow::withdraw(void) {
1907 // We don't need to worry about resizing because resizing always grabs the X
1908 // server. This should only ever happen if using opaque moving.
1912 flags
.visible
= False
;
1913 flags
.iconic
= False
;
1915 setState(current_state
);
1917 XUnmapWindow(blackbox
->getXDisplay(), frame
.window
);
1919 XGrabServer(blackbox
->getXDisplay());
1921 unsigned long event_mask
= PropertyChangeMask
| FocusChangeMask
|
1922 StructureNotifyMask
;
1923 XSelectInput(blackbox
->getXDisplay(), client
.window
,
1924 event_mask
& ~StructureNotifyMask
);
1925 XUnmapWindow(blackbox
->getXDisplay(), client
.window
);
1926 XSelectInput(blackbox
->getXDisplay(), client
.window
, event_mask
);
1928 XUngrabServer(blackbox
->getXDisplay());
1930 if (windowmenu
) windowmenu
->hide();
1934 void BlackboxWindow::maximize(unsigned int button
) {
1935 if (! (functions
& Func_Maximize
)) return;
1937 // We don't need to worry about resizing because resizing always grabs the X
1938 // server. This should only ever happen if using opaque moving.
1942 // handle case where menu is open then the max button is used instead
1943 if (windowmenu
&& windowmenu
->isVisible()) windowmenu
->hide();
1945 if (flags
.maximized
) {
1946 flags
.maximized
= 0;
1948 blackbox_attrib
.flags
&= ! (AttribMaxHoriz
| AttribMaxVert
);
1949 blackbox_attrib
.attrib
&= ! (AttribMaxHoriz
| AttribMaxVert
);
1952 when a resize finishes, maximize(0) is called to clear any maximization
1953 flags currently set. Otherwise it still thinks it is maximized.
1954 so we do not need to call configure() because resizing will handle it
1956 if (! flags
.resizing
)
1957 configure(blackbox_attrib
.premax_x
, blackbox_attrib
.premax_y
,
1958 blackbox_attrib
.premax_w
, blackbox_attrib
.premax_h
);
1960 blackbox_attrib
.premax_x
= blackbox_attrib
.premax_y
= 0;
1961 blackbox_attrib
.premax_w
= blackbox_attrib
.premax_h
= 0;
1963 redrawAllButtons(); // in case it is not called in configure()
1964 setState(current_state
);
1968 blackbox_attrib
.premax_x
= frame
.rect
.x();
1969 blackbox_attrib
.premax_y
= frame
.rect
.y();
1970 blackbox_attrib
.premax_w
= frame
.rect
.width();
1971 // use client.rect so that clients can be restored even if shaded
1972 blackbox_attrib
.premax_h
=
1973 client
.rect
.height() + frame
.margin
.top
+ frame
.margin
.bottom
;
1976 if (screen
->isXineramaActive() && blackbox
->doXineramaMaximizing()) {
1977 // find the area to use
1978 RectList availableAreas
= screen
->allAvailableAreas();
1979 RectList::iterator it
, end
= availableAreas
.end();
1981 for (it
= availableAreas
.begin(); it
!= end
; ++it
)
1982 if (it
->intersects(frame
.rect
)) break;
1983 if (it
== end
) // the window isn't inside an area
1984 it
= availableAreas
.begin(); // so just default to the first one
1986 frame
.changing
= *it
;
1989 frame
.changing
= screen
->availableArea();
1993 blackbox_attrib
.flags
|= AttribMaxHoriz
| AttribMaxVert
;
1994 blackbox_attrib
.attrib
|= AttribMaxHoriz
| AttribMaxVert
;
1998 blackbox_attrib
.flags
|= AttribMaxVert
;
1999 blackbox_attrib
.attrib
|= AttribMaxVert
;
2001 frame
.changing
.setX(frame
.rect
.x());
2002 frame
.changing
.setWidth(frame
.rect
.width());
2006 blackbox_attrib
.flags
|= AttribMaxHoriz
;
2007 blackbox_attrib
.attrib
|= AttribMaxHoriz
;
2009 frame
.changing
.setY(frame
.rect
.y());
2010 frame
.changing
.setHeight(frame
.rect
.height());
2017 blackbox_attrib
.flags
^= AttribShaded
;
2018 blackbox_attrib
.attrib
^= AttribShaded
;
2019 flags
.shaded
= False
;
2022 flags
.maximized
= button
;
2024 configure(frame
.changing
.x(), frame
.changing
.y(),
2025 frame
.changing
.width(), frame
.changing
.height());
2027 screen
->getWorkspace(blackbox_attrib
.workspace
)->raiseWindow(this);
2028 redrawAllButtons(); // in case it is not called in configure()
2029 setState(current_state
);
2033 // re-maximizes the window to take into account availableArea changes
2034 void BlackboxWindow::remaximize(void) {
2036 // we only update the window's attributes otherwise we lose the shade bit
2037 switch(flags
.maximized
) {
2039 blackbox_attrib
.flags
|= AttribMaxHoriz
| AttribMaxVert
;
2040 blackbox_attrib
.attrib
|= AttribMaxHoriz
| AttribMaxVert
;
2044 blackbox_attrib
.flags
|= AttribMaxVert
;
2045 blackbox_attrib
.attrib
|= AttribMaxVert
;
2049 blackbox_attrib
.flags
|= AttribMaxHoriz
;
2050 blackbox_attrib
.attrib
|= AttribMaxHoriz
;
2056 // save the original dimensions because maximize will wipe them out
2057 int premax_x
= blackbox_attrib
.premax_x
,
2058 premax_y
= blackbox_attrib
.premax_y
,
2059 premax_w
= blackbox_attrib
.premax_w
,
2060 premax_h
= blackbox_attrib
.premax_h
;
2062 unsigned int button
= flags
.maximized
;
2063 flags
.maximized
= 0; // trick maximize() into working
2066 // restore saved values
2067 blackbox_attrib
.premax_x
= premax_x
;
2068 blackbox_attrib
.premax_y
= premax_y
;
2069 blackbox_attrib
.premax_w
= premax_w
;
2070 blackbox_attrib
.premax_h
= premax_h
;
2074 void BlackboxWindow::setWorkspace(unsigned int n
) {
2075 blackbox_attrib
.flags
|= AttribWorkspace
;
2076 blackbox_attrib
.workspace
= n
;
2077 if (n
== BSENTINEL
) { // iconified window
2079 we set the workspace to 'all workspaces' so that taskbars will show the
2080 window. otherwise, it made uniconifying a window imposible without the
2081 blackbox workspace menu
2085 xatom
->setValue(client
.window
, XAtom::net_wm_desktop
, XAtom::cardinal
, n
);
2089 void BlackboxWindow::shade(void) {
2091 XResizeWindow(blackbox
->getXDisplay(), frame
.window
,
2092 frame
.inside_w
, frame
.inside_h
);
2093 flags
.shaded
= False
;
2094 blackbox_attrib
.flags
^= AttribShaded
;
2095 blackbox_attrib
.attrib
^= AttribShaded
;
2097 setState(NormalState
);
2099 // set the frame rect to the normal size
2100 frame
.rect
.setHeight(client
.rect
.height() + frame
.margin
.top
+
2101 frame
.margin
.bottom
);
2103 if (! (decorations
& Decor_Titlebar
))
2104 return; // can't shade it without a titlebar!
2106 XResizeWindow(blackbox
->getXDisplay(), frame
.window
,
2107 frame
.inside_w
, frame
.title_h
);
2108 flags
.shaded
= True
;
2109 blackbox_attrib
.flags
|= AttribShaded
;
2110 blackbox_attrib
.attrib
|= AttribShaded
;
2112 setState(IconicState
);
2114 // set the frame rect to the shaded size
2115 frame
.rect
.setHeight(frame
.title_h
+ (frame
.border_w
* 2));
2121 * (Un)Sticks a window and its relatives.
2123 void BlackboxWindow::stick(void) {
2125 blackbox_attrib
.flags
^= AttribOmnipresent
;
2126 blackbox_attrib
.attrib
^= AttribOmnipresent
;
2128 flags
.stuck
= False
;
2130 for (unsigned int i
= 0; i
< screen
->getNumberOfWorkspaces(); ++i
)
2131 if (i
!= blackbox_attrib
.workspace
)
2132 screen
->getWorkspace(i
)->removeWindow(this, True
);
2135 screen
->reassociateWindow(this, BSENTINEL
, True
);
2136 // temporary fix since sticky windows suck. set the hint to what we
2137 // actually hold in our data.
2138 xatom
->setValue(client
.window
, XAtom::net_wm_desktop
, XAtom::cardinal
,
2139 blackbox_attrib
.workspace
);
2141 setState(current_state
);
2145 blackbox_attrib
.flags
|= AttribOmnipresent
;
2146 blackbox_attrib
.attrib
|= AttribOmnipresent
;
2148 // temporary fix since sticky windows suck. set the hint to a different
2149 // value than that contained in the class' data.
2150 xatom
->setValue(client
.window
, XAtom::net_wm_desktop
, XAtom::cardinal
,
2153 for (unsigned int i
= 0; i
< screen
->getNumberOfWorkspaces(); ++i
)
2154 if (i
!= blackbox_attrib
.workspace
)
2155 screen
->getWorkspace(i
)->addWindow(this, False
, True
);
2157 setState(current_state
);
2163 if (isTransient() && client
.transient_for
!= (BlackboxWindow
*) ~0ul &&
2164 client
.transient_for
->isStuck() != flags
.stuck
)
2165 client
.transient_for
->stick();
2166 // go down the chain
2167 BlackboxWindowList::iterator it
;
2168 const BlackboxWindowList::iterator end
= client
.transientList
.end();
2169 for (it
= client
.transientList
.begin(); it
!= end
; ++it
)
2170 if ((*it
)->isStuck() != flags
.stuck
)
2175 void BlackboxWindow::redrawWindowFrame(void) const {
2176 if (decorations
& Decor_Titlebar
) {
2177 if (flags
.focused
) {
2179 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2180 frame
.title
, frame
.ftitle
);
2182 XSetWindowBackground(blackbox
->getXDisplay(),
2183 frame
.title
, frame
.ftitle_pixel
);
2186 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2187 frame
.title
, frame
.utitle
);
2189 XSetWindowBackground(blackbox
->getXDisplay(),
2190 frame
.title
, frame
.utitle_pixel
);
2192 XClearWindow(blackbox
->getXDisplay(), frame
.title
);
2198 if (decorations
& Decor_Handle
) {
2199 if (flags
.focused
) {
2201 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2202 frame
.handle
, frame
.fhandle
);
2204 XSetWindowBackground(blackbox
->getXDisplay(),
2205 frame
.handle
, frame
.fhandle_pixel
);
2208 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2209 frame
.left_grip
, frame
.fgrip
);
2210 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2211 frame
.right_grip
, frame
.fgrip
);
2213 XSetWindowBackground(blackbox
->getXDisplay(),
2214 frame
.left_grip
, frame
.fgrip_pixel
);
2215 XSetWindowBackground(blackbox
->getXDisplay(),
2216 frame
.right_grip
, frame
.fgrip_pixel
);
2220 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2221 frame
.handle
, frame
.uhandle
);
2223 XSetWindowBackground(blackbox
->getXDisplay(),
2224 frame
.handle
, frame
.uhandle_pixel
);
2227 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2228 frame
.left_grip
, frame
.ugrip
);
2229 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2230 frame
.right_grip
, frame
.ugrip
);
2232 XSetWindowBackground(blackbox
->getXDisplay(),
2233 frame
.left_grip
, frame
.ugrip_pixel
);
2234 XSetWindowBackground(blackbox
->getXDisplay(),
2235 frame
.right_grip
, frame
.ugrip_pixel
);
2238 XClearWindow(blackbox
->getXDisplay(), frame
.handle
);
2239 XClearWindow(blackbox
->getXDisplay(), frame
.left_grip
);
2240 XClearWindow(blackbox
->getXDisplay(), frame
.right_grip
);
2243 if (decorations
& Decor_Border
) {
2245 XSetWindowBorder(blackbox
->getXDisplay(),
2246 frame
.plate
, frame
.fborder_pixel
);
2248 XSetWindowBorder(blackbox
->getXDisplay(),
2249 frame
.plate
, frame
.uborder_pixel
);
2254 void BlackboxWindow::setFocusFlag(bool focus
) {
2255 // only focus a window if it is visible
2256 if (focus
&& ! flags
.visible
)
2259 flags
.focused
= focus
;
2261 redrawWindowFrame();
2264 blackbox
->setFocusedWindow(this);
2266 if (! flags
.iconic
) {
2267 // iconic windows arent in a workspace menu!
2269 screen
->getCurrentWorkspace()->setFocused(this, isFocused());
2271 screen
->getWorkspace(blackbox_attrib
.workspace
)->
2272 setFocused(this, flags
.focused
);
2277 void BlackboxWindow::installColormap(bool install
) {
2278 int i
= 0, ncmap
= 0;
2279 Colormap
*cmaps
= XListInstalledColormaps(blackbox
->getXDisplay(),
2280 client
.window
, &ncmap
);
2282 XWindowAttributes wattrib
;
2283 if (XGetWindowAttributes(blackbox
->getXDisplay(),
2284 client
.window
, &wattrib
)) {
2286 // install the window's colormap
2287 for (i
= 0; i
< ncmap
; i
++) {
2288 if (*(cmaps
+ i
) == wattrib
.colormap
)
2289 // this window is using an installed color map... do not install
2292 // otherwise, install the window's colormap
2294 XInstallColormap(blackbox
->getXDisplay(), wattrib
.colormap
);
2296 // uninstall the window's colormap
2297 for (i
= 0; i
< ncmap
; i
++) {
2298 if (*(cmaps
+ i
) == wattrib
.colormap
)
2299 // we found the colormap to uninstall
2300 XUninstallColormap(blackbox
->getXDisplay(), wattrib
.colormap
);
2310 void BlackboxWindow::setAllowedActions(void) {
2314 actions
[num
++] = xatom
->getAtom(XAtom::net_wm_action_shade
);
2315 actions
[num
++] = xatom
->getAtom(XAtom::net_wm_action_change_desktop
);
2316 actions
[num
++] = xatom
->getAtom(XAtom::net_wm_action_close
);
2318 if (functions
& Func_Move
)
2319 actions
[num
++] = xatom
->getAtom(XAtom::net_wm_action_move
);
2320 if (functions
& Func_Resize
)
2321 actions
[num
++] = xatom
->getAtom(XAtom::net_wm_action_resize
);
2322 if (functions
& Func_Maximize
) {
2323 actions
[num
++] = xatom
->getAtom(XAtom::net_wm_action_maximize_horz
);
2324 actions
[num
++] = xatom
->getAtom(XAtom::net_wm_action_maximize_vert
);
2327 xatom
->setValue(client
.window
, XAtom::net_wm_allowed_actions
, XAtom::atom
,
2332 void BlackboxWindow::setState(unsigned long new_state
) {
2333 current_state
= new_state
;
2335 unsigned long state
[2];
2336 state
[0] = current_state
;
2338 xatom
->setValue(client
.window
, XAtom::wm_state
, XAtom::wm_state
, state
, 2);
2340 xatom
->setValue(client
.window
, XAtom::blackbox_attributes
,
2341 XAtom::blackbox_attributes
, (unsigned long *)&blackbox_attrib
,
2342 PropBlackboxAttributesElements
);
2347 netstate
[num
++] = xatom
->getAtom(XAtom::net_wm_state_modal
);
2349 netstate
[num
++] = xatom
->getAtom(XAtom::net_wm_state_shaded
);
2351 netstate
[num
++] = xatom
->getAtom(XAtom::net_wm_state_hidden
);
2352 if (flags
.skip_taskbar
)
2353 netstate
[num
++] = xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
);
2354 if (flags
.skip_pager
)
2355 netstate
[num
++] = xatom
->getAtom(XAtom::net_wm_state_skip_pager
);
2356 if (flags
.fullscreen
)
2357 netstate
[num
++] = xatom
->getAtom(XAtom::net_wm_state_fullscreen
);
2358 if (flags
.maximized
== 1 || flags
.maximized
== 2)
2359 netstate
[num
++] = xatom
->getAtom(XAtom::net_wm_state_maximized_vert
);
2360 if (flags
.maximized
== 1 || flags
.maximized
== 3)
2361 netstate
[num
++] = xatom
->getAtom(XAtom::net_wm_state_maximized_horz
);
2362 xatom
->setValue(client
.window
, XAtom::net_wm_state
, XAtom::atom
,
2367 bool BlackboxWindow::getState(void) {
2368 bool ret
= xatom
->getValue(client
.window
, XAtom::wm_state
, XAtom::wm_state
,
2370 if (! ret
) current_state
= 0;
2375 void BlackboxWindow::restoreAttributes(void) {
2376 unsigned long num
= PropBlackboxAttributesElements
;
2377 BlackboxAttributes
*net
;
2378 if (! xatom
->getValue(client
.window
, XAtom::blackbox_attributes
,
2379 XAtom::blackbox_attributes
, num
,
2380 (unsigned long **)&net
))
2382 if (num
< PropBlackboxAttributesElements
) {
2387 if (net
->flags
& AttribShaded
&& net
->attrib
& AttribShaded
) {
2388 flags
.shaded
= False
;
2389 unsigned long orig_state
= current_state
;
2393 At this point in the life of a window, current_state should only be set
2394 to IconicState if the window was an *icon*, not if it was shaded.
2396 if (orig_state
!= IconicState
)
2397 current_state
= WithdrawnState
;
2400 if (net
->workspace
!= screen
->getCurrentWorkspaceID() &&
2401 net
->workspace
< screen
->getWorkspaceCount())
2402 screen
->reassociateWindow(this, net
->workspace
, True
);
2404 if ((blackbox_attrib
.workspace
!= screen
->getCurrentWorkspaceID()) &&
2405 (blackbox_attrib
.workspace
< screen
->getWorkspaceCount())) {
2406 // set to WithdrawnState so it will be mapped on the new workspace
2407 if (current_state
== NormalState
) current_state
= WithdrawnState
;
2408 } else if (current_state
== WithdrawnState
) {
2409 // the window is on this workspace and is Withdrawn, so it is waiting to
2411 current_state
= NormalState
;
2414 if (net
->flags
& AttribOmnipresent
&& net
->attrib
& AttribOmnipresent
&&
2418 // if the window was on another workspace, it was going to be hidden. this
2419 // specifies that the window should be mapped since it is sticky.
2420 if (current_state
== WithdrawnState
) current_state
= NormalState
;
2423 if (net
->flags
& AttribMaxHoriz
|| net
->flags
& AttribMaxVert
) {
2424 int x
= net
->premax_x
, y
= net
->premax_y
;
2425 unsigned int w
= net
->premax_w
, h
= net
->premax_h
;
2426 flags
.maximized
= 0;
2429 if ((net
->flags
& AttribMaxHoriz
) &&
2430 (net
->flags
& AttribMaxVert
))
2431 m
= (net
->attrib
& (AttribMaxHoriz
| AttribMaxVert
)) ? 1 : 0;
2432 else if (net
->flags
& AttribMaxVert
)
2433 m
= (net
->attrib
& AttribMaxVert
) ? 2 : 0;
2434 else if (net
->flags
& AttribMaxHoriz
)
2435 m
= (net
->attrib
& AttribMaxHoriz
) ? 3 : 0;
2439 blackbox_attrib
.premax_x
= x
;
2440 blackbox_attrib
.premax_y
= y
;
2441 blackbox_attrib
.premax_w
= w
;
2442 blackbox_attrib
.premax_h
= h
;
2445 if (net
->flags
& AttribDecoration
) {
2446 switch (net
->decoration
) {
2451 /* since tools only let you toggle this anyways, we'll just make that all
2452 it supports for now.
2463 // with the state set it will then be the map event's job to read the
2464 // window's state and behave accordingly
2471 * Positions the Rect r according the the client window position and
2474 void BlackboxWindow::applyGravity(Rect
&r
) {
2475 // apply horizontal window gravity
2476 switch (client
.win_gravity
) {
2478 case NorthWestGravity
:
2479 case SouthWestGravity
:
2481 r
.setX(client
.rect
.x());
2487 r
.setX(client
.rect
.x() - (frame
.margin
.left
+ frame
.margin
.right
) / 2);
2490 case NorthEastGravity
:
2491 case SouthEastGravity
:
2493 r
.setX(client
.rect
.x() - frame
.margin
.left
- frame
.margin
.right
+ 2);
2498 r
.setX(client
.rect
.x() - frame
.margin
.left
);
2502 // apply vertical window gravity
2503 switch (client
.win_gravity
) {
2505 case NorthWestGravity
:
2506 case NorthEastGravity
:
2508 r
.setY(client
.rect
.y());
2514 r
.setY(client
.rect
.y() - (frame
.margin
.top
+ frame
.margin
.bottom
) / 2);
2517 case SouthWestGravity
:
2518 case SouthEastGravity
:
2520 r
.setY(client
.rect
.y() - frame
.margin
.top
- frame
.margin
.bottom
+ 2);
2525 r
.setY(client
.rect
.y() - frame
.margin
.top
);
2532 * The reverse of the applyGravity function.
2534 * Positions the Rect r according to the frame window position and
2537 void BlackboxWindow::restoreGravity(Rect
&r
) {
2538 // restore horizontal window gravity
2539 switch (client
.win_gravity
) {
2541 case NorthWestGravity
:
2542 case SouthWestGravity
:
2544 r
.setX(frame
.rect
.x());
2550 r
.setX(frame
.rect
.x() + (frame
.margin
.left
+ frame
.margin
.right
) / 2);
2553 case NorthEastGravity
:
2554 case SouthEastGravity
:
2556 r
.setX(frame
.rect
.x() + frame
.margin
.left
+ frame
.margin
.right
- 2);
2561 r
.setX(frame
.rect
.x() + frame
.margin
.left
);
2565 // restore vertical window gravity
2566 switch (client
.win_gravity
) {
2568 case NorthWestGravity
:
2569 case NorthEastGravity
:
2571 r
.setY(frame
.rect
.y());
2577 r
.setY(frame
.rect
.y() + (frame
.margin
.top
+ frame
.margin
.bottom
) / 2);
2580 case SouthWestGravity
:
2581 case SouthEastGravity
:
2583 r
.setY(frame
.rect
.y() + frame
.margin
.top
+ frame
.margin
.bottom
- 2);
2588 r
.setY(frame
.rect
.y() + frame
.margin
.top
);
2594 void BlackboxWindow::redrawLabel(void) const {
2595 if (flags
.focused
) {
2597 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2598 frame
.label
, frame
.flabel
);
2600 XSetWindowBackground(blackbox
->getXDisplay(),
2601 frame
.label
, frame
.flabel_pixel
);
2604 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(),
2605 frame
.label
, frame
.ulabel
);
2607 XSetWindowBackground(blackbox
->getXDisplay(),
2608 frame
.label
, frame
.ulabel_pixel
);
2610 XClearWindow(blackbox
->getXDisplay(), frame
.label
);
2612 WindowStyle
*style
= screen
->getWindowStyle();
2614 int pos
= frame
.bevel_w
* 2;
2615 style
->doJustify(client
.title
.c_str(), pos
, frame
.label_w
, frame
.bevel_w
* 4);
2616 style
->font
->drawString(frame
.label
, pos
, 1,
2617 (flags
.focused
? style
->l_text_focus
:
2618 style
->l_text_unfocus
),
2623 void BlackboxWindow::redrawAllButtons(void) const {
2624 if (frame
.iconify_button
) redrawIconifyButton(False
);
2625 if (frame
.maximize_button
) redrawMaximizeButton(flags
.maximized
);
2626 if (frame
.close_button
) redrawCloseButton(False
);
2627 if (frame
.stick_button
) redrawStickyButton(flags
.stuck
);
2631 void BlackboxWindow::redrawButton(bool pressed
, Window win
,
2632 Pixmap fppix
, unsigned long fppixel
,
2633 Pixmap uppix
, unsigned long uppixel
,
2634 Pixmap fpix
, unsigned long fpixel
,
2635 Pixmap upix
, unsigned long upixel
) const {
2640 if (flags
.focused
) {
2648 if (flags
.focused
) {
2658 XSetWindowBackgroundPixmap(blackbox
->getXDisplay(), win
, p
);
2660 XSetWindowBackground(blackbox
->getXDisplay(), win
, pix
);
2664 void BlackboxWindow::redrawIconifyButton(bool pressed
) const {
2665 redrawButton(pressed
, frame
.iconify_button
,
2666 frame
.pfbutton
, frame
.pfbutton_pixel
,
2667 frame
.pubutton
, frame
.pubutton_pixel
,
2668 frame
.fbutton
, frame
.fbutton_pixel
,
2669 frame
.ubutton
, frame
.ubutton_pixel
);
2671 XClearWindow(blackbox
->getXDisplay(), frame
.iconify_button
);
2672 BPen
pen((flags
.focused
) ? screen
->getWindowStyle()->b_pic_focus
:
2673 screen
->getWindowStyle()->b_pic_unfocus
);
2675 #ifdef BITMAPBUTTONS
2676 PixmapMask pm
= screen
->getWindowStyle()->icon_button
;
2678 if (screen
->getWindowStyle()->icon_button
.mask
!= None
) {
2679 XSetClipMask(blackbox
->getXDisplay(), pen
.gc(), pm
.mask
);
2680 XSetClipOrigin(blackbox
->getXDisplay(), pen
.gc(),
2681 (frame
.button_w
- pm
.w
)/2, (frame
.button_w
- pm
.h
)/2);
2683 XFillRectangle(blackbox
->getXDisplay(), frame
.iconify_button
, pen
.gc(),
2684 (frame
.button_w
- pm
.w
)/2, (frame
.button_w
- pm
.h
)/2,
2685 (frame
.button_w
+ pm
.w
)/2, (frame
.button_w
+ pm
.h
)/2);
2687 XSetClipMask(blackbox
->getXDisplay(), pen
.gc(), None
);
2688 XSetClipOrigin(blackbox
->getXDisplay(), pen
.gc(), 0, 0);
2690 #endif // BITMAPBUTTONS
2691 XDrawRectangle(blackbox
->getXDisplay(), frame
.iconify_button
, pen
.gc(),
2692 2, (frame
.button_w
- 5), (frame
.button_w
- 5), 2);
2693 #ifdef BITMAPBUTTONS
2695 #endif // BITMAPBUTTONS
2699 void BlackboxWindow::redrawMaximizeButton(bool pressed
) const {
2700 redrawButton(pressed
, frame
.maximize_button
,
2701 frame
.pfbutton
, frame
.pfbutton_pixel
,
2702 frame
.pubutton
, frame
.pubutton_pixel
,
2703 frame
.fbutton
, frame
.fbutton_pixel
,
2704 frame
.ubutton
, frame
.ubutton_pixel
);
2706 XClearWindow(blackbox
->getXDisplay(), frame
.maximize_button
);
2708 BPen
pen((flags
.focused
) ? screen
->getWindowStyle()->b_pic_focus
:
2709 screen
->getWindowStyle()->b_pic_unfocus
);
2711 #ifdef BITMAPBUTTONS
2712 PixmapMask pm
= screen
->getWindowStyle()->max_button
;
2714 if (pm
.mask
!= None
) {
2715 XSetClipMask(blackbox
->getXDisplay(), pen
.gc(), pm
.mask
);
2716 XSetClipOrigin(blackbox
->getXDisplay(), pen
.gc(),
2717 (frame
.button_w
- pm
.w
)/2, (frame
.button_w
- pm
.h
)/2);
2719 XFillRectangle(blackbox
->getXDisplay(), frame
.maximize_button
, pen
.gc(),
2720 (frame
.button_w
- pm
.w
)/2, (frame
.button_w
- pm
.h
)/2,
2721 (frame
.button_w
+ pm
.w
)/2, (frame
.button_w
+ pm
.h
)/2);
2723 XSetClipOrigin(blackbox
->getXDisplay(), pen
.gc(), 0, 0 );
2724 XSetClipMask( blackbox
->getXDisplay(), pen
.gc(), None
);
2726 #endif // BITMAPBUTTONS
2727 XDrawRectangle(blackbox
->getXDisplay(), frame
.maximize_button
, pen
.gc(),
2728 2, 2, (frame
.button_w
- 5), (frame
.button_w
- 5));
2729 XDrawLine(blackbox
->getXDisplay(), frame
.maximize_button
, pen
.gc(),
2730 2, 3, (frame
.button_w
- 3), 3);
2731 #ifdef BITMAPBUTTONS
2733 #endif // BITMAPBUTTONS
2737 void BlackboxWindow::redrawCloseButton(bool pressed
) const {
2738 redrawButton(pressed
, frame
.close_button
,
2739 frame
.pfbutton
, frame
.pfbutton_pixel
,
2740 frame
.pubutton
, frame
.pubutton_pixel
,
2741 frame
.fbutton
, frame
.fbutton_pixel
,
2742 frame
.ubutton
, frame
.ubutton_pixel
);
2744 XClearWindow(blackbox
->getXDisplay(), frame
.close_button
);
2746 BPen
pen((flags
.focused
) ? screen
->getWindowStyle()->b_pic_focus
:
2747 screen
->getWindowStyle()->b_pic_unfocus
);
2749 #ifdef BITMAPBUTTONS
2750 PixmapMask pm
= screen
->getWindowStyle()->close_button
;
2752 if (pm
.mask
!= None
) {
2753 XSetClipMask(blackbox
->getXDisplay(), pen
.gc(), pm
.mask
);
2754 XSetClipOrigin(blackbox
->getXDisplay(), pen
.gc(),
2755 (frame
.button_w
- pm
.w
)/2, (frame
.button_w
- pm
.h
)/2);
2757 XFillRectangle(blackbox
->getXDisplay(), frame
.close_button
, pen
.gc(),
2758 (frame
.button_w
- pm
.w
)/2, (frame
.button_w
- pm
.h
)/2,
2759 (frame
.button_w
+ pm
.w
)/2, (frame
.button_w
+ pm
.h
)/2);
2762 XSetClipOrigin(blackbox
->getXDisplay(), pen
.gc(), 0, 0 );
2763 XSetClipMask( blackbox
->getXDisplay(), pen
.gc(), None
);
2765 #endif // BITMAPBUTTONS
2766 XDrawLine(blackbox
->getXDisplay(), frame
.close_button
, pen
.gc(),
2767 2, 2, (frame
.button_w
- 3), (frame
.button_w
- 3));
2768 XDrawLine(blackbox
->getXDisplay(), frame
.close_button
, pen
.gc(),
2769 2, (frame
.button_w
- 3), (frame
.button_w
- 3), 2);
2770 #ifdef BITMAPBUTTONS
2772 #endif // BITMAPBUTTONS
2775 void BlackboxWindow::redrawStickyButton(bool pressed
) const {
2776 redrawButton(pressed
, frame
.stick_button
,
2777 frame
.pfbutton
, frame
.pfbutton_pixel
,
2778 frame
.pubutton
, frame
.pubutton_pixel
,
2779 frame
.fbutton
, frame
.fbutton_pixel
,
2780 frame
.ubutton
, frame
.ubutton_pixel
);
2782 XClearWindow(blackbox
->getXDisplay(), frame
.stick_button
);
2784 BPen
pen((flags
.focused
) ? screen
->getWindowStyle()->b_pic_focus
:
2785 screen
->getWindowStyle()->b_pic_unfocus
);
2787 #ifdef BITMAPBUTTONS
2788 PixmapMask pm
= screen
->getWindowStyle()->stick_button
;
2790 if (pm
.mask
!= None
) {
2791 XSetClipMask(blackbox
->getXDisplay(), pen
.gc(), pm
.mask
);
2792 XSetClipOrigin(blackbox
->getXDisplay(), pen
.gc(),
2793 (frame
.button_w
- pm
.w
)/2, (frame
.button_w
- pm
.h
)/2);
2795 XFillRectangle(blackbox
->getXDisplay(), frame
.stick_button
, pen
.gc(),
2796 (frame
.button_w
- pm
.w
)/2, (frame
.button_w
- pm
.h
)/2,
2797 (frame
.button_w
+ pm
.w
)/2, (frame
.button_w
+ pm
.h
)/2);
2800 XSetClipOrigin(blackbox
->getXDisplay(), pen
.gc(), 0, 0 );
2801 XSetClipMask( blackbox
->getXDisplay(), pen
.gc(), None
);
2803 #endif // BITMAPBUTTONS
2804 XFillRectangle(blackbox
->getXDisplay(), frame
.stick_button
, pen
.gc(),
2805 frame
.button_w
/2 - 1, frame
.button_w
/2 -1, 2, 2 );
2806 #ifdef BITMAPBUTTONS
2811 void BlackboxWindow::mapRequestEvent(const XMapRequestEvent
*re
) {
2812 if (re
->window
!= client
.window
)
2816 fprintf(stderr
, "BlackboxWindow::mapRequestEvent() for 0x%lx\n",
2821 Even though the window wants to be shown, if it is not on the current
2822 workspace, then it isn't going to be shown right now.
2824 if (! flags
.stuck
&&
2825 blackbox_attrib
.workspace
!= screen
->getCurrentWorkspaceID() &&
2826 blackbox_attrib
.workspace
< screen
->getWorkspaceCount())
2827 if (current_state
== NormalState
) current_state
= WithdrawnState
;
2829 switch (current_state
) {
2834 case WithdrawnState
:
2843 screen
->getWorkspace(blackbox_attrib
.workspace
)->raiseWindow(this);
2845 if (! blackbox
->isStartup()) {
2846 XSync(blackbox
->getXDisplay(), False
); // make sure the frame is mapped
2847 if (screen
->doFocusNew() || (isTransient() && getTransientFor() &&
2848 getTransientFor()->isFocused())) {
2851 if (screen
->getPlacementPolicy() == BScreen::ClickMousePlacement
) {
2855 XQueryPointer(blackbox
->getXDisplay(), screen
->getRootWindow(),
2856 &r
, &c
, &rx
, &ry
, &x
, &y
, &m
);
2866 void BlackboxWindow::unmapNotifyEvent(const XUnmapEvent
*ue
) {
2867 if (ue
->window
!= client
.window
)
2871 fprintf(stderr
, "BlackboxWindow::unmapNotifyEvent() for 0x%lx\n",
2875 screen
->unmanageWindow(this, False
);
2879 void BlackboxWindow::destroyNotifyEvent(const XDestroyWindowEvent
*de
) {
2880 if (de
->window
!= client
.window
)
2884 fprintf(stderr
, "BlackboxWindow::destroyNotifyEvent() for 0x%lx\n",
2888 screen
->unmanageWindow(this, False
);
2892 void BlackboxWindow::reparentNotifyEvent(const XReparentEvent
*re
) {
2893 if (re
->window
!= client
.window
|| re
->parent
== frame
.plate
)
2897 fprintf(stderr
, "BlackboxWindow::reparentNotifyEvent(): reparent 0x%lx to "
2898 "0x%lx.\n", client
.window
, re
->parent
);
2903 XPutBackEvent(blackbox
->getXDisplay(), &ev
);
2904 screen
->unmanageWindow(this, True
);
2908 void BlackboxWindow::propertyNotifyEvent(const XPropertyEvent
*pe
) {
2909 if (pe
->state
== PropertyDelete
|| ! validateClient())
2913 fprintf(stderr
, "BlackboxWindow::propertyNotifyEvent(): for 0x%lx\n",
2919 case XA_WM_CLIENT_MACHINE
:
2923 case XA_WM_TRANSIENT_FOR
: {
2924 bool s
= flags
.stuck
;
2926 // determine if this is a transient window
2929 if (flags
.stuck
!= s
) stick();
2931 // adjust the window decorations based on transience
2932 if (isTransient()) {
2933 functions
&= ~Func_Maximize
;
2934 setAllowedActions();
2946 case XA_WM_ICON_NAME
:
2948 if (flags
.iconic
) screen
->propagateWindowName(this);
2951 case XAtom::net_wm_name
:
2955 if (decorations
& Decor_Titlebar
)
2958 screen
->propagateWindowName(this);
2961 case XA_WM_NORMAL_HINTS
: {
2964 if ((client
.normal_hint_flags
& PMinSize
) &&
2965 (client
.normal_hint_flags
& PMaxSize
)) {
2966 // the window now can/can't resize itself, so the buttons need to be
2969 if (client
.max_width
<= client
.min_width
&&
2970 client
.max_height
<= client
.min_height
) {
2971 functions
&= ~(Func_Resize
| Func_Maximize
);
2973 if (! isTransient())
2974 functions
|= Func_Maximize
;
2975 functions
|= Func_Resize
;
2978 setAllowedActions();
2982 Rect old_rect
= frame
.rect
;
2986 if (old_rect
!= frame
.rect
)
2993 if (pe
->atom
== xatom
->getAtom(XAtom::wm_protocols
)) {
2996 if ((decorations
& Decor_Close
) && (! frame
.close_button
)) {
2997 createCloseButton();
2998 if (decorations
& Decor_Titlebar
) {
2999 positionButtons(True
);
3000 XMapSubwindows(blackbox
->getXDisplay(), frame
.title
);
3002 if (windowmenu
) windowmenu
->reconfigure();
3004 } else if (pe
->atom
== xatom
->getAtom(XAtom::net_wm_strut
)) {
3013 void BlackboxWindow::exposeEvent(const XExposeEvent
*ee
) {
3015 fprintf(stderr
, "BlackboxWindow::exposeEvent() for 0x%lx\n", client
.window
);
3018 if (frame
.label
== ee
->window
&& (decorations
& Decor_Titlebar
))
3020 else if (frame
.close_button
== ee
->window
)
3021 redrawCloseButton(False
);
3022 else if (frame
.maximize_button
== ee
->window
)
3023 redrawMaximizeButton(flags
.maximized
);
3024 else if (frame
.iconify_button
== ee
->window
)
3025 redrawIconifyButton(False
);
3026 else if (frame
.stick_button
== ee
->window
)
3027 redrawStickyButton(flags
.stuck
);
3031 void BlackboxWindow::configureRequestEvent(const XConfigureRequestEvent
*cr
) {
3032 if (cr
->window
!= client
.window
|| flags
.iconic
)
3035 if (cr
->value_mask
& CWBorderWidth
)
3036 client
.old_bw
= cr
->border_width
;
3038 if (cr
->value_mask
& (CWX
| CWY
| CWWidth
| CWHeight
)) {
3039 frame
.changing
= frame
.rect
;
3041 if (cr
->value_mask
& (CWX
| CWY
)) {
3042 if (cr
->value_mask
& CWX
)
3043 client
.rect
.setX(cr
->x
);
3044 if (cr
->value_mask
& CWY
)
3045 client
.rect
.setY(cr
->y
);
3047 applyGravity(frame
.changing
);
3050 if (cr
->value_mask
& (CWWidth
| CWHeight
)) {
3051 if (cr
->value_mask
& CWWidth
)
3052 frame
.changing
.setWidth(cr
->width
+
3053 frame
.margin
.left
+ frame
.margin
.right
);
3055 if (cr
->value_mask
& CWHeight
)
3056 frame
.changing
.setHeight(cr
->height
+
3057 frame
.margin
.top
+ frame
.margin
.bottom
);
3060 if a position change has been specified, then that position will be
3061 used instead of determining a position based on the window's gravity.
3063 if (! (cr
->value_mask
& (CWX
| CWY
))) {
3065 switch (client
.win_gravity
) {
3066 case NorthEastGravity
:
3070 case SouthWestGravity
:
3072 corner
= BottomLeft
;
3074 case SouthEastGravity
:
3075 corner
= BottomRight
;
3077 default: // NorthWest, Static, etc
3084 configure(frame
.changing
.x(), frame
.changing
.y(),
3085 frame
.changing
.width(), frame
.changing
.height());
3088 if (cr
->value_mask
& CWStackMode
&& !isDesktop()) {
3089 switch (cr
->detail
) {
3092 screen
->getWorkspace(blackbox_attrib
.workspace
)->lowerWindow(this);
3098 screen
->getWorkspace(blackbox_attrib
.workspace
)->raiseWindow(this);
3105 void BlackboxWindow::buttonPressEvent(const XButtonEvent
*be
) {
3107 fprintf(stderr
, "BlackboxWindow::buttonPressEvent() for 0x%lx\n",
3111 if (frame
.maximize_button
== be
->window
&& be
->button
<= 3) {
3112 redrawMaximizeButton(True
);
3113 } else if (be
->button
== 1 || (be
->button
== 3 && be
->state
== mod_mask
)) {
3114 if (! flags
.focused
)
3117 if (frame
.iconify_button
== be
->window
) {
3118 redrawIconifyButton(True
);
3119 } else if (frame
.close_button
== be
->window
) {
3120 redrawCloseButton(True
);
3121 } else if (frame
.stick_button
== be
->window
) {
3122 redrawStickyButton(True
);
3123 } else if (frame
.plate
== be
->window
) {
3124 if (windowmenu
&& windowmenu
->isVisible()) windowmenu
->hide();
3126 screen
->getWorkspace(blackbox_attrib
.workspace
)->raiseWindow(this);
3128 XAllowEvents(blackbox
->getXDisplay(), ReplayPointer
, be
->time
);
3130 if (frame
.title
== be
->window
|| frame
.label
== be
->window
) {
3131 if (((be
->time
- lastButtonPressTime
) <=
3132 blackbox
->getDoubleClickInterval()) ||
3133 (be
->state
== ControlMask
)) {
3134 lastButtonPressTime
= 0;
3137 lastButtonPressTime
= be
->time
;
3141 if (windowmenu
&& windowmenu
->isVisible()) windowmenu
->hide();
3143 screen
->getWorkspace(blackbox_attrib
.workspace
)->raiseWindow(this);
3145 } else if (be
->button
== 2 && (be
->window
!= frame
.iconify_button
) &&
3146 (be
->window
!= frame
.close_button
) &&
3147 (be
->window
!= frame
.stick_button
)) {
3148 screen
->getWorkspace(blackbox_attrib
.workspace
)->lowerWindow(this);
3149 } else if (windowmenu
&& be
->button
== 3 &&
3150 (frame
.title
== be
->window
|| frame
.label
== be
->window
||
3151 frame
.handle
== be
->window
|| frame
.window
== be
->window
)) {
3152 if (windowmenu
->isVisible()) {
3155 int mx
= be
->x_root
- windowmenu
->getWidth() / 2,
3156 my
= be
->y_root
- windowmenu
->getHeight() / 2;
3158 // snap the window menu into a corner/side if necessary
3159 int left_edge
, right_edge
, top_edge
, bottom_edge
;
3162 the " + (frame.border_w * 2) - 1" bits are to get the proper width
3163 and height of the menu, as the sizes returned by it do not include
3166 left_edge
= frame
.rect
.x();
3167 right_edge
= frame
.rect
.right() -
3168 (windowmenu
->getWidth() + (frame
.border_w
* 2) - 1);
3169 top_edge
= client
.rect
.top() - (frame
.border_w
+ frame
.mwm_border_w
);
3170 bottom_edge
= client
.rect
.bottom() -
3171 (windowmenu
->getHeight() + (frame
.border_w
* 2) - 1) +
3172 (frame
.border_w
+ frame
.mwm_border_w
);
3176 else if (mx
> right_edge
)
3180 else if (my
> bottom_edge
)
3183 if (my
+ windowmenu
->getHeight() > screen
->getHeight())
3184 my
= screen
->getHeight() - windowmenu
->getHeight() -
3185 (screen
->getBorderWidth() * 2);
3187 windowmenu
->move(mx
, my
);
3189 XRaiseWindow(blackbox
->getXDisplay(), windowmenu
->getWindowID());
3190 XRaiseWindow(blackbox
->getXDisplay(),
3191 windowmenu
->getSendToMenu()->getWindowID());
3194 } else if (be
->button
== 4) {
3195 if ((be
->window
== frame
.label
||
3196 be
->window
== frame
.title
||
3197 be
->window
== frame
.maximize_button
||
3198 be
->window
== frame
.iconify_button
||
3199 be
->window
== frame
.close_button
||
3200 be
->window
== frame
.stick_button
) &&
3204 } else if (be
->button
== 5) {
3205 if ((be
->window
== frame
.label
||
3206 be
->window
== frame
.title
||
3207 be
->window
== frame
.maximize_button
||
3208 be
->window
== frame
.iconify_button
||
3209 be
->window
== frame
.close_button
||
3210 be
->window
== frame
.stick_button
) &&
3217 void BlackboxWindow::buttonReleaseEvent(const XButtonEvent
*re
) {
3219 fprintf(stderr
, "BlackboxWindow::buttonReleaseEvent() for 0x%lx\n",
3223 if (re
->window
== frame
.maximize_button
&&
3224 re
->button
>= 1 && re
->button
<= 3) {
3225 if ((re
->x
>= 0 && re
->x
<= static_cast<signed>(frame
.button_w
)) &&
3226 (re
->y
>= 0 && re
->y
<= static_cast<signed>(frame
.button_w
))) {
3227 maximize(re
->button
);
3229 redrawMaximizeButton(flags
.maximized
);
3231 } else if (re
->window
== frame
.iconify_button
&& re
->button
== 1) {
3232 if ((re
->x
>= 0 && re
->x
<= static_cast<signed>(frame
.button_w
)) &&
3233 (re
->y
>= 0 && re
->y
<= static_cast<signed>(frame
.button_w
))) {
3236 redrawIconifyButton(False
);
3238 } else if (re
->window
== frame
.stick_button
&& re
->button
== 1) {
3239 if ((re
->x
>= 0 && re
->x
<= static_cast<signed>(frame
.button_w
)) &&
3240 (re
->y
>= 0 && re
->y
<= static_cast<signed>(frame
.button_w
))) {
3243 redrawStickyButton(False
);
3245 } else if (re
->window
== frame
.close_button
& re
->button
== 1) {
3246 if ((re
->x
>= 0 && re
->x
<= static_cast<signed>(frame
.button_w
)) &&
3247 (re
->y
>= 0 && re
->y
<= static_cast<signed>(frame
.button_w
)))
3249 redrawCloseButton(False
);
3250 } else if (flags
.moving
) {
3252 } else if (flags
.resizing
) {
3254 } else if (re
->window
== frame
.window
) {
3255 if (re
->button
== 2 && re
->state
== mod_mask
)
3256 XUngrabPointer(blackbox
->getXDisplay(), CurrentTime
);
3262 void BlackboxWindow::beginMove(int x_root
, int y_root
) {
3263 if (! (functions
& Func_Move
)) return;
3265 assert(! (flags
.resizing
|| flags
.moving
));
3268 Only one window can be moved/resized at a time. If another window is already
3269 being moved or resized, then stop it before whating to work with this one.
3271 BlackboxWindow
*changing
= blackbox
->getChangingWindow();
3272 if (changing
&& changing
!= this) {
3273 if (changing
->flags
.moving
)
3274 changing
->endMove();
3275 else // if (changing->flags.resizing)
3276 changing
->endResize();
3279 XGrabPointer(blackbox
->getXDisplay(), frame
.window
, False
,
3280 PointerMotionMask
| ButtonReleaseMask
,
3281 GrabModeAsync
, GrabModeAsync
,
3282 None
, blackbox
->getMoveCursor(), CurrentTime
);
3284 if (windowmenu
&& windowmenu
->isVisible())
3287 flags
.moving
= True
;
3288 blackbox
->setChangingWindow(this);
3290 if (! screen
->doOpaqueMove()) {
3291 XGrabServer(blackbox
->getXDisplay());
3293 frame
.changing
= frame
.rect
;
3294 screen
->showPosition(frame
.changing
.x(), frame
.changing
.y());
3296 XDrawRectangle(blackbox
->getXDisplay(), screen
->getRootWindow(),
3300 frame
.changing
.width() - 1,
3301 frame
.changing
.height() - 1);
3304 frame
.grab_x
= x_root
- frame
.rect
.x() - frame
.border_w
;
3305 frame
.grab_y
= y_root
- frame
.rect
.y() - frame
.border_w
;
3309 void BlackboxWindow::doMove(int x_root
, int y_root
) {
3310 assert(flags
.moving
);
3311 assert(blackbox
->getChangingWindow() == this);
3313 int dx
= x_root
- frame
.grab_x
, dy
= y_root
- frame
.grab_y
;
3314 dx
-= frame
.border_w
;
3315 dy
-= frame
.border_w
;
3317 doWindowSnapping(dx
, dy
);
3319 if (screen
->doOpaqueMove()) {
3320 if (screen
->doWorkspaceWarping())
3321 doWorkspaceWarping(x_root
, y_root
, dx
);
3323 configure(dx
, dy
, frame
.rect
.width(), frame
.rect
.height());
3325 XDrawRectangle(blackbox
->getXDisplay(), screen
->getRootWindow(),
3329 frame
.changing
.width() - 1,
3330 frame
.changing
.height() - 1);
3332 if (screen
->doWorkspaceWarping())
3333 doWorkspaceWarping(x_root
, y_root
, dx
);
3335 frame
.changing
.setPos(dx
, dy
);
3337 XDrawRectangle(blackbox
->getXDisplay(), screen
->getRootWindow(),
3341 frame
.changing
.width() - 1,
3342 frame
.changing
.height() - 1);
3345 screen
->showPosition(dx
, dy
);
3349 void BlackboxWindow::doWorkspaceWarping(int x_root
, int y_root
, int &dx
) {
3350 // workspace warping
3352 unsigned int dest
= screen
->getCurrentWorkspaceID();
3356 if (dest
> 0) dest
--;
3357 else dest
= screen
->getNumberOfWorkspaces() - 1;
3359 } else if (x_root
>= screen
->getRect().right()) {
3362 if (dest
< screen
->getNumberOfWorkspaces() - 1) dest
++;
3368 bool focus
= flags
.focused
; // had focus while moving?
3370 int dest_x
= x_root
;
3372 dest_x
+= screen
->getRect().width() - 1;
3373 dx
+= screen
->getRect().width() - 1;
3375 dest_x
-= screen
->getRect().width() - 1;
3376 dx
-= screen
->getRect().width() - 1;
3380 screen
->reassociateWindow(this, dest
, False
);
3381 screen
->changeWorkspaceID(dest
);
3383 if (screen
->doOpaqueMove())
3384 XGrabServer(blackbox
->getXDisplay());
3386 XUngrabPointer(blackbox
->getXDisplay(), CurrentTime
);
3387 XWarpPointer(blackbox
->getXDisplay(), None
,
3388 screen
->getRootWindow(), 0, 0, 0, 0,
3390 XGrabPointer(blackbox
->getXDisplay(), frame
.window
, False
,
3391 PointerMotionMask
| ButtonReleaseMask
,
3392 GrabModeAsync
, GrabModeAsync
,
3393 None
, blackbox
->getMoveCursor(), CurrentTime
);
3395 if (screen
->doOpaqueMove())
3396 XUngrabServer(blackbox
->getXDisplay());
3404 void BlackboxWindow::doWindowSnapping(int &dx
, int &dy
) {
3405 // how much resistance to edges to provide
3406 const int resistance_size
= screen
->getResistanceSize();
3408 // how far away to snap
3409 const int snap_distance
= screen
->getSnapThreshold();
3411 // how to snap windows
3412 const int snap_to_windows
= screen
->getWindowToWindowSnap();
3413 const int snap_to_edges
= screen
->getWindowToEdgeSnap();
3414 // the amount of space away from the edge to provide resistance/snap
3415 const int snap_offset
= screen
->getSnapOffset();
3417 // find the geomeetery where the moving window currently is
3418 const Rect
&moving
= screen
->doOpaqueMove() ? frame
.rect
: frame
.changing
;
3421 const int wleft
= dx
,
3422 wright
= dx
+ frame
.rect
.width() - 1,
3424 wbottom
= dy
+ frame
.rect
.height() - 1;
3426 if (snap_to_windows
) {
3429 Workspace
*w
= screen
->getWorkspace(getWorkspaceNumber());
3432 // add windows on the workspace to the rect list
3433 const BlackboxWindowList
& stack_list
= w
->getStackingList();
3434 BlackboxWindowList::const_iterator st_it
, st_end
= stack_list
.end();
3435 for (st_it
= stack_list
.begin(); st_it
!= st_end
; ++st_it
)
3436 if (*st_it
!= this) // don't snap to ourself
3437 rectlist
.push_back( (*st_it
)->frameRect() );
3439 // add the toolbar and the slit to the rect list.
3440 // (only if they are not hidden)
3441 Toolbar
*tbar
= screen
->getToolbar();
3442 Slit
*slit
= screen
->getSlit();
3443 Rect tbar_rect
, slit_rect
;
3444 unsigned int bwidth
= screen
->getBorderWidth() * 2;
3446 if (! (screen
->doHideToolbar() || tbar
->isHidden())) {
3447 tbar_rect
.setRect(tbar
->getX(), tbar
->getY(), tbar
->getWidth() + bwidth
,
3448 tbar
->getHeight() + bwidth
);
3449 rectlist
.push_back(tbar_rect
);
3452 if (! slit
->isHidden()) {
3453 slit_rect
.setRect(slit
->getX(), slit
->getY(), slit
->getWidth() + bwidth
,
3454 slit
->getHeight() + bwidth
);
3455 rectlist
.push_back(slit_rect
);
3458 RectList::const_iterator it
, end
= rectlist
.end();
3459 for (it
= rectlist
.begin(); it
!= end
; ++it
) {
3460 bool snapped
= False
;
3461 const Rect
&winrect
= *it
;
3463 offsetrect
.setCoords(winrect
.left() - snap_offset
,
3464 winrect
.top() - snap_offset
,
3465 winrect
.right() + snap_offset
,
3466 winrect
.bottom() + snap_offset
);
3468 if (snap_to_windows
== BScreen::WindowResistance
)
3469 // if the window is already over top of this snap target, then
3470 // resistance is futile, so just ignore it
3471 if (winrect
.intersects(moving
))
3474 int dleft
, dright
, dtop
, dbottom
;
3476 // if the windows are in the same plane vertically
3477 if (wtop
>= (signed)(winrect
.y() - frame
.rect
.height() + 1) &&
3478 wtop
< (signed)(winrect
.y() + winrect
.height() - 1)) {
3480 if (snap_to_windows
== BScreen::WindowResistance
) {
3481 dleft
= wright
- offsetrect
.left();
3482 dright
= offsetrect
.right() - wleft
;
3484 // snap left of other window?
3485 if (dleft
>= 0 && dleft
< resistance_size
&&
3486 dleft
< (wright
- wleft
)) {
3487 dx
= offsetrect
.left() - frame
.rect
.width();
3490 // snap right of other window?
3491 else if (dright
>= 0 && dright
< resistance_size
&&
3492 dright
< (wright
- wleft
)) {
3493 dx
= offsetrect
.right() + 1;
3496 } else { // BScreen::WindowSnap
3497 dleft
= abs(wright
- offsetrect
.left());
3498 dright
= abs(wleft
- offsetrect
.right());
3500 // snap left of other window?
3501 if (dleft
< snap_distance
&& dleft
<= dright
) {
3502 dx
= offsetrect
.left() - frame
.rect
.width();
3505 // snap right of other window?
3506 else if (dright
< snap_distance
) {
3507 dx
= offsetrect
.right() + 1;
3513 if (screen
->getWindowCornerSnap()) {
3514 // try corner-snap to its other sides
3515 if (snap_to_windows
== BScreen::WindowResistance
) {
3516 dtop
= winrect
.top() - wtop
;
3517 dbottom
= wbottom
- winrect
.bottom();
3518 if (dtop
> 0 && dtop
< resistance_size
) {
3519 // if we're already past the top edge, then don't provide
3521 if (moving
.top() >= winrect
.top())
3523 } else if (dbottom
> 0 && dbottom
< resistance_size
) {
3524 // if we're already past the bottom edge, then don't provide
3526 if (moving
.bottom() <= winrect
.bottom())
3527 dy
= winrect
.bottom() - frame
.rect
.height() + 1;
3529 } else { // BScreen::WindowSnap
3530 dtop
= abs(wtop
- winrect
.top());
3531 dbottom
= abs(wbottom
- winrect
.bottom());
3532 if (dtop
< snap_distance
&& dtop
<= dbottom
)
3534 else if (dbottom
< snap_distance
)
3535 dy
= winrect
.bottom() - frame
.rect
.height() + 1;
3543 // if the windows are on the same plane horizontally
3544 if (wleft
>= (signed)(winrect
.x() - frame
.rect
.width() + 1) &&
3545 wleft
< (signed)(winrect
.x() + winrect
.width() - 1)) {
3547 if (snap_to_windows
== BScreen::WindowResistance
) {
3548 dtop
= wbottom
- offsetrect
.top();
3549 dbottom
= offsetrect
.bottom() - wtop
;
3551 // snap top of other window?
3552 if (dtop
>= 0 && dtop
< resistance_size
&& dtop
< (wbottom
- wtop
)) {
3553 dy
= offsetrect
.top() - frame
.rect
.height();
3556 // snap bottom of other window?
3557 else if (dbottom
>= 0 && dbottom
< resistance_size
&&
3558 dbottom
< (wbottom
- wtop
)) {
3559 dy
= offsetrect
.bottom() + 1;
3562 } else { // BScreen::WindowSnap
3563 dtop
= abs(wbottom
- offsetrect
.top());
3564 dbottom
= abs(wtop
- offsetrect
.bottom());
3566 // snap top of other window?
3567 if (dtop
< snap_distance
&& dtop
<= dbottom
) {
3568 dy
= offsetrect
.top() - frame
.rect
.height();
3571 // snap bottom of other window?
3572 else if (dbottom
< snap_distance
) {
3573 dy
= offsetrect
.bottom() + 1;
3580 if (screen
->getWindowCornerSnap()) {
3581 // try corner-snap to its other sides
3582 if (snap_to_windows
== BScreen::WindowResistance
) {
3583 dleft
= winrect
.left() - wleft
;
3584 dright
= wright
- winrect
.right();
3585 if (dleft
> 0 && dleft
< resistance_size
) {
3586 // if we're already past the left edge, then don't provide
3588 if (moving
.left() >= winrect
.left())
3589 dx
= winrect
.left();
3590 } else if (dright
> 0 && dright
< resistance_size
) {
3591 // if we're already past the right edge, then don't provide
3593 if (moving
.right() <= winrect
.right())
3594 dx
= winrect
.right() - frame
.rect
.width() + 1;
3596 } else { // BScreen::WindowSnap
3597 dleft
= abs(wleft
- winrect
.left());
3598 dright
= abs(wright
- winrect
.right());
3599 if (dleft
< snap_distance
&& dleft
<= dright
)
3600 dx
= winrect
.left();
3601 else if (dright
< snap_distance
)
3602 dx
= winrect
.right() - frame
.rect
.width() + 1;
3612 if (snap_to_edges
) {
3615 // snap to the screen edges (and screen boundaries for xinerama)
3617 if (screen
->isXineramaActive() && blackbox
->doXineramaSnapping()) {
3618 rectlist
.insert(rectlist
.begin(),
3619 screen
->getXineramaAreas().begin(),
3620 screen
->getXineramaAreas().end());
3623 rectlist
.push_back(screen
->getRect());
3625 RectList::const_iterator it
, end
= rectlist
.end();
3626 for (it
= rectlist
.begin(); it
!= end
; ++it
) {
3627 const Rect
&srect
= *it
;
3629 offsetrect
.setCoords(srect
.left() + snap_offset
,
3630 srect
.top() + snap_offset
,
3631 srect
.right() - snap_offset
,
3632 srect
.bottom() - snap_offset
);
3634 if (snap_to_edges
== BScreen::WindowResistance
) {
3635 // if we're not in the rectangle then don't snap to it.
3636 if (! srect
.contains(moving
))
3638 } else { // BScreen::WindowSnap
3639 // if we're not in the rectangle then don't snap to it.
3640 if (! srect
.intersects(Rect(wleft
, wtop
, frame
.rect
.width(),
3641 frame
.rect
.height())))
3645 if (snap_to_edges
== BScreen::WindowResistance
) {
3646 int dleft
= offsetrect
.left() - wleft
,
3647 dright
= wright
- offsetrect
.right(),
3648 dtop
= offsetrect
.top() - wtop
,
3649 dbottom
= wbottom
- offsetrect
.bottom();
3652 if (dleft
> 0 && dleft
< resistance_size
)
3653 dx
= offsetrect
.left();
3655 else if (dright
> 0 && dright
< resistance_size
)
3656 dx
= offsetrect
.right() - frame
.rect
.width() + 1;
3659 if (dtop
> 0 && dtop
< resistance_size
)
3660 dy
= offsetrect
.top();
3662 else if (dbottom
> 0 && dbottom
< resistance_size
)
3663 dy
= offsetrect
.bottom() - frame
.rect
.height() + 1;
3664 } else { // BScreen::WindowSnap
3665 int dleft
= abs(wleft
- offsetrect
.left()),
3666 dright
= abs(wright
- offsetrect
.right()),
3667 dtop
= abs(wtop
- offsetrect
.top()),
3668 dbottom
= abs(wbottom
- offsetrect
.bottom());
3671 if (dleft
< snap_distance
&& dleft
<= dright
)
3672 dx
= offsetrect
.left();
3674 else if (dright
< snap_distance
)
3675 dx
= offsetrect
.right() - frame
.rect
.width() + 1;
3678 if (dtop
< snap_distance
&& dtop
<= dbottom
)
3679 dy
= offsetrect
.top();
3681 else if (dbottom
< snap_distance
)
3682 dy
= offsetrect
.bottom() - frame
.rect
.height() + 1;
3689 void BlackboxWindow::endMove(void) {
3690 assert(flags
.moving
);
3691 assert(blackbox
->getChangingWindow() == this);
3693 flags
.moving
= False
;
3694 blackbox
->setChangingWindow(0);
3696 if (! screen
->doOpaqueMove()) {
3697 /* when drawing the rubber band, we need to make sure we only draw inside
3698 * the frame... frame.changing_* contain the new coords for the window,
3699 * so we need to subtract 1 from changing_w/changing_h every where we
3700 * draw the rubber band (for both moving and resizing)
3702 XDrawRectangle(blackbox
->getXDisplay(), screen
->getRootWindow(),
3703 screen
->getOpGC(), frame
.changing
.x(), frame
.changing
.y(),
3704 frame
.changing
.width() - 1, frame
.changing
.height() - 1);
3705 XUngrabServer(blackbox
->getXDisplay());
3707 configure(frame
.changing
.x(), frame
.changing
.y(),
3708 frame
.changing
.width(), frame
.changing
.height());
3710 configure(frame
.rect
.x(), frame
.rect
.y(),
3711 frame
.rect
.width(), frame
.rect
.height());
3713 screen
->hideGeometry();
3715 XUngrabPointer(blackbox
->getXDisplay(), CurrentTime
);
3717 // if there are any left over motions from the move, drop them now
3718 XSync(blackbox
->getXDisplay(), false); // make sure we don't miss any
3720 while (XCheckTypedWindowEvent(blackbox
->getXDisplay(), frame
.window
,
3725 void BlackboxWindow::beginResize(int x_root
, int y_root
, Corner dir
) {
3726 if (! (functions
& Func_Resize
)) return;
3728 assert(! (flags
.resizing
|| flags
.moving
));
3731 Only one window can be moved/resized at a time. If another window is
3732 already being moved or resized, then stop it before whating to work with
3735 BlackboxWindow
*changing
= blackbox
->getChangingWindow();
3736 if (changing
&& changing
!= this) {
3737 if (changing
->flags
.moving
)
3738 changing
->endMove();
3739 else // if (changing->flags.resizing)
3740 changing
->endResize();
3748 switch (resize_dir
) {
3751 cursor
= blackbox
->getLowerLeftAngleCursor();
3756 cursor
= blackbox
->getLowerRightAngleCursor();
3760 anchor
= BottomRight
;
3761 cursor
= blackbox
->getUpperLeftAngleCursor();
3765 anchor
= BottomLeft
;
3766 cursor
= blackbox
->getUpperRightAngleCursor();
3770 assert(false); // unhandled Corner
3771 return; // unreachable, for the compiler
3774 XGrabServer(blackbox
->getXDisplay());
3775 XGrabPointer(blackbox
->getXDisplay(), frame
.window
, False
,
3776 PointerMotionMask
| ButtonReleaseMask
,
3777 GrabModeAsync
, GrabModeAsync
, None
, cursor
, CurrentTime
);
3779 flags
.resizing
= True
;
3780 blackbox
->setChangingWindow(this);
3782 unsigned int gw
, gh
;
3783 frame
.changing
= frame
.rect
;
3785 constrain(anchor
, &gw
, &gh
);
3787 XDrawRectangle(blackbox
->getXDisplay(), screen
->getRootWindow(),
3788 screen
->getOpGC(), frame
.changing
.x(), frame
.changing
.y(),
3789 frame
.changing
.width() - 1, frame
.changing
.height() - 1);
3791 screen
->showGeometry(gw
, gh
);
3793 frame
.grab_x
= x_root
;
3794 frame
.grab_y
= y_root
;
3798 void BlackboxWindow::doResize(int x_root
, int y_root
) {
3799 assert(flags
.resizing
);
3800 assert(blackbox
->getChangingWindow() == this);
3802 XDrawRectangle(blackbox
->getXDisplay(), screen
->getRootWindow(),
3803 screen
->getOpGC(), frame
.changing
.x(), frame
.changing
.y(),
3804 frame
.changing
.width() - 1, frame
.changing
.height() - 1);
3806 unsigned int gw
, gh
;
3808 int dx
, dy
; // the amount of change in the size of the window
3810 switch (resize_dir
) {
3813 dx
= - (x_root
- frame
.grab_x
);
3814 dy
= + (y_root
- frame
.grab_y
);
3818 dx
= + (x_root
- frame
.grab_x
);
3819 dy
= + (y_root
- frame
.grab_y
);
3822 anchor
= BottomRight
;
3823 dx
= - (x_root
- frame
.grab_x
);
3824 dy
= - (y_root
- frame
.grab_y
);
3827 anchor
= BottomLeft
;
3828 dx
= + (x_root
- frame
.grab_x
);
3829 dy
= - (y_root
- frame
.grab_y
);
3833 assert(false); // unhandled Corner
3834 return; // unreachable, for the compiler
3837 // make sure the user cant resize the window smaller than 0, which makes it
3838 // wrap around and become huge
3839 if (dx
< -(signed)client
.rect
.width()) dx
= -(signed)client
.rect
.width();
3840 if (dy
< -(signed)client
.rect
.height()) dy
= -(signed)client
.rect
.height();
3842 frame
.changing
.setSize(frame
.rect
.width() + dx
, frame
.rect
.height() + dy
);
3844 constrain(anchor
, &gw
, &gh
);
3846 XDrawRectangle(blackbox
->getXDisplay(), screen
->getRootWindow(),
3847 screen
->getOpGC(), frame
.changing
.x(), frame
.changing
.y(),
3848 frame
.changing
.width() - 1, frame
.changing
.height() - 1);
3850 screen
->showGeometry(gw
, gh
);
3854 void BlackboxWindow::endResize(void) {
3855 assert(flags
.resizing
);
3856 assert(blackbox
->getChangingWindow() == this);
3858 XDrawRectangle(blackbox
->getXDisplay(), screen
->getRootWindow(),
3859 screen
->getOpGC(), frame
.changing
.x(), frame
.changing
.y(),
3860 frame
.changing
.width() - 1, frame
.changing
.height() - 1);
3861 XUngrabServer(blackbox
->getXDisplay());
3863 // unset maximized state after resized when fully maximized
3864 if (flags
.maximized
== 1)
3867 flags
.resizing
= False
;
3868 blackbox
->setChangingWindow(0);
3870 configure(frame
.changing
.x(), frame
.changing
.y(),
3871 frame
.changing
.width(), frame
.changing
.height());
3872 screen
->hideGeometry();
3874 XUngrabPointer(blackbox
->getXDisplay(), CurrentTime
);
3876 // if there are any left over motions from the resize, drop them now
3877 XSync(blackbox
->getXDisplay(), false); // make sure we don't miss any
3879 while (XCheckTypedWindowEvent(blackbox
->getXDisplay(), frame
.window
,
3884 void BlackboxWindow::motionNotifyEvent(const XMotionEvent
*me
) {
3886 fprintf(stderr
, "BlackboxWindow::motionNotifyEvent() for 0x%lx\n",
3891 doMove(me
->x_root
, me
->y_root
);
3892 } else if (flags
.resizing
) {
3893 doResize(me
->x_root
, me
->y_root
);
3895 if ((functions
& Func_Move
) &&
3896 (me
->state
& Button1Mask
) &&
3897 (frame
.title
== me
->window
|| frame
.label
== me
->window
||
3898 frame
.handle
== me
->window
|| frame
.window
== me
->window
)) {
3899 beginMove(me
->x_root
, me
->y_root
);
3900 } else if ((functions
& Func_Resize
) &&
3901 ((me
->state
& Button1Mask
) &&
3902 (me
->window
== frame
.right_grip
||
3903 me
->window
== frame
.left_grip
)) ||
3904 ((me
->state
& Button3Mask
) && (me
->state
& mod_mask
) &&
3905 (frame
.title
== me
->window
|| frame
.label
== me
->window
||
3906 frame
.handle
== me
->window
|| frame
.window
== me
->window
||
3907 frame
.right_grip
== me
->window
||
3908 frame
.left_grip
== me
->window
))) {
3909 unsigned int zones
= screen
->getResizeZones();
3912 if (me
->window
== frame
.left_grip
) {
3913 corner
= BottomLeft
;
3914 } else if (me
->window
== frame
.right_grip
|| zones
== 1) {
3915 corner
= BottomRight
;
3918 bool left
= (me
->x_root
- frame
.rect
.x() <=
3919 static_cast<signed>(frame
.rect
.width() / 2));
3922 else // (zones == 4)
3923 top
= (me
->y_root
- frame
.rect
.y() <=
3924 static_cast<signed>(frame
.rect
.height() / 2));
3925 corner
= (top
? (left
? TopLeft
: TopRight
) :
3926 (left
? BottomLeft
: BottomRight
));
3929 beginResize(me
->x_root
, me
->y_root
, corner
);
3935 void BlackboxWindow::enterNotifyEvent(const XCrossingEvent
* ce
) {
3936 if (! (screen
->isSloppyFocus() && isVisible() && isNormal()))
3940 bool leave
= False
, inferior
= False
;
3942 while (XCheckTypedWindowEvent(blackbox
->getXDisplay(), ce
->window
,
3944 if (e
.type
== LeaveNotify
&& e
.xcrossing
.mode
== NotifyNormal
) {
3946 inferior
= (e
.xcrossing
.detail
== NotifyInferior
);
3950 if (! leave
|| inferior
) {
3951 if (! isFocused()) {
3952 bool success
= setInputFocus();
3953 if (success
) // if focus succeeded install the colormap
3954 installColormap(True
); // XXX: shouldnt we honour no install?
3957 We only auto-raise when the window wasn't focused because otherwise
3958 we run into problems with gtk+ drop-down lists. The window ends up
3959 raising over the list.
3961 if (screen
->doAutoRaise())
3968 void BlackboxWindow::leaveNotifyEvent(const XCrossingEvent
*) {
3969 if (! (screen
->isSloppyFocus() && screen
->doAutoRaise() && isNormal()))
3972 installColormap(False
);
3974 if (timer
->isTiming())
3980 void BlackboxWindow::shapeEvent(XShapeEvent
*e
) {
3981 if (blackbox
->hasShapeExtensions()) {
3982 if (! e
->shaped
&& flags
.shaped
) {
3984 flags
.shaped
= False
;
3985 } else if (e
->shaped
) {
3987 flags
.shaped
= True
;
3994 bool BlackboxWindow::validateClient(void) const {
3995 XSync(blackbox
->getXDisplay(), False
);
3998 if (XCheckTypedWindowEvent(blackbox
->getXDisplay(), client
.window
,
3999 DestroyNotify
, &e
) ||
4000 XCheckTypedWindowEvent(blackbox
->getXDisplay(), client
.window
,
4002 XPutBackEvent(blackbox
->getXDisplay(), &e
);
4011 void BlackboxWindow::restore(bool remap
) {
4012 XChangeSaveSet(blackbox
->getXDisplay(), client
.window
, SetModeDelete
);
4013 XSelectInput(blackbox
->getXDisplay(), client
.window
, NoEventMask
);
4014 XSelectInput(blackbox
->getXDisplay(), frame
.plate
, NoEventMask
);
4016 // do not leave a shaded window as an icon unless it was an icon
4017 if (flags
.shaded
&& ! flags
.iconic
)
4018 setState(NormalState
);
4020 // erase the netwm stuff that we read when a window maps, so that it
4021 // doesn't persist between mappings.
4022 // (these are the ones read in getNetWMFlags().)
4023 xatom
->eraseValue(client
.window
, XAtom::net_wm_desktop
);
4024 xatom
->eraseValue(client
.window
, XAtom::net_wm_state
);
4026 restoreGravity(client
.rect
);
4028 XUnmapWindow(blackbox
->getXDisplay(), frame
.window
);
4029 XUnmapWindow(blackbox
->getXDisplay(), client
.window
);
4031 XSetWindowBorderWidth(blackbox
->getXDisplay(), client
.window
, client
.old_bw
);
4034 if (XCheckTypedWindowEvent(blackbox
->getXDisplay(), client
.window
,
4035 ReparentNotify
, &ev
)) {
4038 // according to the ICCCM - if the client doesn't reparent to
4039 // root, then we have to do it for them
4040 XReparentWindow(blackbox
->getXDisplay(), client
.window
,
4041 screen
->getRootWindow(),
4042 client
.rect
.x(), client
.rect
.y());
4045 if (remap
) XMapWindow(blackbox
->getXDisplay(), client
.window
);
4049 // timer for autoraise
4050 void BlackboxWindow::timeout(void) {
4051 screen
->getWorkspace(blackbox_attrib
.workspace
)->raiseWindow(this);
4055 void BlackboxWindow::changeBlackboxHints(const BlackboxHints
*net
) {
4056 if ((net
->flags
& AttribShaded
) &&
4057 ((blackbox_attrib
.attrib
& AttribShaded
) !=
4058 (net
->attrib
& AttribShaded
)))
4061 if (flags
.visible
&& // watch out for requests when we can not be seen
4062 (net
->flags
& (AttribMaxVert
| AttribMaxHoriz
)) &&
4063 ((blackbox_attrib
.attrib
& (AttribMaxVert
| AttribMaxHoriz
)) !=
4064 (net
->attrib
& (AttribMaxVert
| AttribMaxHoriz
)))) {
4065 if (flags
.maximized
) {
4070 if ((net
->flags
& AttribMaxHoriz
) && (net
->flags
& AttribMaxVert
))
4071 button
= ((net
->attrib
& (AttribMaxHoriz
| AttribMaxVert
)) ? 1 : 0);
4072 else if (net
->flags
& AttribMaxVert
)
4073 button
= ((net
->attrib
& AttribMaxVert
) ? 2 : 0);
4074 else if (net
->flags
& AttribMaxHoriz
)
4075 button
= ((net
->attrib
& AttribMaxHoriz
) ? 3 : 0);
4081 if ((net
->flags
& AttribOmnipresent
) &&
4082 ((blackbox_attrib
.attrib
& AttribOmnipresent
) !=
4083 (net
->attrib
& AttribOmnipresent
)))
4086 if ((net
->flags
& AttribWorkspace
) &&
4087 (blackbox_attrib
.workspace
!= net
->workspace
)) {
4088 screen
->reassociateWindow(this, net
->workspace
, True
);
4090 if (screen
->getCurrentWorkspaceID() != net
->workspace
) {
4094 screen
->getWorkspace(blackbox_attrib
.workspace
)->raiseWindow(this);
4098 if (net
->flags
& AttribDecoration
) {
4099 switch (net
->decoration
) {
4116 * Set the sizes of all components of the window frame
4117 * (the window decorations).
4118 * These values are based upon the current style settings and the client
4119 * window's dimensions.
4121 void BlackboxWindow::upsize(void) {
4122 frame
.bevel_w
= screen
->getBevelWidth();
4124 if (decorations
& Decor_Border
) {
4125 frame
.border_w
= screen
->getBorderWidth();
4126 if (! isTransient())
4127 frame
.mwm_border_w
= screen
->getFrameWidth();
4129 frame
.mwm_border_w
= 0;
4131 frame
.mwm_border_w
= frame
.border_w
= 0;
4134 if (decorations
& Decor_Titlebar
) {
4135 // the height of the titlebar is based upon the height of the font being
4136 // used to display the window's title
4137 WindowStyle
*style
= screen
->getWindowStyle();
4138 frame
.title_h
= style
->font
->height() + (frame
.bevel_w
* 2) + 2;
4140 frame
.label_h
= frame
.title_h
- (frame
.bevel_w
* 2);
4141 frame
.button_w
= (frame
.label_h
- 2);
4143 // set the top frame margin
4144 frame
.margin
.top
= frame
.border_w
+ frame
.title_h
+
4145 frame
.border_w
+ frame
.mwm_border_w
;
4151 // set the top frame margin
4152 frame
.margin
.top
= frame
.border_w
+ frame
.mwm_border_w
;
4155 // set the left/right frame margin
4156 frame
.margin
.left
= frame
.margin
.right
= frame
.border_w
+ frame
.mwm_border_w
;
4158 if (decorations
& Decor_Handle
) {
4159 frame
.grip_w
= frame
.button_w
* 2;
4160 frame
.handle_h
= screen
->getHandleWidth();
4162 // set the bottom frame margin
4163 frame
.margin
.bottom
= frame
.border_w
+ frame
.handle_h
+
4164 frame
.border_w
+ frame
.mwm_border_w
;
4169 // set the bottom frame margin
4170 frame
.margin
.bottom
= frame
.border_w
+ frame
.mwm_border_w
;
4174 We first get the normal dimensions and use this to define the inside_w/h
4175 then we modify the height if shading is in effect.
4176 If the shade state is not considered then frame.rect gets reset to the
4177 normal window size on a reconfigure() call resulting in improper
4178 dimensions appearing in move/resize and other events.
4181 height
= client
.rect
.height() + frame
.margin
.top
+ frame
.margin
.bottom
,
4182 width
= client
.rect
.width() + frame
.margin
.left
+ frame
.margin
.right
;
4184 frame
.inside_w
= width
- (frame
.border_w
* 2);
4185 frame
.inside_h
= height
- (frame
.border_w
* 2);
4188 height
= frame
.title_h
+ (frame
.border_w
* 2);
4189 frame
.rect
.setSize(width
, height
);
4194 * Calculate the size of the client window and constrain it to the
4195 * size specified by the size hints of the client window.
4197 * The logical width and height are placed into pw and ph, if they
4198 * are non-zero. Logical size refers to the users perception of
4199 * the window size (for example an xterm resizes in cells, not in pixels).
4200 * pw and ph are then used to display the geometry during window moves, resize,
4203 * The physical geometry is placed into frame.changing_{x,y,width,height}.
4204 * Physical geometry refers to the geometry of the window in pixels.
4206 void BlackboxWindow::constrain(Corner anchor
,
4207 unsigned int *pw
, unsigned int *ph
) {
4208 // frame.changing represents the requested frame size, we need to
4209 // strip the frame margin off and constrain the client size
4210 frame
.changing
.setCoords(frame
.changing
.left() + frame
.margin
.left
,
4211 frame
.changing
.top() + frame
.margin
.top
,
4212 frame
.changing
.right() - frame
.margin
.right
,
4213 frame
.changing
.bottom() - frame
.margin
.bottom
);
4215 unsigned int dw
= frame
.changing
.width(), dh
= frame
.changing
.height(),
4216 base_width
= (client
.base_width
) ? client
.base_width
: client
.min_width
,
4217 base_height
= (client
.base_height
) ? client
.base_height
:
4220 // constrain, but only if the min/max are being used. if they aren't, then
4221 // this resize is going to be from a ConfigureRequest because the window
4222 // isn't allowed to be resized by the user. And in that case, we don't want
4223 // to limit what the app can do
4224 if (client
.max_width
> client
.min_width
||
4225 client
.max_height
> client
.min_height
) {
4226 if (dw
< client
.min_width
) dw
= client
.min_width
;
4227 if (dh
< client
.min_height
) dh
= client
.min_height
;
4228 if (dw
> client
.max_width
) dw
= client
.max_width
;
4229 if (dh
> client
.max_height
) dh
= client
.max_height
;
4232 assert(dw
>= base_width
&& dh
>= base_height
);
4234 if (client
.width_inc
> 1) {
4236 dw
/= client
.width_inc
;
4238 if (client
.height_inc
> 1) {
4240 dh
/= client
.height_inc
;
4249 if (client
.width_inc
> 1) {
4250 dw
*= client
.width_inc
;
4253 if (client
.height_inc
> 1) {
4254 dh
*= client
.height_inc
;
4258 frame
.changing
.setSize(dw
, dh
);
4260 // add the frame margin back onto frame.changing
4261 frame
.changing
.setCoords(frame
.changing
.left() - frame
.margin
.left
,
4262 frame
.changing
.top() - frame
.margin
.top
,
4263 frame
.changing
.right() + frame
.margin
.right
,
4264 frame
.changing
.bottom() + frame
.margin
.bottom
);
4266 // move frame.changing to the specified anchor
4274 dx
= frame
.rect
.right() - frame
.changing
.right();
4278 dy
= frame
.rect
.bottom() - frame
.changing
.bottom();
4282 dx
= frame
.rect
.right() - frame
.changing
.right();
4283 dy
= frame
.rect
.bottom() - frame
.changing
.bottom();
4287 assert(false); // unhandled corner
4289 frame
.changing
.setPos(frame
.changing
.x() + dx
, frame
.changing
.y() + dy
);
4293 void WindowStyle::doJustify(const std::string
&text
, int &start_pos
,
4294 unsigned int max_length
,
4295 unsigned int modifier
) const {
4296 size_t text_len
= text
.size();
4297 unsigned int length
;
4300 length
= font
->measureString(string(text
, 0, text_len
)) + modifier
;
4301 } while (length
> max_length
&& text_len
-- > 0);
4305 start_pos
+= max_length
- length
;
4309 start_pos
+= (max_length
- length
) / 2;
4319 BWindowGroup::BWindowGroup(Blackbox
*b
, Window _group
)
4320 : blackbox(b
), group(_group
) {
4321 XWindowAttributes wattrib
;
4322 if (! XGetWindowAttributes(blackbox
->getXDisplay(), group
, &wattrib
)) {
4323 // group window doesn't seem to exist anymore
4328 XSelectInput(blackbox
->getXDisplay(), group
,
4329 PropertyChangeMask
| FocusChangeMask
| StructureNotifyMask
);
4331 blackbox
->saveGroupSearch(group
, this);
4335 BWindowGroup::~BWindowGroup(void) {
4336 blackbox
->removeGroupSearch(group
);
4341 BWindowGroup::find(BScreen
*screen
, bool allow_transients
) const {
4342 BlackboxWindow
*ret
= blackbox
->getFocusedWindow();
4344 // does the focus window match (or any transient_fors)?
4345 for (; ret
; ret
= ret
->getTransientFor()) {
4346 if (ret
->getScreen() == screen
&& ret
->getGroupWindow() == group
&&
4347 (! ret
->isTransient() || allow_transients
))
4351 if (ret
) return ret
;
4353 // the focus window didn't match, look in the group's window list
4354 BlackboxWindowList::const_iterator it
, end
= windowList
.end();
4355 for (it
= windowList
.begin(); it
!= end
; ++it
) {
4357 if (ret
->getScreen() == screen
&& ret
->getGroupWindow() == group
&&
4358 (! ret
->isTransient() || allow_transients
))