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