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