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