src/startup.c

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