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
);
387 } else if ((screen
= searchDesktopWindow(e
->xunmap
.window
))) {
388 screen
->removeDesktopWindow(e
->xunmap
.window
);
394 case DestroyNotify
: {
395 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
396 Slit
*slit
= (Slit
*) 0;
397 BScreen
*screen
= (BScreen
*) 0;
398 BWindowGroup
*group
= (BWindowGroup
*) 0;
400 if ((win
= searchWindow(e
->xdestroywindow
.window
))) {
401 win
->destroyNotifyEvent(&e
->xdestroywindow
);
402 } else if ((slit
= searchSlit(e
->xdestroywindow
.window
))) {
403 slit
->removeClient(e
->xdestroywindow
.window
, False
);
404 } else if ((group
= searchGroup(e
->xdestroywindow
.window
))) {
406 } else if ((screen
= searchSystrayWindow(e
->xunmap
.window
))) {
407 screen
->removeSystrayWindow(e
->xunmap
.window
);
408 } else if ((screen
= searchDesktopWindow(e
->xunmap
.window
))) {
409 screen
->removeDesktopWindow(e
->xunmap
.window
);
415 case ReparentNotify
: {
417 this event is quite rare and is usually handled in unmapNotify
418 however, if the window is unmapped when the reparent event occurs
419 the window manager never sees it because an unmap event is not sent
420 to an already unmapped window.
422 BlackboxWindow
*win
= searchWindow(e
->xreparent
.window
);
424 win
->reparentNotifyEvent(&e
->xreparent
);
426 Slit
*slit
= searchSlit(e
->xreparent
.window
);
427 if (slit
&& slit
->getWindowID() != e
->xreparent
.parent
)
428 slit
->removeClient(e
->xreparent
.window
, True
);
434 // motion notify compression...
437 while (XCheckTypedWindowEvent(getXDisplay(), e
->xmotion
.window
,
438 MotionNotify
, &realevent
)) {
442 // if we have compressed some motion events, use the last one
446 // strip the lock key modifiers
447 e
->xbutton
.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 if (((! sa
.leave
) || sa
.inferior
) && win
->isVisible()) {
499 if (win
->setInputFocus())
500 win
->installColormap(True
); // XXX: shouldnt we honour no install?
503 } else if ((menu
= searchMenu(e
->xcrossing
.window
))) {
504 menu
->enterNotifyEvent(&e
->xcrossing
);
505 } else if ((tbar
= searchToolbar(e
->xcrossing
.window
))) {
506 tbar
->enterNotifyEvent(&e
->xcrossing
);
507 } else if ((slit
= searchSlit(e
->xcrossing
.window
))) {
508 slit
->enterNotifyEvent(&e
->xcrossing
);
514 last_time
= e
->xcrossing
.time
;
516 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
517 Basemenu
*menu
= (Basemenu
*) 0;
518 Toolbar
*tbar
= (Toolbar
*) 0;
519 Slit
*slit
= (Slit
*) 0;
521 if ((menu
= searchMenu(e
->xcrossing
.window
)))
522 menu
->leaveNotifyEvent(&e
->xcrossing
);
523 else if ((win
= searchWindow(e
->xcrossing
.window
)))
524 win
->installColormap(False
);
525 else if ((tbar
= searchToolbar(e
->xcrossing
.window
)))
526 tbar
->leaveNotifyEvent(&e
->xcrossing
);
527 else if ((slit
= searchSlit(e
->xcrossing
.window
)))
528 slit
->leaveNotifyEvent(&e
->xcrossing
);
533 // compress expose events
536 int ex1
, ey1
, ex2
, ey2
;
539 ex2
= ex1
+ e
->xexpose
.width
- 1;
540 ey2
= ey1
+ e
->xexpose
.height
- 1;
541 while (XCheckTypedWindowEvent(getXDisplay(), e
->xexpose
.window
,
542 Expose
, &realevent
)) {
546 ex1
= std::min(realevent
.xexpose
.x
, ex1
);
547 ey1
= std::min(realevent
.xexpose
.y
, ey1
);
548 ex2
= std::max(realevent
.xexpose
.x
+ realevent
.xexpose
.width
- 1, ex2
);
549 ey2
= std::max(realevent
.xexpose
.y
+ realevent
.xexpose
.height
- 1, ey2
);
554 // use the merged area
557 e
->xexpose
.width
= ex2
- ex1
+ 1;
558 e
->xexpose
.height
= ey2
- ey1
+ 1;
560 BlackboxWindow
*win
= (BlackboxWindow
*) 0;
561 Basemenu
*menu
= (Basemenu
*) 0;
562 Toolbar
*tbar
= (Toolbar
*) 0;
564 if ((win
= searchWindow(e
->xexpose
.window
)))
565 win
->exposeEvent(&e
->xexpose
);
566 else if ((menu
= searchMenu(e
->xexpose
.window
)))
567 menu
->exposeEvent(&e
->xexpose
);
568 else if ((tbar
= searchToolbar(e
->xexpose
.window
)))
569 tbar
->exposeEvent(&e
->xexpose
);
575 Toolbar
*tbar
= searchToolbar(e
->xkey
.window
);
577 if (tbar
&& tbar
->isEditing())
578 tbar
->keyPressEvent(&e
->xkey
);
583 case ColormapNotify
: {
584 BScreen
*screen
= searchScreen(e
->xcolormap
.window
);
587 screen
->setRootColormapInstalled((e
->xcolormap
.state
==
588 ColormapInstalled
) ? True
: False
);
594 if (e
->xfocus
.detail
!= NotifyNonlinear
&&
595 e
->xfocus
.detail
!= NotifyAncestor
) {
597 don't process FocusIns when:
598 1. the new focus window isn't an ancestor or inferior of the old
599 focus window (NotifyNonlinear)
600 make sure to allow the FocusIn when the old focus window was an
601 ancestor but didn't have a parent, such as root (NotifyAncestor)
606 BlackboxWindow
*win
= searchWindow(e
->xfocus
.window
);
608 if (! win
->isFocused())
609 win
->setFocusFlag(True
);
612 set the event window to None. when the FocusOut event handler calls
613 this function recursively, it uses this as an indication that focus
614 has moved to a known window.
616 e
->xfocus
.window
= None
;
623 if (e
->xfocus
.detail
!= NotifyNonlinear
) {
625 don't process FocusOuts when:
626 2. the new focus window isn't an ancestor or inferior of the old
627 focus window (NotifyNonlinear)
632 BlackboxWindow
*win
= searchWindow(e
->xfocus
.window
);
633 if (win
&& win
->isFocused()) {
635 before we mark "win" as unfocused, we need to verify that focus is
636 going to a known location, is in a known location, or set focus
641 // don't check the current focus if FocusOut was generated during a grab
642 bool check_focus
= (e
->xfocus
.mode
== NotifyNormal
);
645 First, check if there is a pending FocusIn event waiting. if there
646 is, process it and determine if focus has moved to another window
647 (the FocusIn event handler sets the window in the event
648 structure to None to indicate this).
650 if (XCheckTypedEvent(getXDisplay(), FocusIn
, &event
)) {
652 process_event(&event
);
653 if (event
.xfocus
.window
== None
) {
661 Second, we query the X server for the current input focus.
662 to make sure that we keep a consistent state.
664 BlackboxWindow
*focus
;
667 XGetInputFocus(getXDisplay(), &w
, &revert
);
668 focus
= searchWindow(w
);
671 focus got from "win" to "focus" under some very strange
672 circumstances, and we need to make sure that the focus indication
675 setFocusedWindow(focus
);
677 // we have no idea where focus went... so we set it to somewhere
686 case ClientMessage
: {
687 if (e
->xclient
.format
== 32) {
688 if (e
->xclient
.message_type
== xatom
->getAtom(XAtom::wm_change_state
)) {
689 // WM_CHANGE_STATE message
690 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
691 if (! win
|| ! win
->validateClient()) return;
693 if (e
->xclient
.data
.l
[0] == IconicState
)
695 if (e
->xclient
.data
.l
[0] == NormalState
)
697 } else if (e
->xclient
.message_type
==
698 xatom
->getAtom(XAtom::blackbox_change_workspace
) ||
699 e
->xclient
.message_type
==
700 xatom
->getAtom(XAtom::net_current_desktop
)) {
701 // NET_CURRENT_DESKTOP message
702 BScreen
*screen
= searchScreen(e
->xclient
.window
);
704 unsigned int workspace
= e
->xclient
.data
.l
[0];
705 if (screen
&& workspace
< screen
->getWorkspaceCount())
706 screen
->changeWorkspaceID(workspace
);
707 } else if (e
->xclient
.message_type
==
708 xatom
->getAtom(XAtom::blackbox_change_window_focus
)) {
709 // TEMP HACK TO KEEP BBKEYS WORKING
710 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
712 if (win
&& win
->isVisible() && win
->setInputFocus())
713 win
->installColormap(True
);
714 } else if (e
->xclient
.message_type
==
715 xatom
->getAtom(XAtom::net_active_window
)) {
717 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
721 win
->deiconify(False
, True
);
724 if (win
->isVisible() && win
->setInputFocus()) {
725 win
->getScreen()->getWorkspace(win
->getWorkspaceNumber())->
727 win
->installColormap(True
);
730 } else if (e
->xclient
.message_type
==
731 xatom
->getAtom(XAtom::blackbox_cycle_window_focus
)) {
732 // BLACKBOX_CYCLE_WINDOW_FOCUS
733 BScreen
*screen
= searchScreen(e
->xclient
.window
);
736 if (! e
->xclient
.data
.l
[0])
741 } else if (e
->xclient
.message_type
==
742 xatom
->getAtom(XAtom::net_wm_desktop
)) {
744 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
747 BScreen
*screen
= win
->getScreen();
748 unsigned long wksp
= (unsigned) e
->xclient
.data
.l
[0];
749 if (wksp
< screen
->getWorkspaceCount()) {
750 if (win
->isIconic()) win
->deiconify(False
, True
);
751 if (win
->isStuck()) win
->stick();
752 if (wksp
!= screen
->getCurrentWorkspaceID())
756 screen
->reassociateWindow(win
, wksp
, True
);
757 } else if (wksp
== 0xfffffffe) { // XXX: BUG, BUT DOING THIS SO KDE WORKS FOR NOW!!
758 if (win
->isIconic()) win
->deiconify(False
, True
);
759 if (! win
->isStuck()) win
->stick();
760 if (! win
->isVisible()) win
->show();
763 } else if (e
->xclient
.message_type
==
764 xatom
->getAtom(XAtom::blackbox_change_attributes
)) {
765 // BLACKBOX_CHANGE_ATTRIBUTES
766 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
768 if (win
&& win
->validateClient()) {
770 net
.flags
= e
->xclient
.data
.l
[0];
771 net
.attrib
= e
->xclient
.data
.l
[1];
772 net
.workspace
= e
->xclient
.data
.l
[2];
773 net
.stack
= e
->xclient
.data
.l
[3];
774 net
.decoration
= e
->xclient
.data
.l
[4];
776 win
->changeBlackboxHints(&net
);
778 } else if (e
->xclient
.message_type
==
779 xatom
->getAtom(XAtom::net_number_of_desktops
)) {
780 // NET_NUMBER_OF_DESKTOPS
781 BScreen
*screen
= searchScreen(e
->xclient
.window
);
783 if (e
->xclient
.data
.l
[0] > 0) {
784 if ((unsigned) e
->xclient
.data
.l
[0] < screen
->getWorkspaceCount()) {
786 for (int i
= screen
->getWorkspaceCount();
787 i
> e
->xclient
.data
.l
[0]; --i
)
788 screen
->removeLastWorkspace();
789 // removeLast already sets the current workspace to the
790 // last available one.
791 } else if ((unsigned) e
->xclient
.data
.l
[0] >
792 screen
->getWorkspaceCount()) {
794 for(int i
= screen
->getWorkspaceCount();
795 i
< e
->xclient
.data
.l
[0]; ++i
)
796 screen
->addWorkspace();
799 } else if (e
->xclient
.message_type
==
800 xatom
->getAtom(XAtom::net_close_window
)) {
802 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
803 if (win
&& win
->validateClient())
804 win
->close(); // could this be smarter?
805 } else if (e
->xclient
.message_type
==
806 xatom
->getAtom(XAtom::net_wm_moveresize
)) {
808 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
809 if (win
&& win
->validateClient()) {
810 int x_root
= e
->xclient
.data
.l
[0],
811 y_root
= e
->xclient
.data
.l
[1];
812 if ((Atom
) e
->xclient
.data
.l
[2] ==
813 xatom
->getAtom(XAtom::net_wm_moveresize_move
)) {
814 win
->beginMove(x_root
, y_root
);
816 if ((Atom
) e
->xclient
.data
.l
[2] ==
817 xatom
->getAtom(XAtom::net_wm_moveresize_size_topleft
))
818 win
->beginResize(x_root
, y_root
, BlackboxWindow::TopLeft
);
819 else if ((Atom
) e
->xclient
.data
.l
[2] ==
820 xatom
->getAtom(XAtom::net_wm_moveresize_size_topright
))
821 win
->beginResize(x_root
, y_root
, BlackboxWindow::TopRight
);
822 else if ((Atom
) e
->xclient
.data
.l
[2] ==
823 xatom
->getAtom(XAtom::net_wm_moveresize_size_bottomleft
))
824 win
->beginResize(x_root
, y_root
, BlackboxWindow::BottomLeft
);
825 else if ((Atom
) e
->xclient
.data
.l
[2] ==
826 xatom
->getAtom(XAtom::net_wm_moveresize_size_bottomright
))
827 win
->beginResize(x_root
, y_root
, BlackboxWindow::BottomRight
);
830 } else if (e
->xclient
.message_type
==
831 xatom
->getAtom(XAtom::net_wm_state
)) {
833 BlackboxWindow
*win
= searchWindow(e
->xclient
.window
);
834 if (win
&& win
->validateClient()) {
835 const Atom action
= (Atom
) e
->xclient
.data
.l
[0];
836 const Atom state
[] = { (Atom
) e
->xclient
.data
.l
[1],
837 (Atom
) e
->xclient
.data
.l
[2] };
839 for (int i
= 0; i
< 2; ++i
) {
843 if ((Atom
) e
->xclient
.data
.l
[0] == 1) {
845 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
847 } else if (state
[i
] ==
848 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
849 if (win
->isMaximizedHoriz()) {
850 win
->maximize(0); // unmaximize
851 win
->maximize(1); // full
852 } else if (! win
->isMaximized()) {
853 win
->maximize(2); // vert
855 } else if (state
[i
] ==
856 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
857 if (win
->isMaximizedVert()) {
858 win
->maximize(0); // unmaximize
859 win
->maximize(1); // full
860 } else if (! win
->isMaximized()) {
861 win
->maximize(3); // horiz
863 } else if (state
[i
] ==
864 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
865 if (! win
->isShaded())
867 } else if (state
[i
] ==
868 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
869 win
->setSkipTaskbar(True
);
870 } else if (state
[i
] ==
871 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
872 win
->setSkipPager(True
);
873 } else if (state
[i
] ==
874 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
875 win
->setFullscreen(True
);
877 } else if (action
== 0) {
879 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
880 win
->setModal(False
);
881 } else if (state
[i
] ==
882 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
883 if (win
->isMaximizedFull()) {
884 win
->maximize(0); // unmaximize
885 win
->maximize(3); // horiz
886 } else if (win
->isMaximizedVert()) {
887 win
->maximize(0); // unmaximize
889 } else if (state
[i
] ==
890 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
891 if (win
->isMaximizedFull()) {
892 win
->maximize(0); // unmaximize
893 win
->maximize(2); // vert
894 } else if (win
->isMaximizedHoriz()) {
895 win
->maximize(0); // unmaximize
897 } else if (state
[i
] ==
898 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
901 } else if (state
[i
] ==
902 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
903 win
->setSkipTaskbar(False
);
904 } else if (state
[i
] ==
905 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
906 win
->setSkipPager(False
);
907 } else if (state
[i
] ==
908 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
909 win
->setFullscreen(False
);
911 } else if (action
== 2) {
913 if (state
[i
] == xatom
->getAtom(XAtom::net_wm_state_modal
)) {
914 win
->setModal(! win
->isModal());
915 } else if (state
[i
] ==
916 xatom
->getAtom(XAtom::net_wm_state_maximized_vert
)) {
917 if (win
->isMaximizedFull()) {
918 win
->maximize(0); // unmaximize
919 win
->maximize(3); // horiz
920 } else if (win
->isMaximizedVert()) {
921 win
->maximize(0); // unmaximize
922 } else if (win
->isMaximizedHoriz()) {
923 win
->maximize(0); // unmaximize
924 win
->maximize(1); // full
926 win
->maximize(2); // vert
928 } else if (state
[i
] ==
929 xatom
->getAtom(XAtom::net_wm_state_maximized_horz
)) {
930 if (win
->isMaximizedFull()) {
931 win
->maximize(0); // unmaximize
932 win
->maximize(2); // vert
933 } else if (win
->isMaximizedHoriz()) {
934 win
->maximize(0); // unmaximize
935 } else if (win
->isMaximizedVert()) {
936 win
->maximize(0); // unmaximize
937 win
->maximize(1); // full
939 win
->maximize(3); // horiz
941 } else if (state
[i
] ==
942 xatom
->getAtom(XAtom::net_wm_state_shaded
)) {
944 } else if (state
[i
] ==
945 xatom
->getAtom(XAtom::net_wm_state_skip_taskbar
)) {
946 win
->setSkipTaskbar(! win
->skipTaskbar());
947 } else if (state
[i
] ==
948 xatom
->getAtom(XAtom::net_wm_state_skip_pager
)) {
949 win
->setSkipPager(! win
->skipPager());
950 } else if (state
[i
] ==
951 xatom
->getAtom(XAtom::net_wm_state_fullscreen
)) {
952 win
->setFullscreen(! win
->isFullscreen());
964 case ConfigureNotify
:
966 break; // not handled, just ignore
970 if (e
->type
== getShapeEventBase()) {
971 XShapeEvent
*shape_event
= (XShapeEvent
*) e
;
972 BlackboxWindow
*win
= searchWindow(e
->xany
.window
);
975 win
->shapeEvent(shape_event
);
983 bool Blackbox::handleSignal(int sig
) {
1012 bool Blackbox::validateWindow(Window window
) {
1014 if (XCheckTypedWindowEvent(getXDisplay(), window
, DestroyNotify
, &event
)) {
1015 XPutBackEvent(getXDisplay(), &event
);
1024 BScreen
*Blackbox::searchScreen(Window window
) {
1025 ScreenList::iterator it
= screenList
.begin();
1027 for (; it
!= screenList
.end(); ++it
) {
1029 if (s
->getRootWindow() == window
)
1033 return (BScreen
*) 0;
1037 BScreen
*Blackbox::searchDesktopWindow(Window window
) {
1038 WindowScreenLookup::iterator it
= desktopSearchList
.find(window
);
1039 if (it
!= desktopSearchList
.end())
1042 return (BScreen
*) 0;
1046 BScreen
*Blackbox::searchSystrayWindow(Window window
) {
1047 WindowScreenLookup::iterator it
= systraySearchList
.find(window
);
1048 if (it
!= systraySearchList
.end())
1051 return (BScreen
*) 0;
1055 BlackboxWindow
*Blackbox::searchWindow(Window window
) {
1056 WindowLookup::iterator it
= windowSearchList
.find(window
);
1057 if (it
!= windowSearchList
.end())
1060 return (BlackboxWindow
*) 0;
1064 BWindowGroup
*Blackbox::searchGroup(Window window
) {
1065 GroupLookup::iterator it
= groupSearchList
.find(window
);
1066 if (it
!= groupSearchList
.end())
1069 return (BWindowGroup
*) 0;
1073 Basemenu
*Blackbox::searchMenu(Window window
) {
1074 MenuLookup::iterator it
= menuSearchList
.find(window
);
1075 if (it
!= menuSearchList
.end())
1078 return (Basemenu
*) 0;
1082 Toolbar
*Blackbox::searchToolbar(Window window
) {
1083 ToolbarLookup::iterator it
= toolbarSearchList
.find(window
);
1084 if (it
!= toolbarSearchList
.end())
1087 return (Toolbar
*) 0;
1091 Slit
*Blackbox::searchSlit(Window window
) {
1092 SlitLookup::iterator it
= slitSearchList
.find(window
);
1093 if (it
!= slitSearchList
.end())
1100 void Blackbox::saveDesktopWindowSearch(Window window
, BScreen
*screen
) {
1101 desktopSearchList
.insert(WindowScreenLookupPair(window
, screen
));
1105 void Blackbox::saveSystrayWindowSearch(Window window
, BScreen
*screen
) {
1106 systraySearchList
.insert(WindowScreenLookupPair(window
, screen
));
1110 void Blackbox::saveWindowSearch(Window window
, BlackboxWindow
*data
) {
1111 windowSearchList
.insert(WindowLookupPair(window
, data
));
1115 void Blackbox::saveGroupSearch(Window window
, BWindowGroup
*data
) {
1116 groupSearchList
.insert(GroupLookupPair(window
, data
));
1120 void Blackbox::saveMenuSearch(Window window
, Basemenu
*data
) {
1121 menuSearchList
.insert(MenuLookupPair(window
, data
));
1125 void Blackbox::saveToolbarSearch(Window window
, Toolbar
*data
) {
1126 toolbarSearchList
.insert(ToolbarLookupPair(window
, data
));
1130 void Blackbox::saveSlitSearch(Window window
, Slit
*data
) {
1131 slitSearchList
.insert(SlitLookupPair(window
, data
));
1135 void Blackbox::removeDesktopWindowSearch(Window window
) {
1136 desktopSearchList
.erase(window
);
1140 void Blackbox::removeSystrayWindowSearch(Window window
) {
1141 systraySearchList
.erase(window
);
1145 void Blackbox::removeWindowSearch(Window window
) {
1146 windowSearchList
.erase(window
);
1150 void Blackbox::removeGroupSearch(Window window
) {
1151 groupSearchList
.erase(window
);
1155 void Blackbox::removeMenuSearch(Window window
) {
1156 menuSearchList
.erase(window
);
1160 void Blackbox::removeToolbarSearch(Window window
) {
1161 toolbarSearchList
.erase(window
);
1165 void Blackbox::removeSlitSearch(Window window
) {
1166 slitSearchList
.erase(window
);
1170 void Blackbox::restart(const char *prog
) {
1174 putenv(const_cast<char *>(screenList
.front()->displayString().c_str()));
1175 execlp(prog
, prog
, NULL
);
1179 // fall back in case the above execlp doesn't work
1180 execvp(argv
[0], argv
);
1181 string name
= basename(argv
[0]);
1182 execvp(name
.c_str(), argv
);
1186 void Blackbox::shutdown(void) {
1187 BaseDisplay::shutdown();
1189 XSetInputFocus(getXDisplay(), PointerRoot
, None
, CurrentTime
);
1191 std::for_each(screenList
.begin(), screenList
.end(),
1192 std::mem_fun(&BScreen::shutdown
));
1194 XSync(getXDisplay(), False
);
1199 * Save all values as they are so that the defaults will be written to the rc
1202 void Blackbox::save_rc(void) {
1203 config
.setAutoSave(false);
1205 config
.setValue("session.colorsPerChannel", resource
.colors_per_channel
);
1206 config
.setValue("session.doubleClickInterval",
1207 resource
.double_click_interval
);
1208 config
.setValue("session.autoRaiseDelay",
1209 ((resource
.auto_raise_delay
.tv_sec
* 1000) +
1210 (resource
.auto_raise_delay
.tv_usec
/ 1000)));
1211 config
.setValue("session.cacheLife", resource
.cache_life
/ 60000);
1212 config
.setValue("session.cacheMax", resource
.cache_max
);
1213 config
.setValue("session.styleFile", resource
.style_file
);
1214 config
.setValue("session.titlebarLayout", resource
.titlebar_layout
);
1216 std::for_each(screenList
.begin(), screenList
.end(),
1217 std::mem_fun(&BScreen::save_rc
));
1219 config
.setAutoSave(true);
1224 void Blackbox::load_rc(void) {
1225 if (! config
.load())
1230 if (! config
.getValue("session.colorsPerChannel",
1231 resource
.colors_per_channel
))
1232 resource
.colors_per_channel
= 4;
1233 if (resource
.colors_per_channel
< 2) resource
.colors_per_channel
= 2;
1234 else if (resource
.colors_per_channel
> 6) resource
.colors_per_channel
= 6;
1236 if (config
.getValue("session.styleFile", s
))
1237 resource
.style_file
= expandTilde(s
);
1239 resource
.style_file
= DEFAULTSTYLE
;
1241 if (! config
.getValue("session.doubleClickInterval",
1242 resource
.double_click_interval
));
1243 resource
.double_click_interval
= 250;
1245 if (! config
.getValue("session.autoRaiseDelay",
1246 resource
.auto_raise_delay
.tv_usec
))
1247 resource
.auto_raise_delay
.tv_usec
= 400;
1248 resource
.auto_raise_delay
.tv_sec
= resource
.auto_raise_delay
.tv_usec
/ 1000;
1249 resource
.auto_raise_delay
.tv_usec
-=
1250 (resource
.auto_raise_delay
.tv_sec
* 1000);
1251 resource
.auto_raise_delay
.tv_usec
*= 1000;
1253 if (! config
.getValue("session.cacheLife", resource
.cache_life
))
1254 resource
.cache_life
= 5;
1255 resource
.cache_life
*= 60000;
1257 if (! config
.getValue("session.cacheMax", resource
.cache_max
))
1258 resource
.cache_max
= 200;
1260 if (! config
.getValue("session.titlebarLayout", resource
.titlebar_layout
))
1261 resource
.titlebar_layout
= "ILMC";
1265 void Blackbox::reconfigure(void) {
1266 reconfigure_wait
= True
;
1268 if (! timer
->isTiming()) timer
->start();
1272 void Blackbox::real_reconfigure(void) {
1275 std::for_each(menuTimestamps
.begin(), menuTimestamps
.end(),
1277 menuTimestamps
.clear();
1281 std::for_each(screenList
.begin(), screenList
.end(),
1282 std::mem_fun(&BScreen::reconfigure
));
1286 void Blackbox::checkMenu(void) {
1287 bool reread
= False
;
1288 MenuTimestampList::iterator it
= menuTimestamps
.begin();
1289 for(; it
!= menuTimestamps
.end(); ++it
) {
1290 MenuTimestamp
*tmp
= *it
;
1293 if (! stat(tmp
->filename
.c_str(), &buf
)) {
1294 if (tmp
->timestamp
!= buf
.st_ctime
)
1301 if (reread
) rereadMenu();
1305 void Blackbox::rereadMenu(void) {
1306 reread_menu_wait
= True
;
1308 if (! timer
->isTiming()) timer
->start();
1312 void Blackbox::real_rereadMenu(void) {
1313 std::for_each(menuTimestamps
.begin(), menuTimestamps
.end(),
1315 menuTimestamps
.clear();
1317 std::for_each(screenList
.begin(), screenList
.end(),
1318 std::mem_fun(&BScreen::rereadMenu
));
1322 void Blackbox::saveStyleFilename(const string
& filename
) {
1323 assert(! filename
.empty());
1324 resource
.style_file
= filename
;
1325 config
.setValue("session.styleFile", resource
.style_file
);
1329 void Blackbox::addMenuTimestamp(const string
& filename
) {
1330 assert(! filename
.empty());
1333 MenuTimestampList::iterator it
= menuTimestamps
.begin();
1334 for (; it
!= menuTimestamps
.end() && ! found
; ++it
) {
1335 if ((*it
)->filename
== filename
) found
= True
;
1340 if (! stat(filename
.c_str(), &buf
)) {
1341 MenuTimestamp
*ts
= new MenuTimestamp
;
1343 ts
->filename
= filename
;
1344 ts
->timestamp
= buf
.st_ctime
;
1346 menuTimestamps
.push_back(ts
);
1352 void Blackbox::timeout(void) {
1353 if (reconfigure_wait
)
1356 if (reread_menu_wait
)
1359 reconfigure_wait
= reread_menu_wait
= False
;
1363 void Blackbox::setChangingWindow(BlackboxWindow
*win
) {
1364 // make sure one of the two is null and the other isn't
1365 assert((! changing_window
&& win
) || (! win
&& changing_window
));
1366 changing_window
= win
;
1370 void Blackbox::setFocusedWindow(BlackboxWindow
*win
) {
1371 if (focused_window
&& focused_window
== win
) // nothing to do
1374 BScreen
*old_screen
= 0;
1376 if (focused_window
) {
1377 focused_window
->setFocusFlag(False
);
1378 old_screen
= focused_window
->getScreen();
1381 if (win
&& ! win
->isIconic()) {
1382 // the active screen is the one with the last focused window...
1383 // this will keep focus on this screen no matter where the mouse goes,
1384 // so multihead keybindings will continue to work on that screen until the
1385 // user focuses a window on a different screen.
1386 active_screen
= win
->getScreen();
1387 focused_window
= win
;
1391 if (active_screen
) {
1392 // set input focus to the toolbar of the screen with mouse
1393 XSetInputFocus(getXDisplay(),
1394 active_screen
->getRootWindow(),
1395 RevertToPointerRoot
, CurrentTime
);
1397 // set input focus to the toolbar of the first managed screen
1398 XSetInputFocus(getXDisplay(),
1399 screenList
.front()->getRootWindow(),
1400 RevertToPointerRoot
, CurrentTime
);
1403 // set input focus to the toolbar of the last screen
1404 XSetInputFocus(getXDisplay(), old_screen
->getRootWindow(),
1405 RevertToPointerRoot
, CurrentTime
);
1409 if (active_screen
&& active_screen
->isScreenManaged()) {
1410 active_screen
->getToolbar()->redrawWindowLabel(True
);
1411 active_screen
->updateNetizenWindowFocus();
1414 if (old_screen
&& old_screen
!= active_screen
) {
1415 old_screen
->getToolbar()->redrawWindowLabel(True
);
1416 old_screen
->updateNetizenWindowFocus();