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