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