src/startup.c

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