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