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