src/startup.c

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