Make wmaker XRandR aware
[wmaker-crm.git] / src / startup.c
1 /*
2 * Window Maker window manager
3 *
4 * Copyright (c) 1997-2003 Alfredo K. Kojima
5 * Copyright (c) 1998-2003 Dan Pascu
6 *
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.
11 *
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.
16 *
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,
20 * USA.
21 */
22
23 #include "wconfig.h"
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <signal.h>
31 #include <sys/wait.h>
32 #ifdef __FreeBSD__
33 #include <sys/signal.h>
34 #endif
35
36 #include <X11/Xlib.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>
42 #ifdef SHAPE
43 #include <X11/extensions/shape.h>
44 #endif
45 #ifdef KEEP_XKB_LOCK_STATUS
46 #include <X11/XKBlib.h>
47 #endif
48 #ifdef HAVE_XRANDR
49 #include <X11/extensions/Xrandr.h>
50 #endif
51
52 #include "WindowMaker.h"
53 #include "GNUstep.h"
54 #include "texture.h"
55 #include "screen.h"
56 #include "window.h"
57 #include "actions.h"
58 #include "client.h"
59 #include "funcs.h"
60 #include "dock.h"
61 #include "workspace.h"
62 #include "keybind.h"
63 #include "framewin.h"
64 #include "session.h"
65 #include "defaults.h"
66 #include "properties.h"
67 #include "dialog.h"
68 #include "wmspec.h"
69 #ifdef XDND
70 #include "xdnd.h"
71 #endif
72
73 #include "xutil.h"
74
75 /* for SunOS */
76 #ifndef SA_RESTART
77 # define SA_RESTART 0
78 #endif
79
80 /* Just in case, for weirdo systems */
81 #ifndef SA_NODEFER
82 # define SA_NODEFER 0
83 #endif
84
85 /****** Global Variables ******/
86 extern WPreferences wPreferences;
87 extern WDDomain *WDWindowMaker;
88 extern WDDomain *WDRootMenu;
89 extern WDDomain *WDWindowAttributes;
90 extern WShortKey wKeyBindings[WKBD_LAST];
91 extern int wScreenCount;
92
93 #ifdef SHAPE
94 extern Bool wShapeSupported;
95 extern int wShapeEventBase;
96 #endif
97
98 #ifdef KEEP_XKB_LOCK_STATUS
99 extern Bool wXkbSupported;
100 extern int wXkbEventBase;
101 #endif
102
103 #ifdef HAVE_XRANDR
104 extern Bool has_randr;
105 extern int randr_event_base;
106 #endif
107
108 /* contexts */
109 extern XContext wWinContext;
110 extern XContext wAppWinContext;
111 extern XContext wStackContext;
112 extern XContext wVEdgeContext;
113
114 /* atoms */
115 extern Atom _XA_WM_STATE;
116 extern Atom _XA_WM_CHANGE_STATE;
117 extern Atom _XA_WM_PROTOCOLS;
118 extern Atom _XA_WM_TAKE_FOCUS;
119 extern Atom _XA_WM_DELETE_WINDOW;
120 extern Atom _XA_WM_SAVE_YOURSELF;
121 extern Atom _XA_WM_CLIENT_LEADER;
122 extern Atom _XA_WM_COLORMAP_WINDOWS;
123 extern Atom _XA_WM_COLORMAP_NOTIFY;
124 extern Atom _XA_GNUSTEP_WM_ATTR;
125 extern Atom _XA_WINDOWMAKER_MENU;
126 extern Atom _XA_WINDOWMAKER_WM_PROTOCOLS;
127 extern Atom _XA_WINDOWMAKER_STATE;
128 extern Atom _XA_WINDOWMAKER_WM_FUNCTION;
129 extern Atom _XA_WINDOWMAKER_NOTICEBOARD;
130 extern Atom _XA_WINDOWMAKER_COMMAND;
131 extern Atom _XA_WINDOWMAKER_ICON_SIZE;
132 extern Atom _XA_WINDOWMAKER_ICON_TILE;
133 extern Atom _XA_GNUSTEP_WM_MINIATURIZE_WINDOW;
134 extern Atom _XA_GNUSTEP_TITLEBAR_STATE;
135 extern Atom _XA_WM_IGNORE_FOCUS_EVENTS;
136
137 /* cursors */
138 extern Cursor wCursor[WCUR_LAST];
139
140 #ifndef HAVE_INOTIFY
141 /* special flags */
142 extern char WDelayedActionSet;
143 #endif
144
145 extern void NotifyDeadProcess(pid_t pid, unsigned char status);
146
147 /***** Local *****/
148 static WScreen **wScreen = NULL;
149 static unsigned int _NumLockMask = 0;
150 static unsigned int _ScrollLockMask = 0;
151 static void manageAllWindows(WScreen * scr, int crashed);
152
153 static int catchXError(Display * dpy, XErrorEvent * error)
154 {
155 char buffer[MAXLINE];
156
157 /* ignore some errors */
158 if (error->resourceid != None
159 && ((error->error_code == BadDrawable && error->request_code == X_GetGeometry)
160 || (error->error_code == BadMatch && (error->request_code == X_SetInputFocus))
161 || (error->error_code == BadWindow)
162 /*
163 && (error->request_code == X_GetWindowAttributes
164 || error->request_code == X_SetInputFocus
165 || error->request_code == X_ChangeWindowAttributes
166 || error->request_code == X_GetProperty
167 || error->request_code == X_ChangeProperty
168 || error->request_code == X_QueryTree
169 || error->request_code == X_GrabButton
170 || error->request_code == X_UngrabButton
171 || error->request_code == X_SendEvent
172 || error->request_code == X_ConfigureWindow))
173 */
174 || (error->request_code == X_InstallColormap))) {
175 return 0;
176 }
177 FormatXError(dpy, error, buffer, MAXLINE);
178 wwarning(_("internal X error: %s\n"), buffer);
179 return -1;
180 }
181
182 /*
183 *----------------------------------------------------------------------
184 * handleXIO-
185 * Handle X shutdowns and other stuff.
186 *----------------------------------------------------------------------
187 */
188 static int handleXIO(Display * xio_dpy)
189 {
190 dpy = NULL;
191 Exit(0);
192 return 0;
193 }
194
195 #ifndef HAVE_INOTIFY
196 /*
197 *----------------------------------------------------------------------
198 * delayedAction-
199 * Action to be executed after the signal() handler is exited.
200 *----------------------------------------------------------------------
201 */
202 static void delayedAction(void *cdata)
203 {
204 if (WDelayedActionSet == 0)
205 return;
206
207 WDelayedActionSet--;
208 /*
209 * Make the event dispatcher do whatever it needs to do,
210 * including handling zombie processes, restart and exit
211 * signals.
212 */
213 DispatchEvent(NULL);
214 }
215 #endif
216
217 /*
218 *----------------------------------------------------------------------
219 * handleExitSig--
220 * User generated exit signal handler.
221 *----------------------------------------------------------------------
222 */
223 static RETSIGTYPE handleExitSig(int sig)
224 {
225 sigset_t sigs;
226
227 sigfillset(&sigs);
228 sigprocmask(SIG_BLOCK, &sigs, NULL);
229
230 if (sig == SIGUSR1) {
231 wwarning("got signal %i - restarting\n", sig);
232 SIG_WCHANGE_STATE(WSTATE_NEED_RESTART);
233 } else if (sig == SIGUSR2) {
234 wwarning("got signal %i - rereading defaults\n", sig);
235 SIG_WCHANGE_STATE(WSTATE_NEED_REREAD);
236 } else if (sig == SIGTERM || sig == SIGINT || sig == SIGHUP) {
237 wwarning("got signal %i - exiting...\n", sig);
238 SIG_WCHANGE_STATE(WSTATE_NEED_EXIT);
239 }
240
241 sigprocmask(SIG_UNBLOCK, &sigs, NULL);
242 DispatchEvent(NULL); /* Dispatch events imediately. */
243 }
244
245 /* Dummy signal handler */
246 static void dummyHandler(int sig)
247 {
248 }
249
250 /*
251 *----------------------------------------------------------------------
252 * handleSig--
253 * general signal handler. Exits the program gently.
254 *----------------------------------------------------------------------
255 */
256 static RETSIGTYPE handleSig(int sig)
257 {
258 wfatal("got signal %i\n", sig);
259
260 /* Setting the signal behaviour back to default and then reraising the
261 * signal is a cleaner way to make program exit and core dump than calling
262 * abort(), since it correctly returns from the signal handler and sets
263 * the flags accordingly. -Dan
264 */
265 if (sig == SIGSEGV || sig == SIGFPE || sig == SIGBUS || sig == SIGILL || sig == SIGABRT) {
266 signal(sig, SIG_DFL);
267 kill(getpid(), sig);
268 return;
269 }
270
271 wAbort(0);
272 }
273
274 static RETSIGTYPE buryChild(int foo)
275 {
276 pid_t pid;
277 int status;
278 int save_errno = errno;
279 sigset_t sigs;
280
281 sigfillset(&sigs);
282 /* Block signals so that NotifyDeadProcess() doesn't get fux0red */
283 sigprocmask(SIG_BLOCK, &sigs, NULL);
284
285 /* R.I.P. */
286 /* If 2 or more kids exit in a small time window, before this handler gets
287 * the chance to get invoked, the SIGCHLD signals will be merged and only
288 * one SIGCHLD signal will be sent to us. We use a while loop to get all
289 * exited child status because we can't count on the number of SIGCHLD
290 * signals to know exactly how many kids have exited. -Dan
291 */
292 while ((pid = waitpid(-1, &status, WNOHANG)) > 0 || (pid < 0 && errno == EINTR)) {
293 NotifyDeadProcess(pid, WEXITSTATUS(status));
294 }
295
296 sigprocmask(SIG_UNBLOCK, &sigs, NULL);
297
298 errno = save_errno;
299 }
300
301 static void getOffendingModifiers(void)
302 {
303 int i;
304 XModifierKeymap *modmap;
305 KeyCode nlock, slock;
306 static int mask_table[8] = {
307 ShiftMask, LockMask, ControlMask, Mod1Mask,
308 Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
309 };
310
311 nlock = XKeysymToKeycode(dpy, XK_Num_Lock);
312 slock = XKeysymToKeycode(dpy, XK_Scroll_Lock);
313
314 /*
315 * Find out the masks for the NumLock and ScrollLock modifiers,
316 * so that we can bind the grabs for when they are enabled too.
317 */
318 modmap = XGetModifierMapping(dpy);
319
320 if (modmap != NULL && modmap->max_keypermod > 0) {
321 for (i = 0; i < 8 * modmap->max_keypermod; i++) {
322 if (modmap->modifiermap[i] == nlock && nlock != 0)
323 _NumLockMask = mask_table[i / modmap->max_keypermod];
324 else if (modmap->modifiermap[i] == slock && slock != 0)
325 _ScrollLockMask = mask_table[i / modmap->max_keypermod];
326 }
327 }
328
329 if (modmap)
330 XFreeModifiermap(modmap);
331 }
332
333 #ifdef NUMLOCK_HACK
334 void
335 wHackedGrabKey(int keycode, unsigned int modifiers,
336 Window grab_window, Bool owner_events, int pointer_mode, int keyboard_mode)
337 {
338 if (modifiers == AnyModifier)
339 return;
340
341 /* grab all combinations of the modifier with CapsLock, NumLock and
342 * ScrollLock. How much memory/CPU does such a monstrosity consume
343 * in the server?
344 */
345 if (_NumLockMask)
346 XGrabKey(dpy, keycode, modifiers | _NumLockMask,
347 grab_window, owner_events, pointer_mode, keyboard_mode);
348 if (_ScrollLockMask)
349 XGrabKey(dpy, keycode, modifiers | _ScrollLockMask,
350 grab_window, owner_events, pointer_mode, keyboard_mode);
351 if (_NumLockMask && _ScrollLockMask)
352 XGrabKey(dpy, keycode, modifiers | _NumLockMask | _ScrollLockMask,
353 grab_window, owner_events, pointer_mode, keyboard_mode);
354 if (_NumLockMask)
355 XGrabKey(dpy, keycode, modifiers | _NumLockMask | LockMask,
356 grab_window, owner_events, pointer_mode, keyboard_mode);
357 if (_ScrollLockMask)
358 XGrabKey(dpy, keycode, modifiers | _ScrollLockMask | LockMask,
359 grab_window, owner_events, pointer_mode, keyboard_mode);
360 if (_NumLockMask && _ScrollLockMask)
361 XGrabKey(dpy, keycode, modifiers | _NumLockMask | _ScrollLockMask | LockMask,
362 grab_window, owner_events, pointer_mode, keyboard_mode);
363 /* phew, I guess that's all, right? */
364 }
365 #endif
366
367 void
368 wHackedGrabButton(unsigned int button, unsigned int modifiers,
369 Window grab_window, Bool owner_events,
370 unsigned int event_mask, int pointer_mode, int keyboard_mode, Window confine_to, Cursor cursor)
371 {
372 XGrabButton(dpy, button, modifiers, grab_window, owner_events,
373 event_mask, pointer_mode, keyboard_mode, confine_to, cursor);
374
375 if (modifiers == AnyModifier)
376 return;
377
378 XGrabButton(dpy, button, modifiers | LockMask, grab_window, owner_events,
379 event_mask, pointer_mode, keyboard_mode, confine_to, cursor);
380
381 #ifdef NUMLOCK_HACK
382 /* same as above, but for mouse buttons */
383 if (_NumLockMask)
384 XGrabButton(dpy, button, modifiers | _NumLockMask,
385 grab_window, owner_events, event_mask, pointer_mode,
386 keyboard_mode, confine_to, cursor);
387 if (_ScrollLockMask)
388 XGrabButton(dpy, button, modifiers | _ScrollLockMask,
389 grab_window, owner_events, event_mask, pointer_mode,
390 keyboard_mode, confine_to, cursor);
391 if (_NumLockMask && _ScrollLockMask)
392 XGrabButton(dpy, button, modifiers | _ScrollLockMask | _NumLockMask,
393 grab_window, owner_events, event_mask, pointer_mode,
394 keyboard_mode, confine_to, cursor);
395 if (_NumLockMask)
396 XGrabButton(dpy, button, modifiers | _NumLockMask | LockMask,
397 grab_window, owner_events, event_mask, pointer_mode,
398 keyboard_mode, confine_to, cursor);
399 if (_ScrollLockMask)
400 XGrabButton(dpy, button, modifiers | _ScrollLockMask | LockMask,
401 grab_window, owner_events, event_mask, pointer_mode,
402 keyboard_mode, confine_to, cursor);
403 if (_NumLockMask && _ScrollLockMask)
404 XGrabButton(dpy, button, modifiers | _ScrollLockMask | _NumLockMask | LockMask,
405 grab_window, owner_events, event_mask, pointer_mode,
406 keyboard_mode, confine_to, cursor);
407 #endif /* NUMLOCK_HACK */
408 }
409
410 WScreen *wScreenWithNumber(int i)
411 {
412 assert(i < wScreenCount);
413
414 return wScreen[i];
415 }
416
417 WScreen *wScreenForRootWindow(Window window)
418 {
419 int i;
420
421 if (wScreenCount == 1)
422 return wScreen[0];
423
424 /*
425 * Since the number of heads will probably be small (normally 2),
426 * it should be faster to use this than a hash table, because
427 * of the overhead.
428 */
429 for (i = 0; i < wScreenCount; i++) {
430 if (wScreen[i]->root_win == window) {
431 return wScreen[i];
432 }
433 }
434
435 return wScreenForWindow(window);
436 }
437
438 WScreen *wScreenSearchForRootWindow(Window window)
439 {
440 int i;
441
442 if (wScreenCount == 1)
443 return wScreen[0];
444
445 /*
446 * Since the number of heads will probably be small (normally 2),
447 * it should be faster to use this than a hash table, because
448 * of the overhead.
449 */
450 for (i = 0; i < wScreenCount; i++) {
451 if (wScreen[i]->root_win == window) {
452 return wScreen[i];
453 }
454 }
455
456 return wScreenForWindow(window);
457 }
458
459 WScreen *wScreenForWindow(Window window)
460 {
461 XWindowAttributes attr;
462
463 if (wScreenCount == 1)
464 return wScreen[0];
465
466 if (XGetWindowAttributes(dpy, window, &attr)) {
467 return wScreenForRootWindow(attr.root);
468 }
469 return NULL;
470 }
471
472 static char *atomNames[] = {
473 "WM_STATE",
474 "WM_CHANGE_STATE",
475 "WM_PROTOCOLS",
476 "WM_TAKE_FOCUS",
477 "WM_DELETE_WINDOW",
478 "WM_SAVE_YOURSELF",
479 "WM_CLIENT_LEADER",
480 "WM_COLORMAP_WINDOWS",
481 "WM_COLORMAP_NOTIFY",
482
483 "_WINDOWMAKER_MENU",
484 "_WINDOWMAKER_STATE",
485 "_WINDOWMAKER_WM_PROTOCOLS",
486 "_WINDOWMAKER_WM_FUNCTION",
487 "_WINDOWMAKER_NOTICEBOARD",
488 "_WINDOWMAKER_COMMAND",
489 "_WINDOWMAKER_ICON_SIZE",
490 "_WINDOWMAKER_ICON_TILE",
491
492 GNUSTEP_WM_ATTR_NAME,
493 GNUSTEP_WM_MINIATURIZE_WINDOW,
494 GNUSTEP_TITLEBAR_STATE,
495
496 "WM_IGNORE_FOCUS_EVENTS"
497 };
498
499 /*
500 *----------------------------------------------------------
501 * StartUp--
502 * starts the window manager and setup global data.
503 * Called from main() at startup.
504 *
505 * Side effects:
506 * global data declared in main.c is initialized
507 *----------------------------------------------------------
508 */
509 void StartUp(Bool defaultScreenOnly)
510 {
511 struct sigaction sig_action;
512 int j, max, dummy;
513 Atom atom[sizeof(atomNames) / sizeof(char *)];
514
515 /*
516 * Ignore CapsLock in modifiers
517 */
518 ValidModMask = 0xff & ~LockMask;
519
520 getOffendingModifiers();
521 /*
522 * Ignore NumLock and ScrollLock too
523 */
524 ValidModMask &= ~(_NumLockMask | _ScrollLockMask);
525
526 memset(&wKeyBindings, 0, sizeof(wKeyBindings));
527
528 wWinContext = XUniqueContext();
529 wAppWinContext = XUniqueContext();
530 wStackContext = XUniqueContext();
531 wVEdgeContext = XUniqueContext();
532
533 /* _XA_VERSION = XInternAtom(dpy, "VERSION", False); */
534
535 #ifdef HAVE_XINTERNATOMS
536 XInternAtoms(dpy, atomNames, sizeof(atomNames) / sizeof(char *), False, atom);
537 #else
538
539 {
540 int i;
541 for (i = 0; i < sizeof(atomNames) / sizeof(char *); i++) {
542 atom[i] = XInternAtom(dpy, atomNames[i], False);
543 }
544 }
545 #endif
546
547 _XA_WM_STATE = atom[0];
548 _XA_WM_CHANGE_STATE = atom[1];
549 _XA_WM_PROTOCOLS = atom[2];
550 _XA_WM_TAKE_FOCUS = atom[3];
551 _XA_WM_DELETE_WINDOW = atom[4];
552 _XA_WM_SAVE_YOURSELF = atom[5];
553 _XA_WM_CLIENT_LEADER = atom[6];
554 _XA_WM_COLORMAP_WINDOWS = atom[7];
555 _XA_WM_COLORMAP_NOTIFY = atom[8];
556
557 _XA_WINDOWMAKER_MENU = atom[9];
558 _XA_WINDOWMAKER_STATE = atom[10];
559 _XA_WINDOWMAKER_WM_PROTOCOLS = atom[11];
560 _XA_WINDOWMAKER_WM_FUNCTION = atom[12];
561 _XA_WINDOWMAKER_NOTICEBOARD = atom[13];
562 _XA_WINDOWMAKER_COMMAND = atom[14];
563 _XA_WINDOWMAKER_ICON_SIZE = atom[15];
564 _XA_WINDOWMAKER_ICON_TILE = atom[16];
565
566 _XA_GNUSTEP_WM_ATTR = atom[17];
567 _XA_GNUSTEP_WM_MINIATURIZE_WINDOW = atom[18];
568 _XA_GNUSTEP_TITLEBAR_STATE = atom[19];
569
570 _XA_WM_IGNORE_FOCUS_EVENTS = atom[20];
571
572 #ifdef XDND
573 wXDNDInitializeAtoms();
574 #endif
575
576 /* cursors */
577 wCursor[WCUR_NORMAL] = None; /* inherit from root */
578 wCursor[WCUR_ROOT] = XCreateFontCursor(dpy, XC_left_ptr);
579 wCursor[WCUR_ARROW] = XCreateFontCursor(dpy, XC_top_left_arrow);
580 wCursor[WCUR_MOVE] = XCreateFontCursor(dpy, XC_fleur);
581 wCursor[WCUR_RESIZE] = XCreateFontCursor(dpy, XC_sizing);
582 wCursor[WCUR_TOPLEFTRESIZE] = XCreateFontCursor(dpy, XC_top_left_corner);
583 wCursor[WCUR_TOPRIGHTRESIZE] = XCreateFontCursor(dpy, XC_top_right_corner);
584 wCursor[WCUR_BOTTOMLEFTRESIZE] = XCreateFontCursor(dpy, XC_bottom_left_corner);
585 wCursor[WCUR_BOTTOMRIGHTRESIZE] = XCreateFontCursor(dpy, XC_bottom_right_corner);
586 wCursor[WCUR_VERTICALRESIZE] = XCreateFontCursor(dpy, XC_sb_v_double_arrow);
587 wCursor[WCUR_HORIZONRESIZE] = XCreateFontCursor(dpy, XC_sb_h_double_arrow);
588 wCursor[WCUR_WAIT] = XCreateFontCursor(dpy, XC_watch);
589 wCursor[WCUR_QUESTION] = XCreateFontCursor(dpy, XC_question_arrow);
590 wCursor[WCUR_TEXT] = XCreateFontCursor(dpy, XC_xterm); /* odd name??? */
591 wCursor[WCUR_SELECT] = XCreateFontCursor(dpy, XC_cross);
592 {
593 Pixmap cur = XCreatePixmap(dpy, DefaultRootWindow(dpy), 16, 16, 1);
594 GC gc = XCreateGC(dpy, cur, 0, NULL);
595 XColor black;
596 memset(&black, 0, sizeof(XColor));
597 XSetForeground(dpy, gc, 0);
598 XFillRectangle(dpy, cur, gc, 0, 0, 16, 16);
599 XFreeGC(dpy, gc);
600 wCursor[WCUR_EMPTY] = XCreatePixmapCursor(dpy, cur, cur, &black, &black, 0, 0);
601 XFreePixmap(dpy, cur);
602 }
603
604 #ifndef HAVE_INOTIFY
605 /* signal handler stuff that gets called when a signal is caught */
606 WMAddPersistentTimerHandler(500, delayedAction, NULL);
607 #endif
608
609 /* emergency exit... */
610 sig_action.sa_handler = handleSig;
611 sigemptyset(&sig_action.sa_mask);
612
613 sig_action.sa_flags = SA_RESTART;
614 sigaction(SIGQUIT, &sig_action, NULL);
615 /* instead of catching these, we let the default handler abort the
616 * program. The new monitor process will take appropriate action
617 * when it detects the crash.
618 sigaction(SIGSEGV, &sig_action, NULL);
619 sigaction(SIGBUS, &sig_action, NULL);
620 sigaction(SIGFPE, &sig_action, NULL);
621 sigaction(SIGABRT, &sig_action, NULL);
622 */
623
624 sig_action.sa_handler = handleExitSig;
625
626 /* Here we set SA_RESTART for safety, because SIGUSR1 may not be handled
627 * immediately. -Dan */
628 sig_action.sa_flags = SA_RESTART;
629 sigaction(SIGTERM, &sig_action, NULL);
630 sigaction(SIGINT, &sig_action, NULL);
631 sigaction(SIGHUP, &sig_action, NULL);
632 sigaction(SIGUSR1, &sig_action, NULL);
633 sigaction(SIGUSR2, &sig_action, NULL);
634
635 /* ignore dead pipe */
636 /* Because POSIX mandates that only signal with handlers are reset
637 * accross an exec*(), we do not want to propagate ignoring SIGPIPEs
638 * to children. Hence the dummy handler.
639 * Philippe Troin <phil@fifi.org>
640 */
641 sig_action.sa_handler = &dummyHandler;
642 sig_action.sa_flags = SA_RESTART;
643 sigaction(SIGPIPE, &sig_action, NULL);
644
645 /* handle dead children */
646 sig_action.sa_handler = buryChild;
647 sig_action.sa_flags = SA_NOCLDSTOP | SA_RESTART;
648 sigaction(SIGCHLD, &sig_action, NULL);
649
650 /* Now we unblock all signals, that may have been blocked by the parent
651 * who exec()-ed us. This can happen for example if Window Maker crashes
652 * and restarts itself or another window manager from the signal handler.
653 * In this case, the new proccess inherits the blocked signal mask and
654 * will no longer react to that signal, until unblocked.
655 * This is because the signal handler of the proccess who crashed (parent)
656 * didn't return, and the signal remained blocked. -Dan
657 */
658 sigfillset(&sig_action.sa_mask);
659 sigprocmask(SIG_UNBLOCK, &sig_action.sa_mask, NULL);
660
661 /* handle X shutdowns a such */
662 XSetIOErrorHandler(handleXIO);
663
664 /* set hook for out event dispatcher in WINGs event dispatcher */
665 WMHookEventHandler(DispatchEvent);
666
667 /* initialize defaults stuff */
668 WDWindowMaker = wDefaultsInitDomain("WindowMaker", True);
669 if (!WDWindowMaker->dictionary) {
670 wwarning(_("could not read domain \"%s\" from defaults database"), "WindowMaker");
671 }
672
673 /* read defaults that don't change until a restart and are
674 * screen independent */
675 wReadStaticDefaults(WDWindowMaker ? WDWindowMaker->dictionary : NULL);
676
677 /* check sanity of some values */
678 if (wPreferences.icon_size < 16) {
679 wwarning(_("icon size is configured to %i, but it's too small. Using 16, instead\n"),
680 wPreferences.icon_size);
681 wPreferences.icon_size = 16;
682 }
683
684 /* init other domains */
685 WDRootMenu = wDefaultsInitDomain("WMRootMenu", False);
686 if (!WDRootMenu->dictionary) {
687 wwarning(_("could not read domain \"%s\" from defaults database"), "WMRootMenu");
688 }
689 wDefaultsMergeGlobalMenus(WDRootMenu);
690
691 WDWindowAttributes = wDefaultsInitDomain("WMWindowAttributes", True);
692 if (!WDWindowAttributes->dictionary) {
693 wwarning(_("could not read domain \"%s\" from defaults database"), "WMWindowAttributes");
694 }
695
696 XSetErrorHandler((XErrorHandler) catchXError);
697
698 #ifdef SHAPE
699 /* ignore j */
700 wShapeSupported = XShapeQueryExtension(dpy, &wShapeEventBase, &j);
701 #endif
702
703 #ifdef HAVE_XRANDR
704 has_randr = XRRQueryExtension(dpy, &randr_event_base, &dummy);
705 #else
706 has_randr = false;
707 #endif
708
709 #ifdef KEEP_XKB_LOCK_STATUS
710 wXkbSupported = XkbQueryExtension(dpy, NULL, &wXkbEventBase, NULL, NULL, NULL);
711 if (wPreferences.modelock && !wXkbSupported) {
712 wwarning(_("XKB is not supported. KbdModeLock is automatically disabled."));
713 wPreferences.modelock = 0;
714 }
715 #endif
716
717 if (defaultScreenOnly) {
718 max = 1;
719 } else {
720 max = ScreenCount(dpy);
721 }
722 wScreen = wmalloc(sizeof(WScreen *) * max);
723
724 wScreenCount = 0;
725
726 /* manage the screens */
727 for (j = 0; j < max; j++) {
728 if (defaultScreenOnly || max == 1) {
729 wScreen[wScreenCount] = wScreenInit(DefaultScreen(dpy));
730 if (!wScreen[wScreenCount]) {
731 wfatal(_("it seems that there is already a window manager running"));
732 Exit(1);
733 }
734 } else {
735 wScreen[wScreenCount] = wScreenInit(j);
736 if (!wScreen[wScreenCount]) {
737 wwarning(_("could not manage screen %i"), j);
738 continue;
739 }
740 }
741 wScreenCount++;
742 }
743
744 InitializeSwitchMenu();
745
746 /* initialize/restore state for the screens */
747 for (j = 0; j < wScreenCount; j++) {
748 int lastDesktop;
749
750 lastDesktop = wNETWMGetCurrentDesktopFromHint(wScreen[j]);
751
752 wScreenRestoreState(wScreen[j]);
753
754 /* manage all windows that were already here before us */
755 if (!wPreferences.flags.nodock && wScreen[j]->dock)
756 wScreen[j]->last_dock = wScreen[j]->dock;
757
758 manageAllWindows(wScreen[j], wPreferences.flags.restarting == 2);
759
760 /* restore saved menus */
761 wMenuRestoreState(wScreen[j]);
762
763 /* If we're not restarting, restore session */
764 if (wPreferences.flags.restarting == 0 && !wPreferences.flags.norestore)
765 wSessionRestoreState(wScreen[j]);
766
767 if (!wPreferences.flags.noautolaunch) {
768 /* auto-launch apps */
769 if (!wPreferences.flags.nodock && wScreen[j]->dock) {
770 wScreen[j]->last_dock = wScreen[j]->dock;
771 wDockDoAutoLaunch(wScreen[j]->dock, 0);
772 }
773 /* auto-launch apps in clip */
774 if (!wPreferences.flags.noclip) {
775 int i;
776 for (i = 0; i < wScreen[j]->workspace_count; i++) {
777 if (wScreen[j]->workspaces[i]->clip) {
778 wScreen[j]->last_dock = wScreen[j]->workspaces[i]->clip;
779 wDockDoAutoLaunch(wScreen[j]->workspaces[i]->clip, i);
780 }
781 }
782 }
783 }
784
785 /* go to workspace where we were before restart */
786 if (lastDesktop >= 0) {
787 wWorkspaceForceChange(wScreen[j], lastDesktop);
788 } else {
789 wSessionRestoreLastWorkspace(wScreen[j]);
790 }
791 }
792
793 if (wScreenCount == 0) {
794 wfatal(_("could not manage any screen"));
795 Exit(1);
796 }
797
798 #ifndef HAVE_INOTIFY
799 if (!wPreferences.flags.nopolling && !wPreferences.flags.noupdates) {
800 /* setup defaults file polling */
801 WMAddTimerHandler(3000, wDefaultsCheckDomains, NULL);
802 }
803 #endif
804
805 }
806
807 static Bool windowInList(Window window, Window * list, int count)
808 {
809 for (; count >= 0; count--) {
810 if (window == list[count])
811 return True;
812 }
813 return False;
814 }
815
816 /*
817 *-----------------------------------------------------------------------
818 * manageAllWindows--
819 * Manages all windows in the screen.
820 *
821 * Notes:
822 * Called when the wm is being started.
823 * No events can be processed while the windows are being
824 * reparented/managed.
825 *-----------------------------------------------------------------------
826 */
827 static void manageAllWindows(WScreen * scr, int crashRecovery)
828 {
829 Window root, parent;
830 Window *children;
831 unsigned int nchildren;
832 unsigned int i, j;
833 WWindow *wwin;
834
835 XGrabServer(dpy);
836 XQueryTree(dpy, scr->root_win, &root, &parent, &children, &nchildren);
837
838 scr->flags.startup = 1;
839
840 /* first remove all icon windows */
841 for (i = 0; i < nchildren; i++) {
842 XWMHints *wmhints;
843
844 if (children[i] == None)
845 continue;
846
847 wmhints = XGetWMHints(dpy, children[i]);
848 if (wmhints && (wmhints->flags & IconWindowHint)) {
849 for (j = 0; j < nchildren; j++) {
850 if (children[j] == wmhints->icon_window) {
851 XFree(wmhints);
852 wmhints = NULL;
853 children[j] = None;
854 break;
855 }
856 }
857 }
858 if (wmhints) {
859 XFree(wmhints);
860 }
861 }
862
863 for (i = 0; i < nchildren; i++) {
864 if (children[i] == None)
865 continue;
866
867 wwin = wManageWindow(scr, children[i]);
868 if (wwin) {
869 /* apply states got from WSavedState */
870 /* shaded + minimized is not restored correctly */
871 if (wwin->flags.shaded) {
872 wwin->flags.shaded = 0;
873 wShadeWindow(wwin);
874 }
875 if (wwin->flags.miniaturized
876 && (wwin->transient_for == None
877 || wwin->transient_for == scr->root_win
878 || !windowInList(wwin->transient_for, children, nchildren))) {
879
880 wwin->flags.skip_next_animation = 1;
881 wwin->flags.miniaturized = 0;
882 wIconifyWindow(wwin);
883 } else {
884 wClientSetState(wwin, NormalState, None);
885 }
886 if (crashRecovery) {
887 int border;
888
889 border = (!HAS_BORDER(wwin) ? 0 : FRAME_BORDER_WIDTH);
890
891 wWindowMove(wwin, wwin->frame_x - border,
892 wwin->frame_y - border -
893 (wwin->frame->titlebar ? wwin->frame->titlebar->height : 0));
894 }
895 }
896 }
897 XUngrabServer(dpy);
898
899 /* hide apps */
900 wwin = scr->focused_window;
901 while (wwin) {
902 if (wwin->flags.hidden) {
903 WApplication *wapp = wApplicationOf(wwin->main_window);
904
905 if (wapp) {
906 wwin->flags.hidden = 0;
907 wHideApplication(wapp);
908 } else {
909 wwin->flags.hidden = 0;
910 }
911 }
912 wwin = wwin->prev;
913 }
914
915 XFree(children);
916 scr->flags.startup = 0;
917 scr->flags.startup2 = 1;
918
919 while (XPending(dpy)) {
920 XEvent ev;
921 WMNextEvent(dpy, &ev);
922 WMHandleEvent(&ev);
923 }
924 wWorkspaceForceChange(scr, 0);
925 if (!wPreferences.flags.noclip)
926 wDockShowIcons(scr->workspaces[scr->current_workspace]->clip);
927 scr->flags.startup2 = 0;
928 }