1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
2 // blackbox.cc for Blackbox - an X11 Window manager
3 // Copyright (c) 2001 - 2002 Sean 'Shaleh' Perry <shaleh@debian.org>
4 // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net)
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
30 #include <X11/Xutil.h>
31 #include <X11/Xatom.h>
32 #include <X11/cursorfont.h>
33 #include <X11/keysym.h>
36 #include <X11/extensions/shape.h>
41 #endif // HAVE_STDIO_H
45 #endif // HAVE_STDLIB_H
49 #endif // HAVE_STRING_H
52 # include <sys/types.h>
54 #endif // HAVE_UNISTD_H
56 #ifdef HAVE_SYS_PARAM_H
57 # include <sys/param.h>
58 #endif // HAVE_SYS_PARAM_H
60 #ifdef HAVE_SYS_SELECT_H
61 # include <sys/select.h>
62 #endif // HAVE_SYS_SELECT_H
66 #endif // HAVE_SIGNAL_H
68 #ifdef HAVE_SYS_SIGNAL_H
69 # include <sys/signal.h>
70 #endif // HAVE_SYS_SIGNAL_H
72 #ifdef HAVE_SYS_STAT_H
73 # include <sys/types.h>
74 # include <sys/stat.h>
75 #endif // HAVE_SYS_STAT_H
77 #ifdef TIME_WITH_SYS_TIME
78 # include <sys/time.h>
80 #else // !TIME_WITH_SYS_TIME
81 # ifdef HAVE_SYS_TIME_H
82 # include <sys/time.h>
83 # else // !HAVE_SYS_TIME_H
85 # endif // HAVE_SYS_TIME_H
86 #endif // TIME_WITH_SYS_TIME
90 #endif // HAVE_LIBGEN_H
100 #include "blackbox.hh"
101 #include "Basemenu.hh"
102 #include "Clientmenu.hh"
103 #include "GCCache.hh"
105 #include "Rootmenu.hh"
108 #include "Toolbar.hh"
111 #include "Workspace.hh"
112 #include "Workspacemenu.hh"
115 // X event scanner for enter/leave notifies - adapted from twm
118 bool leave
, inferior
, enter
;
121 static Bool
queueScanner(Display
*, XEvent
*e
, char *args
) {
122 scanargs
*scan
= (scanargs
*) args
;
123 if ((e
->type
== LeaveNotify
) &&
124 (e
->xcrossing
.window
== scan
->w
) &&
125 (e
->xcrossing
.mode
== NotifyNormal
)) {
127 scan
->inferior
= (e
->xcrossing
.detail
== NotifyInferior
);
128 } else if ((e
->type
== EnterNotify
) && (e
->xcrossing
.mode
== NotifyUngrab
)) {
138 Blackbox::Blackbox(char **m_argv
, char *dpy_name
, char *rc
, char *menu
)
139 : BaseDisplay(m_argv
[0], dpy_name
) {
140 if (! XSupportsLocale())
141 fprintf(stderr
, "X server does not support locale\n");
143 if (XSetLocaleModifiers("") == NULL
)
144 fprintf(stderr
, "cannot set locale modifiers\n");
149 // try to make sure the ~/.openbox directory exists
150 mkdir(expandTilde("~/.openbox").c_str(), S_IREAD
| S_IWRITE
| S_IEXEC
|
151 S_IRGRP
| S_IWGRP
| S_IXGRP
|
152 S_IROTH
| S_IWOTH
| S_IXOTH
);
154 if (! rc
) rc
= "~/.openbox/rc";
155 rc_file
= expandTilde(rc
);
156 config
.setFile(rc_file
);
157 if (! menu
) menu
= "~/.openbox/menu";
158 menu_file
= expandTilde(menu
);
162 resource
.auto_raise_delay
.tv_sec
= resource
.auto_raise_delay
.tv_usec
= 0;
165 focused_window
= changing_window
= (BlackboxWindow
*) 0;
169 xatom
= new XAtom(getXDisplay());
171 cursor
.session
= XCreateFontCursor(getXDisplay(), XC_left_ptr
);
172 cursor
.move
= XCreateFontCursor(getXDisplay(), XC_fleur
);
173 cursor
.ll_angle
= XCreateFontCursor(getXDisplay(), XC_ll_angle
);
174 cursor
.lr_angle
= XCreateFontCursor(getXDisplay(), XC_lr_angle
);
175 cursor
.ul_angle
= XCreateFontCursor(getXDisplay(), XC_ul_angle
);
176 cursor
.ur_angle
= XCreateFontCursor(getXDisplay(), XC_ur_angle
);
178 for (unsigned int i
= 0; i
< getNumberOfScreens(); i
++) {
179 BScreen
*screen
= new BScreen(this, i
);
181 if (! screen
->isScreenManaged()) {
186 screenList
.push_back(screen
);
189 if (screenList
.empty()) {
191 i18n(blackboxSet
, blackboxNoManagableScreens
,
192 "Blackbox::Blackbox: no managable screens found, aborting.\n"));
196 // save current settings and default values
199 // set the screen with mouse to the first managed screen
200 active_screen
= screenList
.front();
203 XSynchronize(getXDisplay(), False
);
204 XSync(getXDisplay(), False
);
206 reconfigure_wait
= reread_menu_wait
= False
;
208 timer
= new BTimer(this, this);
209 timer
->setTimeout(0l);
213 Blackbox::~Blackbox(void) {
214 std::for_each(screenList
.begin(), screenList
.end(), PointerAssassin());
216 std::for_each(menuTimestamps
.begin(), menuTimestamps
.end(),
225 void Blackbox::process_event(XEvent
*e
) {
228 // strip the lock key modifiers
229 e
->xbutton
.state
&= ~(NumLockMask
| ScrollLockMask
| LockMask
);
231 last_time
= e
->xbutton
.time
;
233 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
234 Basemenu
*menu
= (Basemenu
*) 0;
235 Slit
*slit
= (Slit
*) 0;
236 Toolbar
*tbar
= (Toolbar
*) 0;
237 BScreen
*scrn
= (BScreen
*) 0;
239 if ((win
= searchWindow(e
->xbutton
.window
))) {
240 win
->buttonPressEvent(&e
->xbutton
);
242 /* XXX: is this sane on low colour desktops? */
243 if (e
->xbutton
.button
== 1)
244 win
->installColormap(True
);
245 } else if ((menu
= searchMenu(e
->xbutton
.window
))) {
246 menu
->buttonPressEvent(&e
->xbutton
);
247 } else if ((slit
= searchSlit(e
->xbutton
.window
))) {
248 slit
->buttonPressEvent(&e
->xbutton
);
249 } else if ((tbar
= searchToolbar(e
->xbutton
.window
))) {
250 tbar
->buttonPressEvent(&e
->xbutton
);
251 } else if ((scrn
= searchScreen(e
->xbutton
.window
))) {
252 scrn
->buttonPressEvent(&e
->xbutton
);
253 if (active_screen
!= scrn
) {
254 active_screen
= scrn
;
255 // first, set no focus window on the old screen
257 // and move focus to this screen
264 case ButtonRelease
: {
265 // strip the lock key modifiers
266 e
->xbutton
.state
&= ~(NumLockMask
| ScrollLockMask
| LockMask
);
268 last_time
= e
->xbutton
.time
;
270 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
271 Basemenu
*menu
= (Basemenu
*) 0;
272 Toolbar
*tbar
= (Toolbar
*) 0;
274 if ((win
= searchWindow(e
->xbutton
.window
)))
275 win
->buttonReleaseEvent(&e
->xbutton
);
276 else if ((menu
= searchMenu(e
->xbutton
.window
)))
277 menu
->buttonReleaseEvent(&e
->xbutton
);
278 else if ((tbar
= searchToolbar(e
->xbutton
.window
)))
279 tbar
->buttonReleaseEvent(&e
->xbutton
);
284 case ConfigureRequest
: {
285 // compress configure requests...
288 while(XCheckTypedWindowEvent(getXDisplay(), e
->xconfigurerequest
.window
,
289 ConfigureRequest
, &realevent
)) {
295 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
296 Slit
*slit
= (Slit
*) 0;
298 if ((win
= searchWindow(e
->xconfigurerequest
.window
))) {
299 win
->configureRequestEvent(&e
->xconfigurerequest
);
300 } else if ((slit
= searchSlit(e
->xconfigurerequest
.window
))) {
301 slit
->configureRequestEvent(&e
->xconfigurerequest
);
303 if (validateWindow(e
->xconfigurerequest
.window
)) {
306 xwc
.x
= e
->xconfigurerequest
.x
;
307 xwc
.y
= e
->xconfigurerequest
.y
;
308 xwc
.width
= e
->xconfigurerequest
.width
;
309 xwc
.height
= e
->xconfigurerequest
.height
;
310 xwc
.border_width
= e
->xconfigurerequest
.border_width
;
311 xwc
.sibling
= e
->xconfigurerequest
.above
;
312 xwc
.stack_mode
= e
->xconfigurerequest
.detail
;
314 XConfigureWindow(getXDisplay(), e
->xconfigurerequest
.window
,
315 e
->xconfigurerequest
.value_mask
, &xwc
);
324 fprintf(stderr
, "Blackbox::process_event(): MapRequest for 0x%lx\n",
325 e
->xmaprequest
.window
);
328 BlackboxWindow
*win
= searchWindow(e
->xmaprequest
.window
);
332 if (win
->isIconic()) {
336 if (win
->isShaded()) {
341 if (focus
&& (win
->isTransient() || win
->getScreen()->doFocusNew()))
342 win
->setInputFocus();
344 BScreen
*screen
= searchScreen(e
->xmaprequest
.parent
);
348 we got a map request for a window who's parent isn't root. this
349 can happen in only one circumstance:
351 a client window unmapped a managed window, and then remapped it
352 somewhere between unmapping the client window and reparenting it
355 regardless of how it happens, we need to find the screen that
358 XWindowAttributes wattrib
;
359 if (! XGetWindowAttributes(getXDisplay(), e
->xmaprequest
.window
,
361 // failed to get the window attributes, perhaps the window has
362 // now been destroyed?
366 screen
= searchScreen(wattrib
.root
);
367 assert(screen
!= 0); // this should never happen
370 screen
->manageWindow(e
->xmaprequest
.window
);
377 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
378 Slit
*slit
= (Slit
*) 0;
379 BScreen
*screen
= (BScreen
*) 0;
381 if ((win
= searchWindow(e
->xunmap
.window
))) {
382 win
->unmapNotifyEvent(&e
->xunmap
);
383 } else if ((slit
= searchSlit(e
->xunmap
.window
))) {
384 slit
->unmapNotifyEvent(&e
->xunmap
);
385 } else if ((screen
= searchSystrayWindow(e
->xunmap
.window
))) {
386 screen
->removeSystrayWindow(e
->xunmap
.window
);
392 case DestroyNotify
: {
393 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
394 Slit
*slit
= (Slit
*) 0;
395 BScreen
*screen
= (BScreen
*) 0;
396 BWindowGroup
*group
= (BWindowGroup
*) 0;
398 if ((win
= searchWindow(e
->xdestroywindow
.window
))) {
399 win
->destroyNotifyEvent(&e
->xdestroywindow
);
400 } else if ((slit
= searchSlit(e
->xdestroywindow
.window
))) {
401 slit
->removeClient(e
->xdestroywindow
.window
, False
);
402 } else if ((group
= searchGroup(e
->xdestroywindow
.window
))) {
404 } else if ((screen
= searchSystrayWindow(e
->xunmap
.window
))) {
405 screen
->removeSystrayWindow(e
->xunmap
.window
);
411 case ReparentNotify
: {
413 this event is quite rare and is usually handled in unmapNotify
414 however, if the window is unmapped when the reparent event occurs
415 the window manager never sees it because an unmap event is not sent
416 to an already unmapped window.
418 BlackboxWindow
*win
= searchWindow(e
->xreparent
.window
);
420 win
->reparentNotifyEvent(&e
->xreparent
);
422 Slit
*slit
= searchSlit(e
->xreparent
.window
);
423 if (slit
&& slit
->getWindowID() != e
->xreparent
.parent
)
424 slit
->removeClient(e
->xreparent
.window
, True
);
430 // motion notify compression...
433 while (XCheckTypedWindowEvent(getXDisplay(), e
->xmotion
.window
,
434 MotionNotify
, &realevent
)) {
438 // if we have compressed some motion events, use the last one
442 // the pointer is on the wrong screen
443 if (! e
->xmotion
.same_screen
)
446 // strip the lock key modifiers
447 e
->xmotion
.state
&= ~(NumLockMask
| ScrollLockMask
| LockMask
);
449 last_time
= e
->xmotion
.time
;
451 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
452 Basemenu
*menu
= (Basemenu
*) 0;
454 if ((win
= searchWindow(e
->xmotion
.window
)))
455 win
->motionNotifyEvent(&e
->xmotion
);
456 else if ((menu
= searchMenu(e
->xmotion
.window
)))
457 menu
->motionNotifyEvent(&e
->xmotion
);
462 case PropertyNotify
: {
463 last_time
= e
->xproperty
.time
;
465 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
466 BScreen
*screen
= (BScreen
*) 0;
468 if ((win
= searchWindow(e
->xproperty
.window
)))
469 win
->propertyNotifyEvent(&e
->xproperty
);
470 else if ((screen
= searchScreen(e
->xproperty
.window
)))
471 screen
->propertyNotifyEvent(&e
->xproperty
);
476 last_time
= e
->xcrossing
.time
;
478 BScreen
*screen
= (BScreen
*) 0;
479 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
480 Basemenu
*menu
= (Basemenu
*) 0;
481 Toolbar
*tbar
= (Toolbar
*) 0;
482 Slit
*slit
= (Slit
*) 0;
484 if (e
->xcrossing
.mode
== NotifyGrab
) break;
488 sa
.w
= e
->xcrossing
.window
;
489 sa
.enter
= sa
.leave
= False
;
490 XCheckIfEvent(getXDisplay(), &dummy
, queueScanner
, (char *) &sa
);
492 if ((e
->xcrossing
.window
== e
->xcrossing
.root
) &&
493 (screen
= searchScreen(e
->xcrossing
.window
))) {
494 screen
->getImageControl()->installRootColormap();
495 } else if ((win
= searchWindow(e
->xcrossing
.window
))) {
496 if (win
->getScreen()->isSloppyFocus() &&
497 (! win
->isFocused()) && (! no_focus
) &&
498 win
->isNormal()) { // don't focus non-normal windows with mouseover
499 if (((! sa
.leave
) || sa
.inferior
) && win
->isVisible()) {
500 if (win
->setInputFocus())
501 win
->installColormap(True
); // XXX: shouldnt we honour no install?
504 } else if ((menu
= searchMenu(e
->xcrossing
.window
))) {
505 menu
->enterNotifyEvent(&e
->xcrossing
);
506 } else if ((tbar
= searchToolbar(e
->xcrossing
.window
))) {
507 tbar
->enterNotifyEvent(&e
->xcrossing
);
508 } else if ((slit
= searchSlit(e
->xcrossing
.window
))) {
509 slit
->enterNotifyEvent(&e
->xcrossing
);
515 last_time
= e
->xcrossing
.time
;
517 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
518 Basemenu
*menu
= (Basemenu
*) 0;
519 Toolbar
*tbar
= (Toolbar
*) 0;
520 Slit
*slit
= (Slit
*) 0;
522 if ((menu
= searchMenu(e
->xcrossing
.window
)))
523 menu
->leaveNotifyEvent(&e
->xcrossing
);
524 else if ((win
= searchWindow(e
->xcrossing
.window
)))
525 win
->installColormap(False
);
526 else if ((tbar
= searchToolbar(e
->xcrossing
.window
)))
527 tbar
->leaveNotifyEvent(&e
->xcrossing
);
528 else if ((slit
= searchSlit(e
->xcrossing
.window
)))
529 slit
->leaveNotifyEvent(&e
->xcrossing
);
534 // compress expose events
537 int ex1
, ey1
, ex2
, ey2
;
540 ex2
= ex1
+ e
->xexpose
.width
- 1;
541 ey2
= ey1
+ e
->xexpose
.height
- 1;
542 while (XCheckTypedWindowEvent(getXDisplay(), e
->xexpose
.window
,
543 Expose
, &realevent
)) {
547 ex1
= std::min(realevent
.xexpose
.x
, ex1
);
548 ey1
= std::min(realevent
.xexpose
.y
, ey1
);
549 ex2
= std::max(realevent
.xexpose
.x
+ realevent
.xexpose
.width
- 1, ex2
);
550 ey2
= std::max(realevent
.xexpose
.y
+ realevent
.xexpose
.height
- 1, ey2
);
555 // use the merged area
558 e
->xexpose
.width
= ex2
- ex1
+ 1;
559 e
->xexpose
.height
= ey2
- ey1
+ 1;
561 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
562 Basemenu
*menu
= (Basemenu
*) 0;
563 Toolbar
*tbar
= (Toolbar
*) 0;
565 if ((win
= searchWindow(e
->xexpose
.window
)))
566 win
->exposeEvent(&e
->xexpose
);
567 else if ((menu
= searchMenu(e
->xexpose
.window
)))
568 menu
->exposeEvent(&e
->xexpose
);
569 else if ((tbar
= searchToolbar(e
->xexpose
.window
)))
570 tbar
->exposeEvent(&e
->xexpose
);
576 Toolbar
*tbar
= searchToolbar(e
->xkey
.window
);
578 if (tbar
&& tbar
->isEditing())
579 tbar
->keyPressEvent(&e
->xkey
);
584 case ColormapNotify
: {
585 BScreen
*screen
= searchScreen(e
->xcolormap
.window
);
588 screen
->setRootColormapInstalled((e
->xcolormap
.state
==
589 ColormapInstalled
) ? True
: False
);
595 if (e
->xfocus
.detail
!= NotifyNonlinear
&&
596 e
->xfocus
.detail
!= NotifyAncestor
) {
598 don't process FocusIns when:
599 1. the new focus window isn't an ancestor or inferior of the old
600 focus window (NotifyNonlinear)
601 make sure to allow the FocusIn when the old focus window was an
602 ancestor but didn't have a parent, such as root (NotifyAncestor)
607 BlackboxWindow
*win
= searchWindow(e
->xfocus
.window
);
609 if (! win
->isFocused())
610 win
->setFocusFlag(True
);
613 set the event window to None. when the FocusOut event handler calls
614 this function recursively, it uses this as an indication that focus
615 has moved to a known window.
617 e
->xfocus
.window
= None
;
624 if (e
->xfocus
.detail
!= NotifyNonlinear
) {
626 don't process FocusOuts when:
627 2. the new focus window isn't an ancestor or inferior of the old
628 focus window (NotifyNonlinear)
633 BlackboxWindow
*win
= searchWindow(e
->xfocus
.window
);
634 if (win
&& win
->isFocused()) {
636 before we mark "win" as unfocused, we need to verify that focus is
637 going to a known location, is in a known location, or set focus
642 // don't check the current focus if FocusOut was generated during a grab
643 bool check_focus
= (e
->xfocus
.mode
== NotifyNormal
);
646 First, check if there is a pending FocusIn event waiting. if there
647 is, process it and determine if focus has moved to another window
648 (the FocusIn event handler sets the window in the event
649 structure to None to indicate this).
651 if (XCheckTypedEvent(getXDisplay(), FocusIn
, &event
)) {
653 process_event(&event
);
654 if (event
.xfocus
.window
== None
) {
662 Second, we query the X server for the current input focus.
663 to make sure that we keep a consistent state.
665 BlackboxWindow
*focus
;
668 XGetInputFocus(getXDisplay(), &w
, &revert
);
669 focus
= searchWindow(w
);
672 focus got from "win" to "focus" under some very strange
673 circumstances, and we need to make sure that the focus indication
676 setFocusedWindow(focus
);
678 // we have no idea where focus went... so we set it to somewhere
687 case ClientMessage
: {
688 if (e
->xclient
.format
== 32) {
689 if (e
->xclient
.message_type
== xatom
->getAtom(XAtom::wm_change_state
)) {
690 // WM_CHANGE_STATE message
691 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
692 if (! win
|| ! win
->validateClient()) return;
694 if (e
->xclient
.data
.l
[0] == IconicState
)
696 if (e
->xclient
.data
.l
[0] == NormalState
)
698 } else if (e
->xclient
.message_type
==
699 xatom
->getAtom(XAtom::blackbox_change_workspace
) ||
700 e
->xclient
.message_type
==
701 xatom
->getAtom(XAtom::net_current_desktop
)) {
702 // NET_CURRENT_DESKTOP message
703 BScreen
*screen
= searchScreen(e
->xclient
.window
);
705 unsigned int workspace
= e
->xclient
.data
.l
[0];
706 if (screen
&& workspace
< screen
->getWorkspaceCount())
707 screen
->changeWorkspaceID(workspace
);
708 } else if (e
->xclient
.message_type
==
709 xatom
->getAtom(XAtom::blackbox_change_window_focus
)) {
710 // TEMP HACK TO KEEP BBKEYS WORKING
711 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
713 if (win
&& win
->isVisible() && win
->setInputFocus())
714 win
->installColormap(True
);
715 } else if (e
->xclient
.message_type
==
716 xatom
->getAtom(XAtom::net_active_window
)) {
718 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
721 BScreen
*screen
= win
->getScreen();
724 win
->deiconify(False
, True
);
727 if (win
->getWorkspaceNumber() != screen
->getCurrentWorkspaceID())
728 screen
->changeWorkspaceID(win
->getWorkspaceNumber());
729 if (win
->isVisible() && win
->setInputFocus()) {
730 win
->getScreen()->getWorkspace(win
->getWorkspaceNumber())->
732 win
->installColormap(True
);
735 } else if (e
->xclient
.message_type
==
736 xatom
->getAtom(XAtom::blackbox_cycle_window_focus
)) {
737 // BLACKBOX_CYCLE_WINDOW_FOCUS
738 BScreen
*screen
= searchScreen(e
->xclient
.window
);
741 if (! e
->xclient
.data
.l
[0])
746 } else if (e
->xclient
.message_type
==
747 xatom
->getAtom(XAtom::net_wm_desktop
)) {
749 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
752 BScreen
*screen
= win
->getScreen();
753 unsigned long wksp
= (unsigned) e
->xclient
.data
.l
[0];
754 if (wksp
< screen
->getWorkspaceCount()) {
755 if (win
->isIconic()) win
->deiconify(False
, True
);
756 if (win
->isStuck()) win
->stick();
757 if (wksp
!= screen
->getCurrentWorkspaceID())
761 screen
->reassociateWindow(win
, wksp
, True
);
762 } else if (wksp
== 0xfffffffe || // XXX: BUG, BUT DOING THIS SO KDE WORKS FOR NOW!!
763 wksp
== 0xffffffff) {
764 if (win
->isIconic()) win
->deiconify(False
, True
);
765 if (! win
->isStuck()) win
->stick();
766 if (! win
->isVisible()) win
->show();
769 } else if (e
->xclient
.message_type
==
770 xatom
->getAtom(XAtom::blackbox_change_attributes
)) {
771 // BLACKBOX_CHANGE_ATTRIBUTES
772 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
774 if (win
&& win
->validateClient()) {
776 net
.flags
= e
->xclient
.data
.l
[0];
777 net
.attrib
= e
->xclient
.data
.l
[1];
778 net
.workspace
= e
->xclient
.data
.l
[2];
779 net
.stack
= e
->xclient
.data
.l
[3];
780 net
.decoration
= e
->xclient
.data
.l
[4];
782 win
->changeBlackboxHints(&net
);
784 } else if (e
->xclient
.message_type
==
785 xatom
->getAtom(XAtom::net_number_of_desktops
)) {
786 // NET_NUMBER_OF_DESKTOPS
787 BScreen
*screen
= searchScreen(e
->xclient
.window
);
789 if (e
->xclient
.data
.l
[0] > 0)
790 screen
->changeWorkspaceCount((unsigned) e
->xclient
.data
.l
[0]);
791 } else if (e
->xclient
.message_type
==
792 xatom
->getAtom(XAtom::net_close_window
)) {
794 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
795 if (win
&& win
->validateClient())
796 win
->close(); // could this be smarter?
797 } else if (e
->xclient
.message_type
==
798 xatom
->getAtom(XAtom::net_wm_moveresize
)) {
800 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
801 if (win
&& win
->validateClient()) {
802 int x_root
= e
->xclient
.data
.l
[0],
803 y_root
= e
->xclient
.data
.l
[1];
804 if ((Atom
) e
->xclient
.data
.l
[2] ==
805 xatom
->getAtom(XAtom::net_wm_moveresize_move
)) {
806 win
->beginMove(x_root
, y_root
);
808 if ((Atom
) e
->xclient
.data
.l
[2] ==
809 xatom
->getAtom(XAtom::net_wm_moveresize_size_topleft
))
810 win
->beginResize(x_root
, y_root
, BlackboxWindow::TopLeft
);
811 else if ((Atom
) e
->xclient
.data
.l
[2] ==
812 xatom
->getAtom(XAtom::net_wm_moveresize_size_topright
))
813 win
->beginResize(x_root
, y_root
, BlackboxWindow::TopRight
);
814 else if ((Atom
) e
->xclient
.data
.l
[2] ==
815 xatom
->getAtom(XAtom::net_wm_moveresize_size_bottomleft
))
816 win
->beginResize(x_root
, y_root
, BlackboxWindow::BottomLeft
);
817 else if ((Atom
) e
->xclient
.data
.l
[2] ==
818 xatom
->getAtom(XAtom::net_wm_moveresize_size_bottomright
))
819 win
->beginResize(x_root
, y_root
, BlackboxWindow::BottomRight
);
822 } else if (e
->xclient
.message_type
==
823 xatom
->getAtom(XAtom::net_wm_state
)) {
825 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
826 if (win
&& win
->validateClient()) {
827 const Atom action
= (Atom
) e
->xclient
.data
.l
[0];
828 const Atom state
[] = { (Atom
) e
->xclient
.data
.l
[1],
829 (Atom
) e
->xclient
.data
.l
[2] };
831 for (int i
= 0; i
< 2; ++i
) {
835 if ((Atom
) e
->xclient
.data
.l
[0] == 1) {
837 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
839 } else if (state
[i
] ==
840 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
841 if (win
->isMaximizedHoriz()) {
842 win
->maximize(0); // unmaximize
843 win
->maximize(1); // full
844 } else if (! win
->isMaximized()) {
845 win
->maximize(2); // vert
847 } else if (state
[i
] ==
848 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
849 if (win
->isMaximizedVert()) {
850 win
->maximize(0); // unmaximize
851 win
->maximize(1); // full
852 } else if (! win
->isMaximized()) {
853 win
->maximize(3); // horiz
855 } else if (state
[i
] ==
856 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
857 if (! win
->isShaded())
859 } else if (state
[i
] ==
860 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
861 win
->setSkipTaskbar(True
);
862 } else if (state
[i
] ==
863 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
864 win
->setSkipPager(True
);
865 } else if (state
[i
] ==
866 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
867 win
->setFullscreen(True
);
869 } else if (action
== 0) {
871 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
872 win
->setModal(False
);
873 } else if (state
[i
] ==
874 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
875 if (win
->isMaximizedFull()) {
876 win
->maximize(0); // unmaximize
877 win
->maximize(3); // horiz
878 } else if (win
->isMaximizedVert()) {
879 win
->maximize(0); // unmaximize
881 } else if (state
[i
] ==
882 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
883 if (win
->isMaximizedFull()) {
884 win
->maximize(0); // unmaximize
885 win
->maximize(2); // vert
886 } else if (win
->isMaximizedHoriz()) {
887 win
->maximize(0); // unmaximize
889 } else if (state
[i
] ==
890 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
893 } else if (state
[i
] ==
894 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
895 win
->setSkipTaskbar(False
);
896 } else if (state
[i
] ==
897 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
898 win
->setSkipPager(False
);
899 } else if (state
[i
] ==
900 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
901 win
->setFullscreen(False
);
903 } else if (action
== 2) {
905 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
906 win
->setModal(! win
->isModal());
907 } else if (state
[i
] ==
908 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
909 if (win
->isMaximizedFull()) {
910 win
->maximize(0); // unmaximize
911 win
->maximize(3); // horiz
912 } else if (win
->isMaximizedVert()) {
913 win
->maximize(0); // unmaximize
914 } else if (win
->isMaximizedHoriz()) {
915 win
->maximize(0); // unmaximize
916 win
->maximize(1); // full
918 win
->maximize(2); // vert
920 } else if (state
[i
] ==
921 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
922 if (win
->isMaximizedFull()) {
923 win
->maximize(0); // unmaximize
924 win
->maximize(2); // vert
925 } else if (win
->isMaximizedHoriz()) {
926 win
->maximize(0); // unmaximize
927 } else if (win
->isMaximizedVert()) {
928 win
->maximize(0); // unmaximize
929 win
->maximize(1); // full
931 win
->maximize(3); // horiz
933 } else if (state
[i
] ==
934 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
936 } else if (state
[i
] ==
937 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
938 win
->setSkipTaskbar(! win
->skipTaskbar());
939 } else if (state
[i
] ==
940 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
941 win
->setSkipPager(! win
->skipPager());
942 } else if (state
[i
] ==
943 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
944 win
->setFullscreen(! win
->isFullscreen());
956 case ConfigureNotify
:
958 break; // not handled, just ignore
962 if (e
->type
== getShapeEventBase()) {
963 XShapeEvent
*shape_event
= (XShapeEvent
*) e
;
964 BlackboxWindow
*win
= searchWindow(e
->xany
.window
);
967 win
->shapeEvent(shape_event
);
975 bool Blackbox::handleSignal(int sig
) {
1004 bool Blackbox::validateWindow(Window window
) {
1006 if (XCheckTypedWindowEvent(getXDisplay(), window
, DestroyNotify
, &event
)) {
1007 XPutBackEvent(getXDisplay(), &event
);
1016 BScreen
*Blackbox::searchScreen(Window window
) {
1017 ScreenList::iterator it
= screenList
.begin();
1019 for (; it
!= screenList
.end(); ++it
) {
1021 if (s
->getRootWindow() == window
)
1025 return (BScreen
*) 0;
1029 BScreen
*Blackbox::searchSystrayWindow(Window window
) {
1030 WindowScreenLookup::iterator it
= systraySearchList
.find(window
);
1031 if (it
!= systraySearchList
.end())
1034 return (BScreen
*) 0;
1038 BlackboxWindow
*Blackbox::searchWindow(Window window
) {
1039 WindowLookup::iterator it
= windowSearchList
.find(window
);
1040 if (it
!= windowSearchList
.end())
1043 return (BlackboxWindow
*) 0;
1047 BWindowGroup
*Blackbox::searchGroup(Window window
) {
1048 GroupLookup::iterator it
= groupSearchList
.find(window
);
1049 if (it
!= groupSearchList
.end())
1052 return (BWindowGroup
*) 0;
1056 Basemenu
*Blackbox::searchMenu(Window window
) {
1057 MenuLookup::iterator it
= menuSearchList
.find(window
);
1058 if (it
!= menuSearchList
.end())
1061 return (Basemenu
*) 0;
1065 Toolbar
*Blackbox::searchToolbar(Window window
) {
1066 ToolbarLookup::iterator it
= toolbarSearchList
.find(window
);
1067 if (it
!= toolbarSearchList
.end())
1070 return (Toolbar
*) 0;
1074 Slit
*Blackbox::searchSlit(Window window
) {
1075 SlitLookup::iterator it
= slitSearchList
.find(window
);
1076 if (it
!= slitSearchList
.end())
1083 void Blackbox::saveSystrayWindowSearch(Window window
, BScreen
*screen
) {
1084 systraySearchList
.insert(WindowScreenLookupPair(window
, screen
));
1088 void Blackbox::saveWindowSearch(Window window
, BlackboxWindow
*data
) {
1089 windowSearchList
.insert(WindowLookupPair(window
, data
));
1093 void Blackbox::saveGroupSearch(Window window
, BWindowGroup
*data
) {
1094 groupSearchList
.insert(GroupLookupPair(window
, data
));
1098 void Blackbox::saveMenuSearch(Window window
, Basemenu
*data
) {
1099 menuSearchList
.insert(MenuLookupPair(window
, data
));
1103 void Blackbox::saveToolbarSearch(Window window
, Toolbar
*data
) {
1104 toolbarSearchList
.insert(ToolbarLookupPair(window
, data
));
1108 void Blackbox::saveSlitSearch(Window window
, Slit
*data
) {
1109 slitSearchList
.insert(SlitLookupPair(window
, data
));
1113 void Blackbox::removeSystrayWindowSearch(Window window
) {
1114 systraySearchList
.erase(window
);
1118 void Blackbox::removeWindowSearch(Window window
) {
1119 windowSearchList
.erase(window
);
1123 void Blackbox::removeGroupSearch(Window window
) {
1124 groupSearchList
.erase(window
);
1128 void Blackbox::removeMenuSearch(Window window
) {
1129 menuSearchList
.erase(window
);
1133 void Blackbox::removeToolbarSearch(Window window
) {
1134 toolbarSearchList
.erase(window
);
1138 void Blackbox::removeSlitSearch(Window window
) {
1139 slitSearchList
.erase(window
);
1143 void Blackbox::restart(const char *prog
) {
1147 putenv(const_cast<char *>(screenList
.front()->displayString().c_str()));
1148 execlp(prog
, prog
, NULL
);
1152 // fall back in case the above execlp doesn't work
1153 execvp(argv
[0], argv
);
1154 string name
= basename(argv
[0]);
1155 execvp(name
.c_str(), argv
);
1159 void Blackbox::shutdown(void) {
1160 BaseDisplay::shutdown();
1162 XSetInputFocus(getXDisplay(), PointerRoot
, None
, CurrentTime
);
1164 std::for_each(screenList
.begin(), screenList
.end(),
1165 std::mem_fun(&BScreen::shutdown
));
1167 XSync(getXDisplay(), False
);
1172 void Blackbox::saveXineramaPlacement(bool x
) {
1173 resource
.xinerama_placement
= x
;
1174 config
.setValue("session.xineramaSupport.windowPlacement",
1175 resource
.xinerama_placement
);
1176 reconfigure(); // make sure all screens get this change
1180 void Blackbox::saveXineramaMaximizing(bool x
) {
1181 resource
.xinerama_maximize
= x
;
1182 config
.setValue("session.xineramaSupport.windowMaximizing",
1183 resource
.xinerama_maximize
);
1184 reconfigure(); // make sure all screens get this change
1188 void Blackbox::saveXineramaSnapping(bool x
) {
1189 resource
.xinerama_snap
= x
;
1190 config
.setValue("session.xineramaSupport.windowSnapping",
1191 resource
.xinerama_snap
);
1192 reconfigure(); // make sure all screens get this change
1198 * Save all values as they are so that the defaults will be written to the rc
1201 void Blackbox::save_rc(void) {
1202 config
.setAutoSave(false);
1204 config
.setValue("session.colorsPerChannel", resource
.colors_per_channel
);
1205 config
.setValue("session.doubleClickInterval",
1206 resource
.double_click_interval
);
1207 config
.setValue("session.autoRaiseDelay",
1208 ((resource
.auto_raise_delay
.tv_sec
* 1000) +
1209 (resource
.auto_raise_delay
.tv_usec
/ 1000)));
1210 config
.setValue("session.cacheLife", resource
.cache_life
/ 60000);
1211 config
.setValue("session.cacheMax", resource
.cache_max
);
1212 config
.setValue("session.styleFile", resource
.style_file
);
1213 config
.setValue("session.titlebarLayout", resource
.titlebar_layout
);
1216 saveXineramaPlacement(resource
.xinerama_placement
);
1217 saveXineramaMaximizing(resource
.xinerama_maximize
);
1218 saveXineramaSnapping(resource
.xinerama_snap
);
1221 std::for_each(screenList
.begin(), screenList
.end(),
1222 std::mem_fun(&BScreen::save_rc
));
1224 config
.setAutoSave(true);
1229 void Blackbox::load_rc(void) {
1230 if (! config
.load())
1235 if (! config
.getValue("session.colorsPerChannel",
1236 resource
.colors_per_channel
))
1237 resource
.colors_per_channel
= 4;
1238 if (resource
.colors_per_channel
< 2) resource
.colors_per_channel
= 2;
1239 else if (resource
.colors_per_channel
> 6) resource
.colors_per_channel
= 6;
1241 if (config
.getValue("session.styleFile", s
))
1242 resource
.style_file
= expandTilde(s
);
1244 resource
.style_file
= DEFAULTSTYLE
;
1246 if (! config
.getValue("session.doubleClickInterval",
1247 resource
.double_click_interval
));
1248 resource
.double_click_interval
= 250;
1250 if (! config
.getValue("session.autoRaiseDelay",
1251 resource
.auto_raise_delay
.tv_usec
))
1252 resource
.auto_raise_delay
.tv_usec
= 400;
1253 resource
.auto_raise_delay
.tv_sec
= resource
.auto_raise_delay
.tv_usec
/ 1000;
1254 resource
.auto_raise_delay
.tv_usec
-=
1255 (resource
.auto_raise_delay
.tv_sec
* 1000);
1256 resource
.auto_raise_delay
.tv_usec
*= 1000;
1258 if (! config
.getValue("session.cacheLife", resource
.cache_life
))
1259 resource
.cache_life
= 5;
1260 resource
.cache_life
*= 60000;
1262 if (! config
.getValue("session.cacheMax", resource
.cache_max
))
1263 resource
.cache_max
= 200;
1265 if (! config
.getValue("session.titlebarLayout", resource
.titlebar_layout
))
1266 resource
.titlebar_layout
= "ILMC";
1269 if (! config
.getValue("session.xineramaSupport.windowPlacement",
1270 resource
.xinerama_placement
))
1271 resource
.xinerama_placement
= false;
1273 if (! config
.getValue("session.xineramaSupport.windowMaximizing",
1274 resource
.xinerama_maximize
))
1275 resource
.xinerama_maximize
= false;
1277 if (! config
.getValue("session.xineramaSupport.windowSnapping",
1278 resource
.xinerama_snap
))
1279 resource
.xinerama_snap
= false;
1284 void Blackbox::reconfigure(void) {
1285 // don't reconfigure while saving the initial rc file, it's a waste and it
1286 // breaks somethings (workspace names)
1287 if (isStartup()) return;
1289 reconfigure_wait
= True
;
1291 if (! timer
->isTiming()) timer
->start();
1295 void Blackbox::real_reconfigure(void) {
1298 std::for_each(menuTimestamps
.begin(), menuTimestamps
.end(),
1300 menuTimestamps
.clear();
1304 std::for_each(screenList
.begin(), screenList
.end(),
1305 std::mem_fun(&BScreen::reconfigure
));
1309 void Blackbox::checkMenu(void) {
1310 bool reread
= False
;
1311 MenuTimestampList::iterator it
= menuTimestamps
.begin();
1312 for(; it
!= menuTimestamps
.end(); ++it
) {
1313 MenuTimestamp
*tmp
= *it
;
1316 if (! stat(tmp
->filename
.c_str(), &buf
)) {
1317 if (tmp
->timestamp
!= buf
.st_ctime
)
1324 if (reread
) rereadMenu();
1328 void Blackbox::rereadMenu(void) {
1329 reread_menu_wait
= True
;
1331 if (! timer
->isTiming()) timer
->start();
1335 void Blackbox::real_rereadMenu(void) {
1336 std::for_each(menuTimestamps
.begin(), menuTimestamps
.end(),
1338 menuTimestamps
.clear();
1340 std::for_each(screenList
.begin(), screenList
.end(),
1341 std::mem_fun(&BScreen::rereadMenu
));
1345 void Blackbox::saveStyleFilename(const string
& filename
) {
1346 assert(! filename
.empty());
1347 resource
.style_file
= filename
;
1348 config
.setValue("session.styleFile", resource
.style_file
);
1352 void Blackbox::addMenuTimestamp(const string
& filename
) {
1353 assert(! filename
.empty());
1356 MenuTimestampList::iterator it
= menuTimestamps
.begin();
1357 for (; it
!= menuTimestamps
.end() && ! found
; ++it
) {
1358 if ((*it
)->filename
== filename
) found
= True
;
1363 if (! stat(filename
.c_str(), &buf
)) {
1364 MenuTimestamp
*ts
= new MenuTimestamp
;
1366 ts
->filename
= filename
;
1367 ts
->timestamp
= buf
.st_ctime
;
1369 menuTimestamps
.push_back(ts
);
1375 void Blackbox::timeout(void) {
1376 if (reconfigure_wait
)
1379 if (reread_menu_wait
)
1382 reconfigure_wait
= reread_menu_wait
= False
;
1386 void Blackbox::setChangingWindow(BlackboxWindow
*win
) {
1387 // make sure one of the two is null and the other isn't
1388 assert((! changing_window
&& win
) || (! win
&& changing_window
));
1389 changing_window
= win
;
1393 void Blackbox::setFocusedWindow(BlackboxWindow
*win
) {
1394 if (focused_window
&& focused_window
== win
) // nothing to do
1397 BScreen
*old_screen
= 0;
1399 if (focused_window
) {
1400 focused_window
->setFocusFlag(False
);
1401 old_screen
= focused_window
->getScreen();
1404 if (win
&& ! win
->isIconic()) {
1405 // the active screen is the one with the last focused window...
1406 // this will keep focus on this screen no matter where the mouse goes,
1407 // so multihead keybindings will continue to work on that screen until the
1408 // user focuses a window on a different screen.
1409 active_screen
= win
->getScreen();
1410 focused_window
= win
;
1414 if (active_screen
) {
1415 // set input focus to the toolbar of the screen with mouse
1416 XSetInputFocus(getXDisplay(),
1417 active_screen
->getRootWindow(),
1418 RevertToPointerRoot
, CurrentTime
);
1420 // set input focus to the toolbar of the first managed screen
1421 XSetInputFocus(getXDisplay(),
1422 screenList
.front()->getRootWindow(),
1423 RevertToPointerRoot
, CurrentTime
);
1426 // set input focus to the toolbar of the last screen
1427 XSetInputFocus(getXDisplay(), old_screen
->getRootWindow(),
1428 RevertToPointerRoot
, CurrentTime
);
1432 if (active_screen
&& active_screen
->isScreenManaged()) {
1433 active_screen
->getToolbar()->redrawWindowLabel(True
);
1434 active_screen
->updateNetizenWindowFocus();
1437 if (old_screen
&& old_screen
!= active_screen
) {
1438 old_screen
->getToolbar()->redrawWindowLabel(True
);
1439 old_screen
->updateNetizenWindowFocus();