src/startup.c

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