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