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