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