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");
148 if (! rc
) rc
= "~/.openbox/rc";
149 rc_file
= expandTilde(rc
);
150 config
.setFile(rc_file
);
151 if (! menu
) menu
= "~/.openbox/menu";
152 menu_file
= expandTilde(menu
);
156 resource
.auto_raise_delay
.tv_sec
= resource
.auto_raise_delay
.tv_usec
= 0;
159 focused_window
= changing_window
= (BlackboxWindow
*) 0;
164 xatom
= new XAtom(getXDisplay());
166 cursor
.session
= XCreateFontCursor(getXDisplay(), XC_left_ptr
);
167 cursor
.move
= XCreateFontCursor(getXDisplay(), XC_fleur
);
168 cursor
.ll_angle
= XCreateFontCursor(getXDisplay(), XC_ll_angle
);
169 cursor
.lr_angle
= XCreateFontCursor(getXDisplay(), XC_lr_angle
);
170 cursor
.ul_angle
= XCreateFontCursor(getXDisplay(), XC_ul_angle
);
171 cursor
.ur_angle
= XCreateFontCursor(getXDisplay(), XC_ur_angle
);
173 for (unsigned int i
= 0; i
< getNumberOfScreens(); i
++) {
174 BScreen
*screen
= new BScreen(this, i
);
176 if (! screen
->isScreenManaged()) {
181 screenList
.push_back(screen
);
184 if (screenList
.empty()) {
186 i18n(blackboxSet
, blackboxNoManagableScreens
,
187 "Blackbox::Blackbox: no managable screens found, aborting.\n"));
191 // save current settings and default values
194 // set the screen with mouse to the first managed screen
195 active_screen
= screenList
.front();
198 XSynchronize(getXDisplay(), False
);
199 XSync(getXDisplay(), False
);
201 reconfigure_wait
= reread_menu_wait
= False
;
203 timer
= new BTimer(this, this);
204 timer
->setTimeout(0l);
208 Blackbox::~Blackbox(void) {
209 std::for_each(screenList
.begin(), screenList
.end(), PointerAssassin());
211 std::for_each(menuTimestamps
.begin(), menuTimestamps
.end(),
220 void Blackbox::process_event(XEvent
*e
) {
223 // strip the lock key modifiers
224 e
->xbutton
.state
&= ~(NumLockMask
| ScrollLockMask
| LockMask
);
226 last_time
= e
->xbutton
.time
;
228 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
229 Basemenu
*menu
= (Basemenu
*) 0;
230 Slit
*slit
= (Slit
*) 0;
231 Toolbar
*tbar
= (Toolbar
*) 0;
232 BScreen
*scrn
= (BScreen
*) 0;
234 if ((win
= searchWindow(e
->xbutton
.window
))) {
235 win
->buttonPressEvent(&e
->xbutton
);
237 /* XXX: is this sane on low colour desktops? */
238 if (e
->xbutton
.button
== 1)
239 win
->installColormap(True
);
240 } else if ((menu
= searchMenu(e
->xbutton
.window
))) {
241 menu
->buttonPressEvent(&e
->xbutton
);
242 } else if ((slit
= searchSlit(e
->xbutton
.window
))) {
243 slit
->buttonPressEvent(&e
->xbutton
);
244 } else if ((tbar
= searchToolbar(e
->xbutton
.window
))) {
245 tbar
->buttonPressEvent(&e
->xbutton
);
246 } else if ((scrn
= searchScreen(e
->xbutton
.window
))) {
247 scrn
->buttonPressEvent(&e
->xbutton
);
248 if (active_screen
!= scrn
) {
249 active_screen
= scrn
;
250 // first, set no focus window on the old screen
252 // and move focus to this screen
259 case ButtonRelease
: {
260 // strip the lock key modifiers
261 e
->xbutton
.state
&= ~(NumLockMask
| ScrollLockMask
| LockMask
);
263 last_time
= e
->xbutton
.time
;
265 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
266 Basemenu
*menu
= (Basemenu
*) 0;
267 Toolbar
*tbar
= (Toolbar
*) 0;
269 if ((win
= searchWindow(e
->xbutton
.window
)))
270 win
->buttonReleaseEvent(&e
->xbutton
);
271 else if ((menu
= searchMenu(e
->xbutton
.window
)))
272 menu
->buttonReleaseEvent(&e
->xbutton
);
273 else if ((tbar
= searchToolbar(e
->xbutton
.window
)))
274 tbar
->buttonReleaseEvent(&e
->xbutton
);
279 case ConfigureRequest
: {
280 // compress configure requests...
283 while(XCheckTypedWindowEvent(getXDisplay(), e
->xconfigurerequest
.window
,
284 ConfigureRequest
, &realevent
)) {
290 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
291 Slit
*slit
= (Slit
*) 0;
293 if ((win
= searchWindow(e
->xconfigurerequest
.window
))) {
294 win
->configureRequestEvent(&e
->xconfigurerequest
);
295 } else if ((slit
= searchSlit(e
->xconfigurerequest
.window
))) {
296 slit
->configureRequestEvent(&e
->xconfigurerequest
);
298 if (validateWindow(e
->xconfigurerequest
.window
)) {
301 xwc
.x
= e
->xconfigurerequest
.x
;
302 xwc
.y
= e
->xconfigurerequest
.y
;
303 xwc
.width
= e
->xconfigurerequest
.width
;
304 xwc
.height
= e
->xconfigurerequest
.height
;
305 xwc
.border_width
= e
->xconfigurerequest
.border_width
;
306 xwc
.sibling
= e
->xconfigurerequest
.above
;
307 xwc
.stack_mode
= e
->xconfigurerequest
.detail
;
309 XConfigureWindow(getXDisplay(), e
->xconfigurerequest
.window
,
310 e
->xconfigurerequest
.value_mask
, &xwc
);
319 fprintf(stderr
, "Blackbox::process_event(): MapRequest for 0x%lx\n",
320 e
->xmaprequest
.window
);
323 BlackboxWindow
*win
= searchWindow(e
->xmaprequest
.window
);
326 if (win
->isIconic()) {
328 win
->setInputFocus();
331 BScreen
*screen
= searchScreen(e
->xmaprequest
.parent
);
335 we got a map request for a window who's parent isn't root. this
336 can happen in only one circumstance:
338 a client window unmapped a managed window, and then remapped it
339 somewhere between unmapping the client window and reparenting it
342 regardless of how it happens, we need to find the screen that
345 XWindowAttributes wattrib
;
346 if (! XGetWindowAttributes(getXDisplay(), e
->xmaprequest
.window
,
348 // failed to get the window attributes, perhaps the window has
349 // now been destroyed?
353 screen
= searchScreen(wattrib
.root
);
354 assert(screen
!= 0); // this should never happen
357 screen
->manageWindow(e
->xmaprequest
.window
);
364 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
365 Slit
*slit
= (Slit
*) 0;
366 BScreen
*screen
= (BScreen
*) 0;
368 if ((win
= searchWindow(e
->xunmap
.window
))) {
369 win
->unmapNotifyEvent(&e
->xunmap
);
370 } else if ((slit
= searchSlit(e
->xunmap
.window
))) {
371 slit
->unmapNotifyEvent(&e
->xunmap
);
372 } else if ((screen
= searchSystrayWindow(e
->xunmap
.window
))) {
373 screen
->removeSystrayWindow(e
->xunmap
.window
);
374 } else if ((screen
= searchDesktopWindow(e
->xunmap
.window
))) {
375 screen
->removeDesktopWindow(e
->xunmap
.window
);
381 case DestroyNotify
: {
382 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
383 Slit
*slit
= (Slit
*) 0;
384 BScreen
*screen
= (BScreen
*) 0;
385 BWindowGroup
*group
= (BWindowGroup
*) 0;
387 if ((win
= searchWindow(e
->xdestroywindow
.window
))) {
388 win
->destroyNotifyEvent(&e
->xdestroywindow
);
389 } else if ((slit
= searchSlit(e
->xdestroywindow
.window
))) {
390 slit
->removeClient(e
->xdestroywindow
.window
, False
);
391 } else if ((group
= searchGroup(e
->xdestroywindow
.window
))) {
393 } else if ((screen
= searchSystrayWindow(e
->xunmap
.window
))) {
394 screen
->removeSystrayWindow(e
->xunmap
.window
);
395 } else if ((screen
= searchDesktopWindow(e
->xunmap
.window
))) {
396 screen
->removeDesktopWindow(e
->xunmap
.window
);
402 case ReparentNotify
: {
404 this event is quite rare and is usually handled in unmapNotify
405 however, if the window is unmapped when the reparent event occurs
406 the window manager never sees it because an unmap event is not sent
407 to an already unmapped window.
409 BlackboxWindow
*win
= searchWindow(e
->xreparent
.window
);
411 win
->reparentNotifyEvent(&e
->xreparent
);
413 Slit
*slit
= searchSlit(e
->xreparent
.window
);
414 if (slit
&& slit
->getWindowID() != e
->xreparent
.parent
)
415 slit
->removeClient(e
->xreparent
.window
, True
);
421 // motion notify compression...
424 while (XCheckTypedWindowEvent(getXDisplay(), e
->xmotion
.window
,
425 MotionNotify
, &realevent
)) {
429 // if we have compressed some motion events, use the last one
433 // strip the lock key modifiers
434 e
->xbutton
.state
&= ~(NumLockMask
| ScrollLockMask
| LockMask
);
436 last_time
= e
->xmotion
.time
;
438 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
439 Basemenu
*menu
= (Basemenu
*) 0;
441 if ((win
= searchWindow(e
->xmotion
.window
)))
442 win
->motionNotifyEvent(&e
->xmotion
);
443 else if ((menu
= searchMenu(e
->xmotion
.window
)))
444 menu
->motionNotifyEvent(&e
->xmotion
);
449 case PropertyNotify
: {
450 last_time
= e
->xproperty
.time
;
452 BlackboxWindow
*win
= searchWindow(e
->xproperty
.window
);
454 win
->propertyNotifyEvent(&e
->xproperty
);
459 last_time
= e
->xcrossing
.time
;
461 BScreen
*screen
= (BScreen
*) 0;
462 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
463 Basemenu
*menu
= (Basemenu
*) 0;
464 Toolbar
*tbar
= (Toolbar
*) 0;
465 Slit
*slit
= (Slit
*) 0;
467 if (e
->xcrossing
.mode
== NotifyGrab
) break;
471 sa
.w
= e
->xcrossing
.window
;
472 sa
.enter
= sa
.leave
= False
;
473 XCheckIfEvent(getXDisplay(), &dummy
, queueScanner
, (char *) &sa
);
475 if ((e
->xcrossing
.window
== e
->xcrossing
.root
) &&
476 (screen
= searchScreen(e
->xcrossing
.window
))) {
477 screen
->getImageControl()->installRootColormap();
478 } else if ((win
= searchWindow(e
->xcrossing
.window
))) {
479 if (win
->getScreen()->isSloppyFocus() &&
480 (! win
->isFocused()) && (! no_focus
)) {
481 if (((! sa
.leave
) || sa
.inferior
) && win
->isVisible()) {
482 if (win
->setInputFocus())
483 win
->installColormap(True
); // XXX: shouldnt we honour no install?
486 } else if ((menu
= searchMenu(e
->xcrossing
.window
))) {
487 menu
->enterNotifyEvent(&e
->xcrossing
);
488 } else if ((tbar
= searchToolbar(e
->xcrossing
.window
))) {
489 tbar
->enterNotifyEvent(&e
->xcrossing
);
490 } else if ((slit
= searchSlit(e
->xcrossing
.window
))) {
491 slit
->enterNotifyEvent(&e
->xcrossing
);
497 last_time
= e
->xcrossing
.time
;
499 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
500 Basemenu
*menu
= (Basemenu
*) 0;
501 Toolbar
*tbar
= (Toolbar
*) 0;
502 Slit
*slit
= (Slit
*) 0;
504 if ((menu
= searchMenu(e
->xcrossing
.window
)))
505 menu
->leaveNotifyEvent(&e
->xcrossing
);
506 else if ((win
= searchWindow(e
->xcrossing
.window
)))
507 win
->installColormap(False
);
508 else if ((tbar
= searchToolbar(e
->xcrossing
.window
)))
509 tbar
->leaveNotifyEvent(&e
->xcrossing
);
510 else if ((slit
= searchSlit(e
->xcrossing
.window
)))
511 slit
->leaveNotifyEvent(&e
->xcrossing
);
516 // compress expose events
519 int ex1
, ey1
, ex2
, ey2
;
522 ex2
= ex1
+ e
->xexpose
.width
- 1;
523 ey2
= ey1
+ e
->xexpose
.height
- 1;
524 while (XCheckTypedWindowEvent(getXDisplay(), e
->xexpose
.window
,
525 Expose
, &realevent
)) {
529 ex1
= std::min(realevent
.xexpose
.x
, ex1
);
530 ey1
= std::min(realevent
.xexpose
.y
, ey1
);
531 ex2
= std::max(realevent
.xexpose
.x
+ realevent
.xexpose
.width
- 1, ex2
);
532 ey2
= std::max(realevent
.xexpose
.y
+ realevent
.xexpose
.height
- 1, ey2
);
537 // use the merged area
540 e
->xexpose
.width
= ex2
- ex1
+ 1;
541 e
->xexpose
.height
= ey2
- ey1
+ 1;
543 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
544 Basemenu
*menu
= (Basemenu
*) 0;
545 Toolbar
*tbar
= (Toolbar
*) 0;
547 if ((win
= searchWindow(e
->xexpose
.window
)))
548 win
->exposeEvent(&e
->xexpose
);
549 else if ((menu
= searchMenu(e
->xexpose
.window
)))
550 menu
->exposeEvent(&e
->xexpose
);
551 else if ((tbar
= searchToolbar(e
->xexpose
.window
)))
552 tbar
->exposeEvent(&e
->xexpose
);
558 Toolbar
*tbar
= searchToolbar(e
->xkey
.window
);
560 if (tbar
&& tbar
->isEditing())
561 tbar
->keyPressEvent(&e
->xkey
);
566 case ColormapNotify
: {
567 BScreen
*screen
= searchScreen(e
->xcolormap
.window
);
570 screen
->setRootColormapInstalled((e
->xcolormap
.state
==
571 ColormapInstalled
) ? True
: False
);
577 if (e
->xfocus
.detail
!= NotifyNonlinear
&&
578 e
->xfocus
.detail
!= NotifyAncestor
) {
580 don't process FocusIns when:
581 1. the new focus window isn't an ancestor or inferior of the old
582 focus window (NotifyNonlinear)
583 make sure to allow the FocusIn when the old focus window was an
584 ancestor but didn't have a parent, such as root (NotifyAncestor)
589 BlackboxWindow
*win
= searchWindow(e
->xfocus
.window
);
591 if (! win
->isFocused())
592 win
->setFocusFlag(True
);
595 set the event window to None. when the FocusOut event handler calls
596 this function recursively, it uses this as an indication that focus
597 has moved to a known window.
599 e
->xfocus
.window
= None
;
606 if (e
->xfocus
.detail
!= NotifyNonlinear
) {
608 don't process FocusOuts when:
609 2. the new focus window isn't an ancestor or inferior of the old
610 focus window (NotifyNonlinear)
615 BlackboxWindow
*win
= searchWindow(e
->xfocus
.window
);
616 if (win
&& win
->isFocused()) {
618 before we mark "win" as unfocused, we need to verify that focus is
619 going to a known location, is in a known location, or set focus
624 // don't check the current focus if FocusOut was generated during a grab
625 bool check_focus
= (e
->xfocus
.mode
== NotifyNormal
);
628 First, check if there is a pending FocusIn event waiting. if there
629 is, process it and determine if focus has moved to another window
630 (the FocusIn event handler sets the window in the event
631 structure to None to indicate this).
633 if (XCheckTypedEvent(getXDisplay(), FocusIn
, &event
)) {
635 process_event(&event
);
636 if (event
.xfocus
.window
== None
) {
644 Second, we query the X server for the current input focus.
645 to make sure that we keep a consistent state.
647 BlackboxWindow
*focus
;
650 XGetInputFocus(getXDisplay(), &w
, &revert
);
651 focus
= searchWindow(w
);
654 focus got from "win" to "focus" under some very strange
655 circumstances, and we need to make sure that the focus indication
658 setFocusedWindow(focus
);
660 // we have no idea where focus went... so we set it to somewhere
669 case ClientMessage
: {
670 if (e
->xclient
.format
== 32) {
671 if (e
->xclient
.message_type
== xatom
->getAtom(XAtom::wm_change_state
)) {
672 // WM_CHANGE_STATE message
673 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
674 if (! win
|| ! win
->validateClient()) return;
676 if (e
->xclient
.data
.l
[0] == IconicState
)
678 if (e
->xclient
.data
.l
[0] == NormalState
)
680 } else if (e
->xclient
.message_type
==
681 xatom
->getAtom(XAtom::blackbox_change_workspace
) ||
682 e
->xclient
.message_type
==
683 xatom
->getAtom(XAtom::net_current_desktop
)) {
684 // NET_CURRENT_DESKTOP message
685 BScreen
*screen
= searchScreen(e
->xclient
.window
);
687 unsigned int workspace
= e
->xclient
.data
.l
[0];
688 if (screen
&& workspace
< screen
->getWorkspaceCount())
689 screen
->changeWorkspaceID(workspace
);
690 } else if (e
->xclient
.message_type
==
691 xatom
->getAtom(XAtom::blackbox_change_window_focus
) ||
692 e
->xclient
.message_type
==
693 xatom
->getAtom(XAtom::net_active_window
)) {
695 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
699 win
->deiconify(False
, True
);
700 if (win
->isVisible() && win
->setInputFocus()) {
701 //win->getScreen()->getWorkspace(win->getWorkspaceNumber())->
703 win
->installColormap(True
);
706 } else if (e
->xclient
.message_type
==
707 xatom
->getAtom(XAtom::blackbox_cycle_window_focus
)) {
708 // BLACKBOX_CYCLE_WINDOW_FOCUS
709 BScreen
*screen
= searchScreen(e
->xclient
.window
);
712 if (! e
->xclient
.data
.l
[0])
717 } else if (e
->xclient
.message_type
==
718 xatom
->getAtom(XAtom::net_wm_desktop
)) {
720 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
723 BScreen
*screen
= win
->getScreen();
724 unsigned long wksp
= (unsigned) e
->xclient
.data
.l
[0];
725 if (wksp
< screen
->getWorkspaceCount()) {
726 if (win
->isIconic()) win
->deiconify(False
, True
);
727 if (win
->isStuck()) win
->stick();
728 if (wksp
!= screen
->getCurrentWorkspaceID())
732 screen
->reassociateWindow(win
, wksp
, True
);
733 } else if (wksp
== 0xfffffffe) { // XXX: BUG, BUT DOING THIS SO KDE WORKS FOR NOW!!
734 if (win
->isIconic()) win
->deiconify(False
, True
);
735 if (! win
->isStuck()) win
->stick();
736 if (! win
->isVisible()) win
->show();
739 } else if (e
->xclient
.message_type
==
740 xatom
->getAtom(XAtom::blackbox_change_attributes
)) {
741 // BLACKBOX_CHANGE_ATTRIBUTES
742 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
744 if (win
&& win
->validateClient()) {
746 net
.flags
= e
->xclient
.data
.l
[0];
747 net
.attrib
= e
->xclient
.data
.l
[1];
748 net
.workspace
= e
->xclient
.data
.l
[2];
749 net
.stack
= e
->xclient
.data
.l
[3];
750 net
.decoration
= e
->xclient
.data
.l
[4];
752 win
->changeBlackboxHints(&net
);
754 } else if (e
->xclient
.message_type
==
755 xatom
->getAtom(XAtom::net_number_of_desktops
)) {
756 // NET_NUMBER_OF_DESKTOPS
757 BScreen
*screen
= searchScreen(e
->xclient
.window
);
759 if (e
->xclient
.data
.l
[0] > 0) {
760 if ((unsigned) e
->xclient
.data
.l
[0] < screen
->getWorkspaceCount()) {
762 for (int i
= screen
->getWorkspaceCount();
763 i
> e
->xclient
.data
.l
[0]; --i
)
764 screen
->removeLastWorkspace();
765 // removeLast already sets the current workspace to the
766 // last available one.
767 } else if ((unsigned) e
->xclient
.data
.l
[0] >
768 screen
->getWorkspaceCount()) {
770 for(int i
= screen
->getWorkspaceCount();
771 i
< e
->xclient
.data
.l
[0]; ++i
)
772 screen
->addWorkspace();
775 } else if (e
->xclient
.message_type
==
776 xatom
->getAtom(XAtom::net_close_window
)) {
778 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
779 if (win
&& win
->validateClient())
780 win
->close(); // could this be smarter?
781 } else if (e
->xclient
.message_type
==
782 xatom
->getAtom(XAtom::net_wm_moveresize
)) {
784 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
785 if (win
&& win
->validateClient()) {
786 int x_root
= e
->xclient
.data
.l
[0],
787 y_root
= e
->xclient
.data
.l
[1];
788 if ((Atom
) e
->xclient
.data
.l
[2] ==
789 xatom
->getAtom(XAtom::net_wm_moveresize_move
)) {
790 win
->beginMove(x_root
, y_root
);
792 if ((Atom
) e
->xclient
.data
.l
[2] ==
793 xatom
->getAtom(XAtom::net_wm_moveresize_size_topleft
))
794 win
->beginResize(x_root
, y_root
, BlackboxWindow::TopLeft
);
795 else if ((Atom
) e
->xclient
.data
.l
[2] ==
796 xatom
->getAtom(XAtom::net_wm_moveresize_size_topright
))
797 win
->beginResize(x_root
, y_root
, BlackboxWindow::TopRight
);
798 else if ((Atom
) e
->xclient
.data
.l
[2] ==
799 xatom
->getAtom(XAtom::net_wm_moveresize_size_bottomleft
))
800 win
->beginResize(x_root
, y_root
, BlackboxWindow::BottomLeft
);
801 else if ((Atom
) e
->xclient
.data
.l
[2] ==
802 xatom
->getAtom(XAtom::net_wm_moveresize_size_bottomright
))
803 win
->beginResize(x_root
, y_root
, BlackboxWindow::BottomRight
);
806 } else if (e
->xclient
.message_type
==
807 xatom
->getAtom(XAtom::net_wm_state
)) {
809 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
810 if (win
&& win
->validateClient()) {
811 const Atom action
= (Atom
) e
->xclient
.data
.l
[0];
812 const Atom state
[] = { (Atom
) e
->xclient
.data
.l
[1],
813 (Atom
) e
->xclient
.data
.l
[2] };
815 for (int i
= 0; i
< 2; ++i
) {
819 if ((Atom
) e
->xclient
.data
.l
[0] == 1) {
821 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
823 } else if (state
[i
] ==
824 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
825 if (win
->isMaximizedHoriz()) {
826 win
->maximize(0); // unmaximize
827 win
->maximize(1); // full
828 } else if (! win
->isMaximized()) {
829 win
->maximize(2); // vert
831 } else if (state
[i
] ==
832 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
833 if (win
->isMaximizedVert()) {
834 win
->maximize(0); // unmaximize
835 win
->maximize(1); // full
836 } else if (! win
->isMaximized()) {
837 win
->maximize(3); // horiz
839 } else if (state
[i
] ==
840 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
841 if (! win
->isShaded())
843 } else if (state
[i
] ==
844 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
845 win
->setSkipTaskbar(True
);
846 } else if (state
[i
] ==
847 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
848 win
->setSkipPager(True
);
849 } else if (state
[i
] ==
850 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
851 win
->setFullscreen(True
);
853 } else if (action
== 0) {
855 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
856 win
->setModal(False
);
857 } else if (state
[i
] ==
858 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
859 if (win
->isMaximizedFull()) {
860 win
->maximize(0); // unmaximize
861 win
->maximize(3); // horiz
862 } else if (win
->isMaximizedVert()) {
863 win
->maximize(0); // unmaximize
865 } else if (state
[i
] ==
866 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
867 if (win
->isMaximizedFull()) {
868 win
->maximize(0); // unmaximize
869 win
->maximize(2); // vert
870 } else if (win
->isMaximizedHoriz()) {
871 win
->maximize(0); // unmaximize
873 } else if (state
[i
] ==
874 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
877 } else if (state
[i
] ==
878 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
879 win
->setSkipTaskbar(False
);
880 } else if (state
[i
] ==
881 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
882 win
->setSkipPager(False
);
883 } else if (state
[i
] ==
884 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
885 win
->setFullscreen(False
);
887 } else if (action
== 2) {
889 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
890 win
->setModal(! win
->isModal());
891 } else if (state
[i
] ==
892 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
893 if (win
->isMaximizedFull()) {
894 win
->maximize(0); // unmaximize
895 win
->maximize(3); // horiz
896 } else if (win
->isMaximizedVert()) {
897 win
->maximize(0); // unmaximize
898 } else if (win
->isMaximizedHoriz()) {
899 win
->maximize(0); // unmaximize
900 win
->maximize(1); // full
902 win
->maximize(2); // vert
904 } else if (state
[i
] ==
905 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
906 if (win
->isMaximizedFull()) {
907 win
->maximize(0); // unmaximize
908 win
->maximize(2); // vert
909 } else if (win
->isMaximizedHoriz()) {
910 win
->maximize(0); // unmaximize
911 } else if (win
->isMaximizedVert()) {
912 win
->maximize(0); // unmaximize
913 win
->maximize(1); // full
915 win
->maximize(3); // horiz
917 } else if (state
[i
] ==
918 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
920 } else if (state
[i
] ==
921 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
922 win
->setSkipTaskbar(! win
->skipTaskbar());
923 } else if (state
[i
] ==
924 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
925 win
->setSkipPager(! win
->skipPager());
926 } else if (state
[i
] ==
927 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
928 win
->setFullscreen(! win
->isFullscreen());
940 case ConfigureNotify
:
942 break; // not handled, just ignore
946 if (e
->type
== getShapeEventBase()) {
947 XShapeEvent
*shape_event
= (XShapeEvent
*) e
;
948 BlackboxWindow
*win
= searchWindow(e
->xany
.window
);
951 win
->shapeEvent(shape_event
);
959 bool Blackbox::handleSignal(int sig
) {
985 bool Blackbox::validateWindow(Window window
) {
987 if (XCheckTypedWindowEvent(getXDisplay(), window
, DestroyNotify
, &event
)) {
988 XPutBackEvent(getXDisplay(), &event
);
997 BScreen
*Blackbox::searchScreen(Window window
) {
998 ScreenList::iterator it
= screenList
.begin();
1000 for (; it
!= screenList
.end(); ++it
) {
1002 if (s
->getRootWindow() == window
)
1006 return (BScreen
*) 0;
1010 BScreen
*Blackbox::searchDesktopWindow(Window window
) {
1011 WindowScreenLookup::iterator it
= desktopSearchList
.find(window
);
1012 if (it
!= desktopSearchList
.end())
1015 return (BScreen
*) 0;
1019 BScreen
*Blackbox::searchSystrayWindow(Window window
) {
1020 WindowScreenLookup::iterator it
= systraySearchList
.find(window
);
1021 if (it
!= systraySearchList
.end())
1024 return (BScreen
*) 0;
1028 BlackboxWindow
*Blackbox::searchWindow(Window window
) {
1029 WindowLookup::iterator it
= windowSearchList
.find(window
);
1030 if (it
!= windowSearchList
.end())
1033 return (BlackboxWindow
*) 0;
1037 BWindowGroup
*Blackbox::searchGroup(Window window
) {
1038 GroupLookup::iterator it
= groupSearchList
.find(window
);
1039 if (it
!= groupSearchList
.end())
1042 return (BWindowGroup
*) 0;
1046 Basemenu
*Blackbox::searchMenu(Window window
) {
1047 MenuLookup::iterator it
= menuSearchList
.find(window
);
1048 if (it
!= menuSearchList
.end())
1051 return (Basemenu
*) 0;
1055 Toolbar
*Blackbox::searchToolbar(Window window
) {
1056 ToolbarLookup::iterator it
= toolbarSearchList
.find(window
);
1057 if (it
!= toolbarSearchList
.end())
1060 return (Toolbar
*) 0;
1064 Slit
*Blackbox::searchSlit(Window window
) {
1065 SlitLookup::iterator it
= slitSearchList
.find(window
);
1066 if (it
!= slitSearchList
.end())
1073 void Blackbox::saveDesktopWindowSearch(Window window
, BScreen
*screen
) {
1074 desktopSearchList
.insert(WindowScreenLookupPair(window
, screen
));
1078 void Blackbox::saveSystrayWindowSearch(Window window
, BScreen
*screen
) {
1079 systraySearchList
.insert(WindowScreenLookupPair(window
, screen
));
1083 void Blackbox::saveWindowSearch(Window window
, BlackboxWindow
*data
) {
1084 windowSearchList
.insert(WindowLookupPair(window
, data
));
1088 void Blackbox::saveGroupSearch(Window window
, BWindowGroup
*data
) {
1089 groupSearchList
.insert(GroupLookupPair(window
, data
));
1093 void Blackbox::saveMenuSearch(Window window
, Basemenu
*data
) {
1094 menuSearchList
.insert(MenuLookupPair(window
, data
));
1098 void Blackbox::saveToolbarSearch(Window window
, Toolbar
*data
) {
1099 toolbarSearchList
.insert(ToolbarLookupPair(window
, data
));
1103 void Blackbox::saveSlitSearch(Window window
, Slit
*data
) {
1104 slitSearchList
.insert(SlitLookupPair(window
, data
));
1108 void Blackbox::removeDesktopWindowSearch(Window window
) {
1109 desktopSearchList
.erase(window
);
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 * Save all values as they are so that the defaults will be written to the rc
1175 void Blackbox::save_rc(void) {
1176 config
.setAutoSave(false);
1178 config
.setValue("session.colorsPerChannel", resource
.colors_per_channel
);
1179 config
.setValue("session.doubleClickInterval",
1180 resource
.double_click_interval
);
1181 config
.setValue("session.autoRaiseDelay",
1182 ((resource
.auto_raise_delay
.tv_sec
* 1000) +
1183 (resource
.auto_raise_delay
.tv_usec
/ 1000)));
1184 config
.setValue("session.cacheLife", resource
.cache_life
/ 60000);
1185 config
.setValue("session.cacheMax", resource
.cache_max
);
1186 config
.setValue("session.styleFile", resource
.style_file
);
1187 config
.setValue("session.titlebarLayout", resource
.titlebar_layout
);
1189 std::for_each(screenList
.begin(), screenList
.end(),
1190 std::mem_fun(&BScreen::save_rc
));
1192 config
.setAutoSave(true);
1197 void Blackbox::load_rc(void) {
1198 if (! config
.load())
1203 if (! config
.getValue("session.colorsPerChannel",
1204 resource
.colors_per_channel
))
1205 resource
.colors_per_channel
= 4;
1206 if (resource
.colors_per_channel
< 2) resource
.colors_per_channel
= 2;
1207 else if (resource
.colors_per_channel
> 6) resource
.colors_per_channel
= 6;
1209 if (config
.getValue("session.styleFile", s
))
1210 resource
.style_file
= expandTilde(s
);
1212 resource
.style_file
= DEFAULTSTYLE
;
1214 if (! config
.getValue("session.doubleClickInterval",
1215 resource
.double_click_interval
));
1216 resource
.double_click_interval
= 250;
1218 if (! config
.getValue("session.autoRaiseDelay",
1219 resource
.auto_raise_delay
.tv_usec
))
1220 resource
.auto_raise_delay
.tv_usec
= 400;
1221 resource
.auto_raise_delay
.tv_sec
= resource
.auto_raise_delay
.tv_usec
/ 1000;
1222 resource
.auto_raise_delay
.tv_usec
-=
1223 (resource
.auto_raise_delay
.tv_sec
* 1000);
1224 resource
.auto_raise_delay
.tv_usec
*= 1000;
1226 if (! config
.getValue("session.cacheLife", resource
.cache_life
))
1227 resource
.cache_life
= 5;
1228 resource
.cache_life
*= 60000;
1230 if (! config
.getValue("session.cacheMax", resource
.cache_max
))
1231 resource
.cache_max
= 200;
1233 if (! config
.getValue("session.titlebarLayout", resource
.titlebar_layout
))
1234 resource
.titlebar_layout
= "ILMC";
1238 void Blackbox::reconfigure(void) {
1239 reconfigure_wait
= True
;
1241 if (! timer
->isTiming()) timer
->start();
1245 void Blackbox::real_reconfigure(void) {
1248 std::for_each(menuTimestamps
.begin(), menuTimestamps
.end(),
1250 menuTimestamps
.clear();
1254 std::for_each(screenList
.begin(), screenList
.end(),
1255 std::mem_fun(&BScreen::reconfigure
));
1259 void Blackbox::checkMenu(void) {
1260 bool reread
= False
;
1261 MenuTimestampList::iterator it
= menuTimestamps
.begin();
1262 for(; it
!= menuTimestamps
.end(); ++it
) {
1263 MenuTimestamp
*tmp
= *it
;
1266 if (! stat(tmp
->filename
.c_str(), &buf
)) {
1267 if (tmp
->timestamp
!= buf
.st_ctime
)
1274 if (reread
) rereadMenu();
1278 void Blackbox::rereadMenu(void) {
1279 reread_menu_wait
= True
;
1281 if (! timer
->isTiming()) timer
->start();
1285 void Blackbox::real_rereadMenu(void) {
1286 std::for_each(menuTimestamps
.begin(), menuTimestamps
.end(),
1288 menuTimestamps
.clear();
1290 std::for_each(screenList
.begin(), screenList
.end(),
1291 std::mem_fun(&BScreen::rereadMenu
));
1295 void Blackbox::saveStyleFilename(const string
& filename
) {
1296 assert(! filename
.empty());
1297 resource
.style_file
= filename
;
1298 config
.setValue("session.styleFile", resource
.style_file
);
1302 void Blackbox::addMenuTimestamp(const string
& filename
) {
1303 assert(! filename
.empty());
1306 MenuTimestampList::iterator it
= menuTimestamps
.begin();
1307 for (; it
!= menuTimestamps
.end() && ! found
; ++it
) {
1308 if ((*it
)->filename
== filename
) found
= True
;
1313 if (! stat(filename
.c_str(), &buf
)) {
1314 MenuTimestamp
*ts
= new MenuTimestamp
;
1316 ts
->filename
= filename
;
1317 ts
->timestamp
= buf
.st_ctime
;
1319 menuTimestamps
.push_back(ts
);
1325 void Blackbox::timeout(void) {
1326 if (reconfigure_wait
)
1329 if (reread_menu_wait
)
1332 reconfigure_wait
= reread_menu_wait
= False
;
1336 void Blackbox::setChangingWindow(BlackboxWindow
*win
) {
1337 // make sure one of the two is null and the other isn't
1338 assert((! changing_window
&& win
) || (! win
&& changing_window
));
1339 changing_window
= win
;
1343 void Blackbox::setFocusedWindow(BlackboxWindow
*win
) {
1344 if (focused_window
&& focused_window
== win
) // nothing to do
1347 BScreen
*old_screen
= 0;
1349 if (focused_window
) {
1350 focused_window
->setFocusFlag(False
);
1351 old_screen
= focused_window
->getScreen();
1354 if (win
&& ! win
->isIconic()) {
1355 // the active screen is the one with the last focused window...
1356 // this will keep focus on this screen no matter where the mouse goes,
1357 // so multihead keybindings will continue to work on that screen until the
1358 // user focuses a window on a different screen.
1359 active_screen
= win
->getScreen();
1360 focused_window
= win
;
1364 if (active_screen
) {
1365 // set input focus to the toolbar of the screen with mouse
1366 XSetInputFocus(getXDisplay(),
1367 active_screen
->getRootWindow(),
1368 RevertToPointerRoot
, CurrentTime
);
1370 // set input focus to the toolbar of the first managed screen
1371 XSetInputFocus(getXDisplay(),
1372 screenList
.front()->getRootWindow(),
1373 RevertToPointerRoot
, CurrentTime
);
1376 // set input focus to the toolbar of the last screen
1377 XSetInputFocus(getXDisplay(), old_screen
->getRootWindow(),
1378 RevertToPointerRoot
, CurrentTime
);
1382 if (active_screen
&& active_screen
->isScreenManaged()) {
1383 active_screen
->getToolbar()->redrawWindowLabel(True
);
1384 active_screen
->updateNetizenWindowFocus();
1387 if (old_screen
&& old_screen
!= active_screen
) {
1388 old_screen
->getToolbar()->redrawWindowLabel(True
);
1389 old_screen
->updateNetizenWindowFocus();