2 * Window Maker window manager
4 * Copyright (c) 1997-2003 Alfredo K. Kojima
5 * Copyright (c) 1998-2003 Dan Pascu
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
33 #include <sys/signal.h>
37 #include <X11/Xresource.h>
38 #include <X11/Xutil.h>
39 #include <X11/cursorfont.h>
40 #include <X11/Xproto.h>
41 #include <X11/keysym.h>
43 #include <X11/extensions/shape.h>
46 #include "WindowMaker.h"
55 #include "workspace.h"
60 #include "properties.h"
70 #ifdef SYS_SIGLIST_DECLARED
71 extern const char *const sys_siglist
[];
80 /* Just in case, for weirdo systems */
85 /****** Global Variables ******/
87 extern WPreferences wPreferences
;
89 extern WDDomain
*WDWindowMaker
;
90 extern WDDomain
*WDRootMenu
;
91 extern WDDomain
*WDWindowAttributes
;
93 extern WShortKey wKeyBindings
[WKBD_LAST
];
95 extern int wScreenCount
;
98 extern Bool wShapeSupported
;
99 extern int wShapeEventBase
;
102 #ifdef KEEP_XKB_LOCK_STATUS
103 extern Bool wXkbSupported
;
104 extern int wXkbEventBase
;
108 extern XContext wWinContext
;
109 extern XContext wAppWinContext
;
110 extern XContext wStackContext
;
111 extern XContext wVEdgeContext
;
114 extern Atom _XA_WM_STATE
;
115 extern Atom _XA_WM_CHANGE_STATE
;
116 extern Atom _XA_WM_PROTOCOLS
;
117 extern Atom _XA_WM_TAKE_FOCUS
;
118 extern Atom _XA_WM_DELETE_WINDOW
;
119 extern Atom _XA_WM_SAVE_YOURSELF
;
120 extern Atom _XA_WM_CLIENT_LEADER
;
121 extern Atom _XA_WM_COLORMAP_WINDOWS
;
122 extern Atom _XA_WM_COLORMAP_NOTIFY
;
124 extern Atom _XA_GNUSTEP_WM_ATTR
;
126 extern Atom _XA_WINDOWMAKER_MENU
;
127 extern Atom _XA_WINDOWMAKER_WM_PROTOCOLS
;
128 extern Atom _XA_WINDOWMAKER_STATE
;
129 extern Atom _XA_WINDOWMAKER_WM_FUNCTION
;
130 extern Atom _XA_WINDOWMAKER_NOTICEBOARD
;
131 extern Atom _XA_WINDOWMAKER_COMMAND
;
132 extern Atom _XA_WINDOWMAKER_ICON_SIZE
;
133 extern Atom _XA_WINDOWMAKER_ICON_TILE
;
135 extern Atom _XA_GNUSTEP_WM_MINIATURIZE_WINDOW
;
136 extern Atom _XA_GNUSTEP_TITLEBAR_STATE
;
139 extern Cursor wCursor
[WCUR_LAST
];
142 /*extern char WDelayedActionSet;*/
146 static WScreen
**wScreen
= NULL
;
148 static unsigned int _NumLockMask
= 0;
149 static unsigned int _ScrollLockMask
= 0;
151 static void manageAllWindows(WScreen
* scr
, int crashed
);
153 extern void NotifyDeadProcess(pid_t pid
, unsigned char status
);
155 static int catchXError(Display
* dpy
, XErrorEvent
* error
)
157 char buffer
[MAXLINE
];
159 /* ignore some errors */
160 if (error
->resourceid
!= None
161 && ((error
->error_code
== BadDrawable
&& error
->request_code
== X_GetGeometry
)
162 || (error
->error_code
== BadMatch
&& (error
->request_code
== X_SetInputFocus
))
163 || (error
->error_code
== BadWindow
)
165 && (error->request_code == X_GetWindowAttributes
166 || error->request_code == X_SetInputFocus
167 || error->request_code == X_ChangeWindowAttributes
168 || error->request_code == X_GetProperty
169 || error->request_code == X_ChangeProperty
170 || error->request_code == X_QueryTree
171 || error->request_code == X_GrabButton
172 || error->request_code == X_UngrabButton
173 || error->request_code == X_SendEvent
174 || error->request_code == X_ConfigureWindow))
176 || (error
->request_code
== X_InstallColormap
))) {
181 printf("got X error %x %x %x\n", error
->request_code
,
182 error
->error_code
, (unsigned)error
->resourceid
);
186 FormatXError(dpy
, error
, buffer
, MAXLINE
);
187 wwarning(_("internal X error: %s\n"), buffer
);
192 *----------------------------------------------------------------------
194 * Handle X shutdowns and other stuff.
195 *----------------------------------------------------------------------
197 static int handleXIO(Display
* xio_dpy
)
205 *----------------------------------------------------------------------
207 * Action to be executed after the signal() handler is exited.
208 * This was called every 500ms to 'clean up' signals. Not used now.
209 *----------------------------------------------------------------------
212 static void delayedAction(void *cdata
)
214 if (WDelayedActionSet
== 0) {
219 * Make the event dispatcher do whatever it needs to do,
220 * including handling zombie processes, restart and exit
228 *----------------------------------------------------------------------
230 * User generated exit signal handler.
231 *----------------------------------------------------------------------
233 static RETSIGTYPE
handleExitSig(int sig
)
238 sigprocmask(SIG_BLOCK
, &sigs
, NULL
);
240 if (sig
== SIGUSR1
) {
241 #ifdef SYS_SIGLIST_DECLARED
242 wwarning("got signal %i (%s) - restarting\n", sig
, sys_siglist
[sig
]);
244 wwarning("got signal %i - restarting\n", sig
);
247 SIG_WCHANGE_STATE(WSTATE_NEED_RESTART
);
249 } else if (sig
== SIGUSR2
) {
250 #ifdef SYS_SIGLIST_DECLARED
251 wwarning("got signal %i (%s) - rereading defaults\n", sig
, sys_siglist
[sig
]);
253 wwarning("got signal %i - rereading defaults\n", sig
);
256 SIG_WCHANGE_STATE(WSTATE_NEED_REREAD
);
258 } else if (sig
== SIGTERM
|| sig
== SIGINT
|| sig
== SIGHUP
) {
259 #ifdef SYS_SIGLIST_DECLARED
260 wwarning("got signal %i (%s) - exiting...\n", sig
, sys_siglist
[sig
]);
262 wwarning("got signal %i - exiting...\n", sig
);
265 SIG_WCHANGE_STATE(WSTATE_NEED_EXIT
);
269 sigprocmask(SIG_UNBLOCK
, &sigs
, NULL
);
270 DispatchEvent(NULL
); /* Dispatch events imediately. */
273 /* Dummy signal handler */
274 static void dummyHandler(int sig
)
279 *----------------------------------------------------------------------
281 * general signal handler. Exits the program gently.
282 *----------------------------------------------------------------------
284 static RETSIGTYPE
handleSig(int sig
)
286 #ifdef SYS_SIGLIST_DECLARED
287 wfatal("got signal %i (%s)\n", sig
, sys_siglist
[sig
]);
289 wfatal("got signal %i\n", sig
);
292 /* Setting the signal behaviour back to default and then reraising the
293 * signal is a cleaner way to make program exit and core dump than calling
294 * abort(), since it correctly returns from the signal handler and sets
295 * the flags accordingly. -Dan
297 if (sig
== SIGSEGV
|| sig
== SIGFPE
|| sig
== SIGBUS
|| sig
== SIGILL
|| sig
== SIGABRT
) {
298 signal(sig
, SIG_DFL
);
306 static RETSIGTYPE
buryChild(int foo
)
310 int save_errno
= errno
;
314 /* Block signals so that NotifyDeadProcess() doesn't get fux0red */
315 sigprocmask(SIG_BLOCK
, &sigs
, NULL
);
318 /* If 2 or more kids exit in a small time window, before this handler gets
319 * the chance to get invoked, the SIGCHLD signals will be merged and only
320 * one SIGCHLD signal will be sent to us. We use a while loop to get all
321 * exited child status because we can't count on the number of SIGCHLD
322 * signals to know exactly how many kids have exited. -Dan
324 while ((pid
= waitpid(-1, &status
, WNOHANG
)) > 0 || (pid
< 0 && errno
== EINTR
)) {
325 NotifyDeadProcess(pid
, WEXITSTATUS(status
));
328 sigprocmask(SIG_UNBLOCK
, &sigs
, NULL
);
333 static void getOffendingModifiers()
336 XModifierKeymap
*modmap
;
337 KeyCode nlock
, slock
;
338 static int mask_table
[8] = {
339 ShiftMask
, LockMask
, ControlMask
, Mod1Mask
,
340 Mod2Mask
, Mod3Mask
, Mod4Mask
, Mod5Mask
343 nlock
= XKeysymToKeycode(dpy
, XK_Num_Lock
);
344 slock
= XKeysymToKeycode(dpy
, XK_Scroll_Lock
);
347 * Find out the masks for the NumLock and ScrollLock modifiers,
348 * so that we can bind the grabs for when they are enabled too.
350 modmap
= XGetModifierMapping(dpy
);
352 if (modmap
!= NULL
&& modmap
->max_keypermod
> 0) {
353 for (i
= 0; i
< 8 * modmap
->max_keypermod
; i
++) {
354 if (modmap
->modifiermap
[i
] == nlock
&& nlock
!= 0)
355 _NumLockMask
= mask_table
[i
/ modmap
->max_keypermod
];
356 else if (modmap
->modifiermap
[i
] == slock
&& slock
!= 0)
357 _ScrollLockMask
= mask_table
[i
/ modmap
->max_keypermod
];
362 XFreeModifiermap(modmap
);
367 wHackedGrabKey(int keycode
, unsigned int modifiers
,
368 Window grab_window
, Bool owner_events
, int pointer_mode
, int keyboard_mode
)
370 if (modifiers
== AnyModifier
)
373 /* grab all combinations of the modifier with CapsLock, NumLock and
374 * ScrollLock. How much memory/CPU does such a monstrosity consume
378 XGrabKey(dpy
, keycode
, modifiers
| _NumLockMask
,
379 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
381 XGrabKey(dpy
, keycode
, modifiers
| _ScrollLockMask
,
382 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
383 if (_NumLockMask
&& _ScrollLockMask
)
384 XGrabKey(dpy
, keycode
, modifiers
| _NumLockMask
| _ScrollLockMask
,
385 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
387 XGrabKey(dpy
, keycode
, modifiers
| _NumLockMask
| LockMask
,
388 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
390 XGrabKey(dpy
, keycode
, modifiers
| _ScrollLockMask
| LockMask
,
391 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
392 if (_NumLockMask
&& _ScrollLockMask
)
393 XGrabKey(dpy
, keycode
, modifiers
| _NumLockMask
| _ScrollLockMask
| LockMask
,
394 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
395 /* phew, I guess that's all, right? */
400 wHackedGrabButton(unsigned int button
, unsigned int modifiers
,
401 Window grab_window
, Bool owner_events
,
402 unsigned int event_mask
, int pointer_mode
, int keyboard_mode
, Window confine_to
, Cursor cursor
)
404 XGrabButton(dpy
, button
, modifiers
, grab_window
, owner_events
,
405 event_mask
, pointer_mode
, keyboard_mode
, confine_to
, cursor
);
407 if (modifiers
== AnyModifier
)
410 XGrabButton(dpy
, button
, modifiers
| LockMask
, grab_window
, owner_events
,
411 event_mask
, pointer_mode
, keyboard_mode
, confine_to
, cursor
);
414 /* same as above, but for mouse buttons */
416 XGrabButton(dpy
, button
, modifiers
| _NumLockMask
,
417 grab_window
, owner_events
, event_mask
, pointer_mode
,
418 keyboard_mode
, confine_to
, cursor
);
420 XGrabButton(dpy
, button
, modifiers
| _ScrollLockMask
,
421 grab_window
, owner_events
, event_mask
, pointer_mode
,
422 keyboard_mode
, confine_to
, cursor
);
423 if (_NumLockMask
&& _ScrollLockMask
)
424 XGrabButton(dpy
, button
, modifiers
| _ScrollLockMask
| _NumLockMask
,
425 grab_window
, owner_events
, event_mask
, pointer_mode
,
426 keyboard_mode
, confine_to
, cursor
);
428 XGrabButton(dpy
, button
, modifiers
| _NumLockMask
| LockMask
,
429 grab_window
, owner_events
, event_mask
, pointer_mode
,
430 keyboard_mode
, confine_to
, cursor
);
432 XGrabButton(dpy
, button
, modifiers
| _ScrollLockMask
| LockMask
,
433 grab_window
, owner_events
, event_mask
, pointer_mode
,
434 keyboard_mode
, confine_to
, cursor
);
435 if (_NumLockMask
&& _ScrollLockMask
)
436 XGrabButton(dpy
, button
, modifiers
| _ScrollLockMask
| _NumLockMask
| LockMask
,
437 grab_window
, owner_events
, event_mask
, pointer_mode
,
438 keyboard_mode
, confine_to
, cursor
);
439 #endif /* NUMLOCK_HACK */
443 void wHackedUngrabButton(unsigned int button
, unsigned int modifiers
, Window grab_window
)
445 XUngrabButton(dpy
, button
, modifiers
| _NumLockMask
, grab_window
);
446 XUngrabButton(dpy
, button
, modifiers
| _ScrollLockMask
, grab_window
);
447 XUngrabButton(dpy
, button
, modifiers
| _NumLockMask
| _ScrollLockMask
, grab_window
);
448 XUngrabButton(dpy
, button
, modifiers
| _NumLockMask
| LockMask
, grab_window
);
449 XUngrabButton(dpy
, button
, modifiers
| _ScrollLockMask
| LockMask
, grab_window
);
450 XUngrabButton(dpy
, button
, modifiers
| _NumLockMask
| _ScrollLockMask
| LockMask
, grab_window
);
454 WScreen
*wScreenWithNumber(int i
)
456 assert(i
< wScreenCount
);
461 WScreen
*wScreenForRootWindow(Window window
)
465 if (wScreenCount
== 1)
469 * Since the number of heads will probably be small (normally 2),
470 * it should be faster to use this than a hash table, because
473 for (i
= 0; i
< wScreenCount
; i
++) {
474 if (wScreen
[i
]->root_win
== window
) {
479 return wScreenForWindow(window
);
482 WScreen
*wScreenSearchForRootWindow(Window window
)
486 if (wScreenCount
== 1)
490 * Since the number of heads will probably be small (normally 2),
491 * it should be faster to use this than a hash table, because
494 for (i
= 0; i
< wScreenCount
; i
++) {
495 if (wScreen
[i
]->root_win
== window
) {
500 return wScreenForWindow(window
);
503 WScreen
*wScreenForWindow(Window window
)
505 XWindowAttributes attr
;
507 if (wScreenCount
== 1)
510 if (XGetWindowAttributes(dpy
, window
, &attr
)) {
511 return wScreenForRootWindow(attr
.root
);
516 static char *atomNames
[] = {
524 "WM_COLORMAP_WINDOWS",
525 "WM_COLORMAP_NOTIFY",
528 "_WINDOWMAKER_STATE",
529 "_WINDOWMAKER_WM_PROTOCOLS",
530 "_WINDOWMAKER_WM_FUNCTION",
531 "_WINDOWMAKER_NOTICEBOARD",
532 "_WINDOWMAKER_COMMAND",
533 "_WINDOWMAKER_ICON_SIZE",
534 "_WINDOWMAKER_ICON_TILE",
536 GNUSTEP_WM_ATTR_NAME
,
537 GNUSTEP_WM_MINIATURIZE_WINDOW
,
538 GNUSTEP_TITLEBAR_STATE
542 *----------------------------------------------------------
544 * starts the window manager and setup global data.
545 * Called from main() at startup.
548 * global data declared in main.c is initialized
549 *----------------------------------------------------------
551 void StartUp(Bool defaultScreenOnly
)
553 struct sigaction sig_action
;
555 Atom atom
[sizeof(atomNames
) / sizeof(char *)];
558 * Ignore CapsLock in modifiers
560 ValidModMask
= 0xff & ~LockMask
;
562 getOffendingModifiers();
564 * Ignore NumLock and ScrollLock too
566 ValidModMask
&= ~(_NumLockMask
| _ScrollLockMask
);
568 memset(&wKeyBindings
, 0, sizeof(wKeyBindings
));
570 wWinContext
= XUniqueContext();
571 wAppWinContext
= XUniqueContext();
572 wStackContext
= XUniqueContext();
573 wVEdgeContext
= XUniqueContext();
575 /* _XA_VERSION = XInternAtom(dpy, "VERSION", False); */
577 #ifdef HAVE_XINTERNATOMS
578 XInternAtoms(dpy
, atomNames
, sizeof(atomNames
) / sizeof(char *), False
, atom
);
583 for (i
= 0; i
< sizeof(atomNames
) / sizeof(char *); i
++) {
584 atom
[i
] = XInternAtom(dpy
, atomNames
[i
], False
);
589 _XA_WM_STATE
= atom
[0];
590 _XA_WM_CHANGE_STATE
= atom
[1];
591 _XA_WM_PROTOCOLS
= atom
[2];
592 _XA_WM_TAKE_FOCUS
= atom
[3];
593 _XA_WM_DELETE_WINDOW
= atom
[4];
594 _XA_WM_SAVE_YOURSELF
= atom
[5];
595 _XA_WM_CLIENT_LEADER
= atom
[6];
596 _XA_WM_COLORMAP_WINDOWS
= atom
[7];
597 _XA_WM_COLORMAP_NOTIFY
= atom
[8];
599 _XA_WINDOWMAKER_MENU
= atom
[9];
600 _XA_WINDOWMAKER_STATE
= atom
[10];
601 _XA_WINDOWMAKER_WM_PROTOCOLS
= atom
[11];
602 _XA_WINDOWMAKER_WM_FUNCTION
= atom
[12];
603 _XA_WINDOWMAKER_NOTICEBOARD
= atom
[13];
604 _XA_WINDOWMAKER_COMMAND
= atom
[14];
605 _XA_WINDOWMAKER_ICON_SIZE
= atom
[15];
606 _XA_WINDOWMAKER_ICON_TILE
= atom
[16];
608 _XA_GNUSTEP_WM_ATTR
= atom
[17];
609 _XA_GNUSTEP_WM_MINIATURIZE_WINDOW
= atom
[18];
610 _XA_GNUSTEP_TITLEBAR_STATE
= atom
[19];
613 wXDNDInitializeAtoms();
617 wCursor
[WCUR_NORMAL
] = None
; /* inherit from root */
618 wCursor
[WCUR_ROOT
] = XCreateFontCursor(dpy
, XC_left_ptr
);
619 wCursor
[WCUR_ARROW
] = XCreateFontCursor(dpy
, XC_top_left_arrow
);
620 wCursor
[WCUR_MOVE
] = XCreateFontCursor(dpy
, XC_fleur
);
621 wCursor
[WCUR_RESIZE
] = XCreateFontCursor(dpy
, XC_sizing
);
622 wCursor
[WCUR_TOPLEFTRESIZE
] = XCreateFontCursor(dpy
, XC_top_left_corner
);
623 wCursor
[WCUR_TOPRIGHTRESIZE
] = XCreateFontCursor(dpy
, XC_top_right_corner
);
624 wCursor
[WCUR_BOTTOMLEFTRESIZE
] = XCreateFontCursor(dpy
, XC_bottom_left_corner
);
625 wCursor
[WCUR_BOTTOMRIGHTRESIZE
] = XCreateFontCursor(dpy
, XC_bottom_right_corner
);
626 wCursor
[WCUR_VERTICALRESIZE
] = XCreateFontCursor(dpy
, XC_sb_v_double_arrow
);
627 wCursor
[WCUR_HORIZONRESIZE
] = XCreateFontCursor(dpy
, XC_sb_h_double_arrow
);
628 wCursor
[WCUR_WAIT
] = XCreateFontCursor(dpy
, XC_watch
);
629 wCursor
[WCUR_QUESTION
] = XCreateFontCursor(dpy
, XC_question_arrow
);
630 wCursor
[WCUR_TEXT
] = XCreateFontCursor(dpy
, XC_xterm
); /* odd name??? */
631 wCursor
[WCUR_SELECT
] = XCreateFontCursor(dpy
, XC_cross
);
633 Pixmap cur
= XCreatePixmap(dpy
, DefaultRootWindow(dpy
), 16, 16, 1);
634 GC gc
= XCreateGC(dpy
, cur
, 0, NULL
);
636 memset(&black
, 0, sizeof(XColor
));
637 XSetForeground(dpy
, gc
, 0);
638 XFillRectangle(dpy
, cur
, gc
, 0, 0, 16, 16);
640 wCursor
[WCUR_EMPTY
] = XCreatePixmapCursor(dpy
, cur
, cur
, &black
, &black
, 0, 0);
641 XFreePixmap(dpy
, cur
);
644 /* emergency exit... */
645 sig_action
.sa_handler
= handleSig
;
646 sigemptyset(&sig_action
.sa_mask
);
648 sig_action
.sa_flags
= SA_RESTART
;
649 sigaction(SIGQUIT
, &sig_action
, NULL
);
650 /* instead of catching these, we let the default handler abort the
651 * program. The new monitor process will take appropriate action
652 * when it detects the crash.
653 sigaction(SIGSEGV, &sig_action, NULL);
654 sigaction(SIGBUS, &sig_action, NULL);
655 sigaction(SIGFPE, &sig_action, NULL);
656 sigaction(SIGABRT, &sig_action, NULL);
659 sig_action
.sa_handler
= handleExitSig
;
661 /* Here we set SA_RESTART for safety, because SIGUSR1 may not be handled
662 * immediately. -Dan */
663 sig_action
.sa_flags
= SA_RESTART
;
664 sigaction(SIGTERM
, &sig_action
, NULL
);
665 sigaction(SIGINT
, &sig_action
, NULL
);
666 sigaction(SIGHUP
, &sig_action
, NULL
);
667 sigaction(SIGUSR1
, &sig_action
, NULL
);
668 sigaction(SIGUSR2
, &sig_action
, NULL
);
670 /* ignore dead pipe */
671 /* Because POSIX mandates that only signal with handlers are reset
672 * accross an exec*(), we do not want to propagate ignoring SIGPIPEs
673 * to children. Hence the dummy handler.
674 * Philippe Troin <phil@fifi.org>
676 sig_action
.sa_handler
= &dummyHandler
;
677 sig_action
.sa_flags
= SA_RESTART
;
678 sigaction(SIGPIPE
, &sig_action
, NULL
);
680 /* handle dead children */
681 sig_action
.sa_handler
= buryChild
;
682 sig_action
.sa_flags
= SA_NOCLDSTOP
| SA_RESTART
;
683 sigaction(SIGCHLD
, &sig_action
, NULL
);
685 /* Now we unblock all signals, that may have been blocked by the parent
686 * who exec()-ed us. This can happen for example if Window Maker crashes
687 * and restarts itself or another window manager from the signal handler.
688 * In this case, the new proccess inherits the blocked signal mask and
689 * will no longer react to that signal, until unblocked.
690 * This is because the signal handler of the proccess who crashed (parent)
691 * didn't return, and the signal remained blocked. -Dan
693 sigfillset(&sig_action
.sa_mask
);
694 sigprocmask(SIG_UNBLOCK
, &sig_action
.sa_mask
, NULL
);
696 /* handle X shutdowns a such */
697 XSetIOErrorHandler(handleXIO
);
699 /* set hook for out event dispatcher in WINGs event dispatcher */
700 WMHookEventHandler(DispatchEvent
);
702 /* initialize defaults stuff */
703 WDWindowMaker
= wDefaultsInitDomain("WindowMaker", True
);
704 if (!WDWindowMaker
->dictionary
) {
705 wwarning(_("could not read domain \"%s\" from defaults database"), "WindowMaker");
708 /* read defaults that don't change until a restart and are
709 * screen independent */
710 wReadStaticDefaults(WDWindowMaker
? WDWindowMaker
->dictionary
: NULL
);
712 /* check sanity of some values */
713 if (wPreferences
.icon_size
< 16) {
714 wwarning(_("icon size is configured to %i, but it's too small. Using 16, instead\n"),
715 wPreferences
.icon_size
);
716 wPreferences
.icon_size
= 16;
719 /* init other domains */
720 WDRootMenu
= wDefaultsInitDomain("WMRootMenu", False
);
721 if (!WDRootMenu
->dictionary
) {
722 wwarning(_("could not read domain \"%s\" from defaults database"), "WMRootMenu");
724 wDefaultsMergeGlobalMenus(WDRootMenu
);
726 WDWindowAttributes
= wDefaultsInitDomain("WMWindowAttributes", True
);
727 if (!WDWindowAttributes
->dictionary
) {
728 wwarning(_("could not read domain \"%s\" from defaults database"), "WMWindowAttributes");
731 XSetErrorHandler((XErrorHandler
) catchXError
);
735 wShapeSupported
= XShapeQueryExtension(dpy
, &wShapeEventBase
, &j
);
738 #ifdef KEEP_XKB_LOCK_STATUS
739 wXkbSupported
= XkbQueryExtension(dpy
, NULL
, &wXkbEventBase
, NULL
, NULL
, NULL
);
740 if (wPreferences
.modelock
&& !wXkbSupported
) {
741 wwarning(_("XKB is not supported. KbdModeLock is automatically disabled."));
742 wPreferences
.modelock
= 0;
746 if (defaultScreenOnly
) {
749 max
= ScreenCount(dpy
);
751 wScreen
= wmalloc(sizeof(WScreen
*) * max
);
755 /* manage the screens */
756 for (j
= 0; j
< max
; j
++) {
757 if (defaultScreenOnly
|| max
== 1) {
758 wScreen
[wScreenCount
] = wScreenInit(DefaultScreen(dpy
));
759 if (!wScreen
[wScreenCount
]) {
760 wfatal(_("it seems that there is already a window manager running"));
764 wScreen
[wScreenCount
] = wScreenInit(j
);
765 if (!wScreen
[wScreenCount
]) {
766 wwarning(_("could not manage screen %i"), j
);
774 InitializeSwitchMenu();
777 /* initialize/restore state for the screens */
778 for (j
= 0; j
< wScreenCount
; j
++) {
781 lastDesktop
= wNETWMGetCurrentDesktopFromHint(wScreen
[j
]);
783 wScreenRestoreState(wScreen
[j
]);
785 /* manage all windows that were already here before us */
786 if (!wPreferences
.flags
.nodock
&& wScreen
[j
]->dock
)
787 wScreen
[j
]->last_dock
= wScreen
[j
]->dock
;
789 manageAllWindows(wScreen
[j
], wPreferences
.flags
.restarting
== 2);
791 /* restore saved menus */
792 wMenuRestoreState(wScreen
[j
]);
794 /* If we're not restarting, restore session */
795 if (wPreferences
.flags
.restarting
== 0 && !wPreferences
.flags
.norestore
)
796 wSessionRestoreState(wScreen
[j
]);
798 if (!wPreferences
.flags
.noautolaunch
) {
799 /* auto-launch apps */
800 if (!wPreferences
.flags
.nodock
&& wScreen
[j
]->dock
) {
801 wScreen
[j
]->last_dock
= wScreen
[j
]->dock
;
802 wDockDoAutoLaunch(wScreen
[j
]->dock
, 0);
804 /* auto-launch apps in clip */
805 if (!wPreferences
.flags
.noclip
) {
807 for (i
= 0; i
< wScreen
[j
]->workspace_count
; i
++) {
808 if (wScreen
[j
]->workspaces
[i
]->clip
) {
809 wScreen
[j
]->last_dock
= wScreen
[j
]->workspaces
[i
]->clip
;
810 wDockDoAutoLaunch(wScreen
[j
]->workspaces
[i
]->clip
, i
);
816 /* go to workspace where we were before restart */
817 if (lastDesktop
>= 0) {
818 wWorkspaceForceChange(wScreen
[j
], lastDesktop
);
820 wSessionRestoreLastWorkspace(wScreen
[j
]);
824 if (wScreenCount
== 0) {
825 wfatal(_("could not manage any screen"));
831 static Bool
windowInList(Window window
, Window
* list
, int count
)
833 for (; count
>= 0; count
--) {
834 if (window
== list
[count
])
841 *-----------------------------------------------------------------------
843 * Manages all windows in the screen.
846 * Called when the wm is being started.
847 * No events can be processed while the windows are being
848 * reparented/managed.
849 *-----------------------------------------------------------------------
851 static void manageAllWindows(WScreen
* scr
, int crashRecovery
)
855 unsigned int nchildren
;
860 XQueryTree(dpy
, scr
->root_win
, &root
, &parent
, &children
, &nchildren
);
862 scr
->flags
.startup
= 1;
864 /* first remove all icon windows */
865 for (i
= 0; i
< nchildren
; i
++) {
868 if (children
[i
] == None
)
871 wmhints
= XGetWMHints(dpy
, children
[i
]);
872 if (wmhints
&& (wmhints
->flags
& IconWindowHint
)) {
873 for (j
= 0; j
< nchildren
; j
++) {
874 if (children
[j
] == wmhints
->icon_window
) {
887 for (i
= 0; i
< nchildren
; i
++) {
888 if (children
[i
] == None
)
891 wwin
= wManageWindow(scr
, children
[i
]);
893 /* apply states got from WSavedState */
894 /* shaded + minimized is not restored correctly */
895 if (wwin
->flags
.shaded
) {
896 wwin
->flags
.shaded
= 0;
899 if (wwin
->flags
.miniaturized
900 && (wwin
->transient_for
== None
901 || wwin
->transient_for
== scr
->root_win
902 || !windowInList(wwin
->transient_for
, children
, nchildren
))) {
904 wwin
->flags
.skip_next_animation
= 1;
905 wwin
->flags
.miniaturized
= 0;
906 wIconifyWindow(wwin
);
908 wClientSetState(wwin
, NormalState
, None
);
913 border
= (!HAS_BORDER(wwin
) ? 0 : FRAME_BORDER_WIDTH
);
915 wWindowMove(wwin
, wwin
->frame_x
- border
,
916 wwin
->frame_y
- border
-
917 (wwin
->frame
->titlebar
? wwin
->frame
->titlebar
->height
: 0));
924 wwin
= scr
->focused_window
;
926 if (wwin
->flags
.hidden
) {
927 WApplication
*wapp
= wApplicationOf(wwin
->main_window
);
930 wwin
->flags
.hidden
= 0;
931 wHideApplication(wapp
);
933 wwin
->flags
.hidden
= 0;
940 scr
->flags
.startup
= 0;
941 scr
->flags
.startup2
= 1;
943 while (XPending(dpy
)) {
945 WMNextEvent(dpy
, &ev
);
948 wWorkspaceForceChange(scr
, 0);
949 if (!wPreferences
.flags
.noclip
)
950 wDockShowIcons(scr
->workspaces
[scr
->current_workspace
]->clip
);
951 scr
->flags
.startup2
= 0;