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