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 along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
32 #include <sys/signal.h>
36 #include <X11/Xresource.h>
37 #include <X11/Xutil.h>
38 #include <X11/cursorfont.h>
39 #include <X11/Xproto.h>
40 #include <X11/keysym.h>
42 #include <X11/extensions/shape.h>
44 #ifdef KEEP_XKB_LOCK_STATUS
45 #include <X11/XKBlib.h>
48 #include <X11/extensions/Xrandr.h>
51 #include "WindowMaker.h"
61 #include "workspace.h"
66 #include "properties.h"
70 #include "switchmenu.h"
82 /* Just in case, for weirdo systems */
88 static WScreen
**wScreen
= NULL
;
89 static unsigned int _NumLockMask
= 0;
90 static unsigned int _ScrollLockMask
= 0;
91 static void manageAllWindows(WScreen
* scr
, int crashed
);
93 static int catchXError(Display
* dpy
, XErrorEvent
* error
)
97 /* ignore some errors */
98 if (error
->resourceid
!= None
99 && ((error
->error_code
== BadDrawable
&& error
->request_code
== X_GetGeometry
)
100 || (error
->error_code
== BadMatch
&& (error
->request_code
== X_SetInputFocus
))
101 || (error
->error_code
== BadWindow
)
103 && (error->request_code == X_GetWindowAttributes
104 || error->request_code == X_SetInputFocus
105 || error->request_code == X_ChangeWindowAttributes
106 || error->request_code == X_GetProperty
107 || error->request_code == X_ChangeProperty
108 || error->request_code == X_QueryTree
109 || error->request_code == X_GrabButton
110 || error->request_code == X_UngrabButton
111 || error->request_code == X_SendEvent
112 || error->request_code == X_ConfigureWindow))
114 || (error
->request_code
== X_InstallColormap
))) {
117 FormatXError(dpy
, error
, buffer
, MAXLINE
);
118 wwarning(_("internal X error: %s"), buffer
);
123 *----------------------------------------------------------------------
125 * Handle X shutdowns and other stuff.
126 *----------------------------------------------------------------------
128 static int handleXIO(Display
* xio_dpy
)
130 /* Parameter not used, but tell the compiler that it is ok */
139 *----------------------------------------------------------------------
141 * User generated exit signal handler.
142 *----------------------------------------------------------------------
144 static RETSIGTYPE
handleExitSig(int sig
)
149 sigprocmask(SIG_BLOCK
, &sigs
, NULL
);
151 if (sig
== SIGUSR1
) {
152 wwarning("got signal %i - restarting", sig
);
153 SIG_WCHANGE_STATE(WSTATE_NEED_RESTART
);
154 } else if (sig
== SIGUSR2
) {
155 wwarning("got signal %i - rereading defaults", sig
);
156 SIG_WCHANGE_STATE(WSTATE_NEED_REREAD
);
157 } else if (sig
== SIGTERM
|| sig
== SIGINT
|| sig
== SIGHUP
) {
158 wwarning("got signal %i - exiting...", sig
);
159 SIG_WCHANGE_STATE(WSTATE_NEED_EXIT
);
162 sigprocmask(SIG_UNBLOCK
, &sigs
, NULL
);
163 DispatchEvent(NULL
); /* Dispatch events imediately. */
166 /* Dummy signal handler */
167 static void dummyHandler(int sig
)
169 /* Parameter is not used, but tell the compiler that it is ok */
174 *----------------------------------------------------------------------
176 * general signal handler. Exits the program gently.
177 *----------------------------------------------------------------------
179 static RETSIGTYPE
handleSig(int sig
)
181 wfatal("got signal %i", sig
);
183 /* Setting the signal behaviour back to default and then reraising the
184 * signal is a cleaner way to make program exit and core dump than calling
185 * abort(), since it correctly returns from the signal handler and sets
186 * the flags accordingly. -Dan
188 if (sig
== SIGSEGV
|| sig
== SIGFPE
|| sig
== SIGBUS
|| sig
== SIGILL
|| sig
== SIGABRT
) {
189 signal(sig
, SIG_DFL
);
197 static RETSIGTYPE
buryChild(int foo
)
201 int save_errno
= errno
;
204 /* Parameter not used, but tell the compiler that it is ok */
208 /* Block signals so that NotifyDeadProcess() doesn't get fux0red */
209 sigprocmask(SIG_BLOCK
, &sigs
, NULL
);
212 /* If 2 or more kids exit in a small time window, before this handler gets
213 * the chance to get invoked, the SIGCHLD signals will be merged and only
214 * one SIGCHLD signal will be sent to us. We use a while loop to get all
215 * exited child status because we can't count on the number of SIGCHLD
216 * signals to know exactly how many kids have exited. -Dan
218 while ((pid
= waitpid(-1, &status
, WNOHANG
)) > 0 || (pid
< 0 && errno
== EINTR
)) {
219 NotifyDeadProcess(pid
, WEXITSTATUS(status
));
222 sigprocmask(SIG_UNBLOCK
, &sigs
, NULL
);
227 static void getOffendingModifiers(void)
230 XModifierKeymap
*modmap
;
231 KeyCode nlock
, slock
;
232 static int mask_table
[8] = {
233 ShiftMask
, LockMask
, ControlMask
, Mod1Mask
,
234 Mod2Mask
, Mod3Mask
, Mod4Mask
, Mod5Mask
237 nlock
= XKeysymToKeycode(dpy
, XK_Num_Lock
);
238 slock
= XKeysymToKeycode(dpy
, XK_Scroll_Lock
);
241 * Find out the masks for the NumLock and ScrollLock modifiers,
242 * so that we can bind the grabs for when they are enabled too.
244 modmap
= XGetModifierMapping(dpy
);
246 if (modmap
!= NULL
&& modmap
->max_keypermod
> 0) {
247 for (i
= 0; i
< 8 * modmap
->max_keypermod
; i
++) {
248 if (modmap
->modifiermap
[i
] == nlock
&& nlock
!= 0)
249 _NumLockMask
= mask_table
[i
/ modmap
->max_keypermod
];
250 else if (modmap
->modifiermap
[i
] == slock
&& slock
!= 0)
251 _ScrollLockMask
= mask_table
[i
/ modmap
->max_keypermod
];
256 XFreeModifiermap(modmap
);
261 wHackedGrabKey(int keycode
, unsigned int modifiers
,
262 Window grab_window
, Bool owner_events
, int pointer_mode
, int keyboard_mode
)
264 if (modifiers
== AnyModifier
)
267 /* grab all combinations of the modifier with CapsLock, NumLock and
268 * ScrollLock. How much memory/CPU does such a monstrosity consume
272 XGrabKey(dpy
, keycode
, modifiers
| _NumLockMask
,
273 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
275 XGrabKey(dpy
, keycode
, modifiers
| _ScrollLockMask
,
276 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
277 if (_NumLockMask
&& _ScrollLockMask
)
278 XGrabKey(dpy
, keycode
, modifiers
| _NumLockMask
| _ScrollLockMask
,
279 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
281 XGrabKey(dpy
, keycode
, modifiers
| _NumLockMask
| LockMask
,
282 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
284 XGrabKey(dpy
, keycode
, modifiers
| _ScrollLockMask
| LockMask
,
285 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
286 if (_NumLockMask
&& _ScrollLockMask
)
287 XGrabKey(dpy
, keycode
, modifiers
| _NumLockMask
| _ScrollLockMask
| LockMask
,
288 grab_window
, owner_events
, pointer_mode
, keyboard_mode
);
289 /* phew, I guess that's all, right? */
294 wHackedGrabButton(unsigned int button
, unsigned int modifiers
,
295 Window grab_window
, Bool owner_events
,
296 unsigned int event_mask
, int pointer_mode
, int keyboard_mode
, Window confine_to
, Cursor cursor
)
298 XGrabButton(dpy
, button
, modifiers
, grab_window
, owner_events
,
299 event_mask
, pointer_mode
, keyboard_mode
, confine_to
, cursor
);
301 if (modifiers
== AnyModifier
)
304 XGrabButton(dpy
, button
, modifiers
| LockMask
, grab_window
, owner_events
,
305 event_mask
, pointer_mode
, keyboard_mode
, confine_to
, cursor
);
308 /* same as above, but for mouse buttons */
310 XGrabButton(dpy
, button
, modifiers
| _NumLockMask
,
311 grab_window
, owner_events
, event_mask
, pointer_mode
,
312 keyboard_mode
, confine_to
, cursor
);
314 XGrabButton(dpy
, button
, modifiers
| _ScrollLockMask
,
315 grab_window
, owner_events
, event_mask
, pointer_mode
,
316 keyboard_mode
, confine_to
, cursor
);
317 if (_NumLockMask
&& _ScrollLockMask
)
318 XGrabButton(dpy
, button
, modifiers
| _ScrollLockMask
| _NumLockMask
,
319 grab_window
, owner_events
, event_mask
, pointer_mode
,
320 keyboard_mode
, confine_to
, cursor
);
322 XGrabButton(dpy
, button
, modifiers
| _NumLockMask
| LockMask
,
323 grab_window
, owner_events
, event_mask
, pointer_mode
,
324 keyboard_mode
, confine_to
, cursor
);
326 XGrabButton(dpy
, button
, modifiers
| _ScrollLockMask
| LockMask
,
327 grab_window
, owner_events
, event_mask
, pointer_mode
,
328 keyboard_mode
, confine_to
, cursor
);
329 if (_NumLockMask
&& _ScrollLockMask
)
330 XGrabButton(dpy
, button
, modifiers
| _ScrollLockMask
| _NumLockMask
| LockMask
,
331 grab_window
, owner_events
, event_mask
, pointer_mode
,
332 keyboard_mode
, confine_to
, cursor
);
333 #endif /* NUMLOCK_HACK */
336 WScreen
*wScreenWithNumber(int i
)
338 assert(i
< w_global
.screen_count
);
343 WScreen
*wScreenForRootWindow(Window window
)
347 if (w_global
.screen_count
== 1)
350 /* Since the number of heads will probably be small (normally 2),
351 * it should be faster to use this than a hash table, because
352 * of the overhead. */
353 for (i
= 0; i
< w_global
.screen_count
; i
++)
354 if (wScreen
[i
]->root_win
== window
)
357 return wScreenForWindow(window
);
360 WScreen
*wScreenForWindow(Window window
)
362 XWindowAttributes attr
;
364 if (w_global
.screen_count
== 1)
367 if (XGetWindowAttributes(dpy
, window
, &attr
))
368 return wScreenForRootWindow(attr
.root
);
373 static char *atomNames
[] = {
381 "WM_COLORMAP_WINDOWS",
382 "WM_COLORMAP_NOTIFY",
385 "_WINDOWMAKER_STATE",
386 "_WINDOWMAKER_WM_PROTOCOLS",
387 "_WINDOWMAKER_WM_FUNCTION",
388 "_WINDOWMAKER_NOTICEBOARD",
389 "_WINDOWMAKER_COMMAND",
390 "_WINDOWMAKER_ICON_SIZE",
391 "_WINDOWMAKER_ICON_TILE",
393 GNUSTEP_WM_ATTR_NAME
,
394 GNUSTEP_WM_MINIATURIZE_WINDOW
,
395 GNUSTEP_TITLEBAR_STATE
,
397 "WM_IGNORE_FOCUS_EVENTS"
401 *----------------------------------------------------------
403 * starts the window manager and setup global data.
404 * Called from main() at startup.
407 * global data declared in main.c is initialized
408 *----------------------------------------------------------
410 void StartUp(Bool defaultScreenOnly
)
412 struct sigaction sig_action
;
415 Atom atom
[wlengthof(atomNames
)];
418 * Ignore CapsLock in modifiers
420 w_global
.shortcut
.modifiers_mask
= 0xff & ~LockMask
;
422 getOffendingModifiers();
424 * Ignore NumLock and ScrollLock too
426 w_global
.shortcut
.modifiers_mask
&= ~(_NumLockMask
| _ScrollLockMask
);
428 memset(&wKeyBindings
, 0, sizeof(wKeyBindings
));
430 w_global
.context
.client_win
= XUniqueContext();
431 w_global
.context
.app_win
= XUniqueContext();
432 w_global
.context
.stack
= XUniqueContext();
434 /* _XA_VERSION = XInternAtom(dpy, "VERSION", False); */
436 #ifdef HAVE_XINTERNATOMS
437 XInternAtoms(dpy
, atomNames
, wlengthof(atomNames
), False
, atom
);
442 for (i
= 0; i
< wlengthof(atomNames
); i
++)
443 atom
[i
] = XInternAtom(dpy
, atomNames
[i
], False
);
447 w_global
.atom
.wm
.state
= atom
[0];
448 w_global
.atom
.wm
.change_state
= atom
[1];
449 w_global
.atom
.wm
.protocols
= atom
[2];
450 w_global
.atom
.wm
.take_focus
= atom
[3];
451 w_global
.atom
.wm
.delete_window
= atom
[4];
452 w_global
.atom
.wm
.save_yourself
= atom
[5];
453 w_global
.atom
.wm
.client_leader
= atom
[6];
454 w_global
.atom
.wm
.colormap_windows
= atom
[7];
455 w_global
.atom
.wm
.colormap_notify
= atom
[8];
457 w_global
.atom
.wmaker
.menu
= atom
[9];
458 w_global
.atom
.wmaker
.state
= atom
[10];
459 w_global
.atom
.wmaker
.wm_protocols
= atom
[11];
460 w_global
.atom
.wmaker
.wm_function
= atom
[12];
461 w_global
.atom
.wmaker
.noticeboard
= atom
[13];
462 w_global
.atom
.wmaker
.command
= atom
[14];
463 w_global
.atom
.wmaker
.icon_size
= atom
[15];
464 w_global
.atom
.wmaker
.icon_tile
= atom
[16];
466 w_global
.atom
.gnustep
.wm_attr
= atom
[17];
467 w_global
.atom
.gnustep
.wm_miniaturize_window
= atom
[18];
468 w_global
.atom
.gnustep
.titlebar_state
= atom
[19];
470 w_global
.atom
.wm
.ignore_focus_events
= atom
[20];
473 wXDNDInitializeAtoms();
477 wPreferences
.cursor
[WCUR_NORMAL
] = None
; /* inherit from root */
478 wPreferences
.cursor
[WCUR_ROOT
] = XCreateFontCursor(dpy
, XC_left_ptr
);
479 wPreferences
.cursor
[WCUR_ARROW
] = XCreateFontCursor(dpy
, XC_top_left_arrow
);
480 wPreferences
.cursor
[WCUR_MOVE
] = XCreateFontCursor(dpy
, XC_fleur
);
481 wPreferences
.cursor
[WCUR_RESIZE
] = XCreateFontCursor(dpy
, XC_sizing
);
482 wPreferences
.cursor
[WCUR_TOPLEFTRESIZE
] = XCreateFontCursor(dpy
, XC_top_left_corner
);
483 wPreferences
.cursor
[WCUR_TOPRIGHTRESIZE
] = XCreateFontCursor(dpy
, XC_top_right_corner
);
484 wPreferences
.cursor
[WCUR_BOTTOMLEFTRESIZE
] = XCreateFontCursor(dpy
, XC_bottom_left_corner
);
485 wPreferences
.cursor
[WCUR_BOTTOMRIGHTRESIZE
] = XCreateFontCursor(dpy
, XC_bottom_right_corner
);
486 wPreferences
.cursor
[WCUR_VERTICALRESIZE
] = XCreateFontCursor(dpy
, XC_sb_v_double_arrow
);
487 wPreferences
.cursor
[WCUR_HORIZONRESIZE
] = XCreateFontCursor(dpy
, XC_sb_h_double_arrow
);
488 wPreferences
.cursor
[WCUR_WAIT
] = XCreateFontCursor(dpy
, XC_watch
);
489 wPreferences
.cursor
[WCUR_QUESTION
] = XCreateFontCursor(dpy
, XC_question_arrow
);
490 wPreferences
.cursor
[WCUR_TEXT
] = XCreateFontCursor(dpy
, XC_xterm
); /* odd name??? */
491 wPreferences
.cursor
[WCUR_SELECT
] = XCreateFontCursor(dpy
, XC_cross
);
493 Pixmap cur
= XCreatePixmap(dpy
, DefaultRootWindow(dpy
), 16, 16, 1);
494 GC gc
= XCreateGC(dpy
, cur
, 0, NULL
);
496 memset(&black
, 0, sizeof(XColor
));
497 XSetForeground(dpy
, gc
, 0);
498 XFillRectangle(dpy
, cur
, gc
, 0, 0, 16, 16);
500 wPreferences
.cursor
[WCUR_EMPTY
] = XCreatePixmapCursor(dpy
, cur
, cur
, &black
, &black
, 0, 0);
501 XFreePixmap(dpy
, cur
);
503 /* emergency exit... */
504 sig_action
.sa_handler
= handleSig
;
505 sigemptyset(&sig_action
.sa_mask
);
507 sig_action
.sa_flags
= SA_RESTART
;
508 sigaction(SIGQUIT
, &sig_action
, NULL
);
509 /* instead of catching these, we let the default handler abort the
510 * program. The new monitor process will take appropriate action
511 * when it detects the crash.
512 sigaction(SIGSEGV, &sig_action, NULL);
513 sigaction(SIGBUS, &sig_action, NULL);
514 sigaction(SIGFPE, &sig_action, NULL);
515 sigaction(SIGABRT, &sig_action, NULL);
518 sig_action
.sa_handler
= handleExitSig
;
520 /* Here we set SA_RESTART for safety, because SIGUSR1 may not be handled
521 * immediately. -Dan */
522 sig_action
.sa_flags
= SA_RESTART
;
523 sigaction(SIGTERM
, &sig_action
, NULL
);
524 sigaction(SIGINT
, &sig_action
, NULL
);
525 sigaction(SIGHUP
, &sig_action
, NULL
);
526 sigaction(SIGUSR1
, &sig_action
, NULL
);
527 sigaction(SIGUSR2
, &sig_action
, NULL
);
529 /* ignore dead pipe */
530 /* Because POSIX mandates that only signal with handlers are reset
531 * accross an exec*(), we do not want to propagate ignoring SIGPIPEs
532 * to children. Hence the dummy handler.
533 * Philippe Troin <phil@fifi.org>
535 sig_action
.sa_handler
= &dummyHandler
;
536 sig_action
.sa_flags
= SA_RESTART
;
537 sigaction(SIGPIPE
, &sig_action
, NULL
);
539 /* handle dead children */
540 sig_action
.sa_handler
= buryChild
;
541 sig_action
.sa_flags
= SA_NOCLDSTOP
| SA_RESTART
;
542 sigaction(SIGCHLD
, &sig_action
, NULL
);
544 /* Now we unblock all signals, that may have been blocked by the parent
545 * who exec()-ed us. This can happen for example if Window Maker crashes
546 * and restarts itself or another window manager from the signal handler.
547 * In this case, the new proccess inherits the blocked signal mask and
548 * will no longer react to that signal, until unblocked.
549 * This is because the signal handler of the proccess who crashed (parent)
550 * didn't return, and the signal remained blocked. -Dan
552 sigfillset(&sig_action
.sa_mask
);
553 sigprocmask(SIG_UNBLOCK
, &sig_action
.sa_mask
, NULL
);
555 /* handle X shutdowns a such */
556 XSetIOErrorHandler(handleXIO
);
558 /* set hook for out event dispatcher in WINGs event dispatcher */
559 WMHookEventHandler(DispatchEvent
);
561 /* initialize defaults stuff */
562 w_global
.domain
.wmaker
= wDefaultsInitDomain("WindowMaker", True
);
563 if (!w_global
.domain
.wmaker
->dictionary
)
564 wwarning(_("could not read domain \"%s\" from defaults database"), "WindowMaker");
566 /* read defaults that don't change until a restart and are
567 * screen independent */
568 wReadStaticDefaults(w_global
.domain
.wmaker
? w_global
.domain
.wmaker
->dictionary
: NULL
);
570 /* check sanity of some values */
571 if (wPreferences
.icon_size
< 16) {
572 wwarning(_("icon size is configured to %i, but it's too small. Using 16 instead"),
573 wPreferences
.icon_size
);
574 wPreferences
.icon_size
= 16;
577 /* init other domains */
578 w_global
.domain
.root_menu
= wDefaultsInitDomain("WMRootMenu", False
);
579 if (!w_global
.domain
.root_menu
->dictionary
)
580 wwarning(_("could not read domain \"%s\" from defaults database"), "WMRootMenu");
582 wDefaultsMergeGlobalMenus(w_global
.domain
.root_menu
);
584 w_global
.domain
.window_attr
= wDefaultsInitDomain("WMWindowAttributes", True
);
585 if (!w_global
.domain
.window_attr
->dictionary
)
586 wwarning(_("could not read domain \"%s\" from defaults database"), "WMWindowAttributes");
588 XSetErrorHandler((XErrorHandler
) catchXError
);
592 w_global
.xext
.shape
.supported
= XShapeQueryExtension(dpy
, &w_global
.xext
.shape
.event_base
, &j
);
596 w_global
.xext
.randr
.supported
= XRRQueryExtension(dpy
, &w_global
.xext
.randr
.event_base
, &j
);
599 #ifdef KEEP_XKB_LOCK_STATUS
600 w_global
.xext
.xkb
.supported
= XkbQueryExtension(dpy
, NULL
, &w_global
.xext
.xkb
.event_base
, NULL
, NULL
, NULL
);
601 if (wPreferences
.modelock
&& !w_global
.xext
.xkb
.supported
) {
602 wwarning(_("XKB is not supported. KbdModeLock is automatically disabled."));
603 wPreferences
.modelock
= 0;
607 if (defaultScreenOnly
)
610 max
= ScreenCount(dpy
);
612 wScreen
= wmalloc(sizeof(WScreen
*) * max
);
614 w_global
.screen_count
= 0;
616 /* Check if TIFF images are supported */
617 formats
= RSupportedFileFormats();
619 for (i
= 0; formats
[i
] != NULL
; i
++) {
620 if (strcmp(formats
[i
], "TIFF") == 0) {
621 wPreferences
.supports_tiff
= 1;
627 /* manage the screens */
628 for (j
= 0; j
< max
; j
++) {
629 if (defaultScreenOnly
|| max
== 1) {
630 wScreen
[w_global
.screen_count
] = wScreenInit(DefaultScreen(dpy
));
631 if (!wScreen
[w_global
.screen_count
]) {
632 wfatal(_("it seems that there is already a window manager running"));
636 wScreen
[w_global
.screen_count
] = wScreenInit(j
);
637 if (!wScreen
[w_global
.screen_count
]) {
638 wwarning(_("could not manage screen %i"), j
);
642 w_global
.screen_count
++;
645 InitializeSwitchMenu();
647 /* initialize/restore state for the screens */
648 for (j
= 0; j
< w_global
.screen_count
; j
++) {
651 lastDesktop
= wNETWMGetCurrentDesktopFromHint(wScreen
[j
]);
653 wScreenRestoreState(wScreen
[j
]);
655 /* manage all windows that were already here before us */
656 if (!wPreferences
.flags
.nodock
&& wScreen
[j
]->dock
)
657 wScreen
[j
]->last_dock
= wScreen
[j
]->dock
;
659 manageAllWindows(wScreen
[j
], wPreferences
.flags
.restarting
== 2);
661 /* restore saved menus */
662 wMenuRestoreState(wScreen
[j
]);
664 /* If we're not restarting, restore session */
665 if (wPreferences
.flags
.restarting
== 0 && !wPreferences
.flags
.norestore
)
666 wSessionRestoreState(wScreen
[j
]);
668 if (!wPreferences
.flags
.noautolaunch
) {
669 /* auto-launch apps */
670 if (!wPreferences
.flags
.nodock
&& wScreen
[j
]->dock
) {
671 wScreen
[j
]->last_dock
= wScreen
[j
]->dock
;
672 wDockDoAutoLaunch(wScreen
[j
]->dock
, 0);
674 /* auto-launch apps in clip */
675 if (!wPreferences
.flags
.noclip
) {
677 for (i
= 0; i
< wScreen
[j
]->workspace_count
; i
++) {
678 if (wScreen
[j
]->workspaces
[i
]->clip
) {
679 wScreen
[j
]->last_dock
= wScreen
[j
]->workspaces
[i
]->clip
;
680 wDockDoAutoLaunch(wScreen
[j
]->workspaces
[i
]->clip
, i
);
684 /* auto-launch apps in drawers */
685 if (!wPreferences
.flags
.nodrawer
) {
687 for (dc
= wScreen
[j
]->drawers
; dc
; dc
= dc
->next
) {
688 wScreen
[j
]->last_dock
= dc
->adrawer
;
689 wDockDoAutoLaunch(dc
->adrawer
, 0);
694 /* go to workspace where we were before restart */
695 if (lastDesktop
>= 0)
696 wWorkspaceForceChange(wScreen
[j
], lastDesktop
);
698 wSessionRestoreLastWorkspace(wScreen
[j
]);
701 if (w_global
.screen_count
== 0) {
702 wfatal(_("could not manage any screen"));
707 /* setup defaults file polling */
708 if (!wPreferences
.flags
.nopolling
&& !wPreferences
.flags
.noupdates
)
709 WMAddTimerHandler(3000, wDefaultsCheckDomains
, NULL
);
714 static Bool
windowInList(Window window
, Window
* list
, int count
)
716 for (; count
>= 0; count
--) {
717 if (window
== list
[count
])
724 *-----------------------------------------------------------------------
726 * Manages all windows in the screen.
729 * Called when the wm is being started.
730 * No events can be processed while the windows are being
731 * reparented/managed.
732 *-----------------------------------------------------------------------
734 static void manageAllWindows(WScreen
* scr
, int crashRecovery
)
738 unsigned int nchildren
;
743 XQueryTree(dpy
, scr
->root_win
, &root
, &parent
, &children
, &nchildren
);
745 scr
->flags
.startup
= 1;
747 /* first remove all icon windows */
748 for (i
= 0; i
< nchildren
; i
++) {
751 if (children
[i
] == None
)
754 wmhints
= XGetWMHints(dpy
, children
[i
]);
755 if (wmhints
&& (wmhints
->flags
& IconWindowHint
)) {
756 for (j
= 0; j
< nchildren
; j
++) {
757 if (children
[j
] == wmhints
->icon_window
) {
770 for (i
= 0; i
< nchildren
; i
++) {
771 if (children
[i
] == None
)
774 wwin
= wManageWindow(scr
, children
[i
]);
776 /* apply states got from WSavedState */
777 /* shaded + minimized is not restored correctly */
778 if (wwin
->flags
.shaded
) {
779 wwin
->flags
.shaded
= 0;
782 if (wwin
->flags
.miniaturized
783 && (wwin
->transient_for
== None
784 || wwin
->transient_for
== scr
->root_win
785 || !windowInList(wwin
->transient_for
, children
, nchildren
))) {
787 wwin
->flags
.skip_next_animation
= 1;
788 wwin
->flags
.miniaturized
= 0;
789 wIconifyWindow(wwin
);
791 wClientSetState(wwin
, NormalState
, None
);
796 border
= (!HAS_BORDER(wwin
) ? 0 : scr
->frame_border_width
);
798 wWindowMove(wwin
, wwin
->frame_x
- border
,
799 wwin
->frame_y
- border
-
800 (wwin
->frame
->titlebar
? wwin
->frame
->titlebar
->height
: 0));
807 wwin
= scr
->focused_window
;
809 if (wwin
->flags
.hidden
) {
810 WApplication
*wapp
= wApplicationOf(wwin
->main_window
);
813 wwin
->flags
.hidden
= 0;
814 wHideApplication(wapp
);
816 wwin
->flags
.hidden
= 0;
823 scr
->flags
.startup
= 0;
824 scr
->flags
.startup2
= 1;
826 while (XPending(dpy
)) {
828 WMNextEvent(dpy
, &ev
);
831 scr
->last_workspace
= 0;
832 wWorkspaceForceChange(scr
, 0);
833 if (!wPreferences
.flags
.noclip
)
834 wDockShowIcons(scr
->workspaces
[scr
->current_workspace
]->clip
);
835 scr
->flags
.startup2
= 0;