src/startup.c

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