src/startup.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   5  *  Copyright (c) 1999       Dan Pascu
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23 #include "wconfig.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <unistd.h>
  28 #include <signal.h>
  29 #include <sys/wait.h>
  30 #ifdef __FreeBSD__
  31 #include <sys/signal.h>
  32 #endif
  33
  34 #include <X11/Xlib.h>
  35 #include <X11/Xutil.h>
  36 #include <X11/Intrinsic.h>
  37 #include <X11/cursorfont.h>
  38 #include <X11/Xproto.h>
  39 #include <X11/keysym.h>
  40 #ifdef SHAPE
  41 #include <X11/extensions/shape.h>
  42 #endif
  43
  44 #include "WindowMaker.h"
  45 #include "GNUstep.h"
  46 #include "texture.h"
  47 #include "screen.h"
  48 #include "window.h"
  49 #include "actions.h"
  50 #include "client.h"
  51 #include "funcs.h"
  52 #include "dock.h"
  53 #include "workspace.h"
  54 #include "keybind.h"
  55 #include "framewin.h"
  56 #include "session.h"
  57 #include "defaults.h"
  58 #include "properties.h"
  59
  60 #include "xutil.h"
  61
  62 #ifdef KWM_HINTS
  63 #include "kwm.h"
  64 #endif
  65
  66 #if 0
  67 #ifdef SYS_SIGLIST_DECLARED
  68 extern const char * const sys_siglist[];
  69 #endif
  70 #endif
  71
  72 /* for SunOS */
  73 #ifndef SA_RESTART
  74 # define SA_RESTART 0
  75 #endif
  76
  77
  78 /****** Global Variables ******/
  79
  80 extern char **Arguments;
  81
  82 extern WPreferences wPreferences;
  83
  84 extern WDDomain *WDWindowMaker;
  85 extern WDDomain *WDRootMenu;
  86 extern WDDomain *WDWindowAttributes;
  87
  88 extern WShortKey wKeyBindings[WKBD_LAST];
  89
  90 extern int wScreenCount;
  91
  92
  93 #ifdef SHAPE
  94 extern Bool wShapeSupported;
  95 extern int wShapeEventBase;
  96 #endif
  97
  98 /* contexts */
  99 extern XContext wWinContext;
 100 extern XContext wAppWinContext;
 101 extern XContext wStackContext;
 102
 103 /* atoms */
 104 extern Atom _XA_WM_STATE;
 105 extern Atom _XA_WM_CHANGE_STATE;
 106 extern Atom _XA_WM_PROTOCOLS;
 107 extern Atom _XA_WM_TAKE_FOCUS;
 108 extern Atom _XA_WM_DELETE_WINDOW;
 109 extern Atom _XA_WM_SAVE_YOURSELF;
 110 extern Atom _XA_WM_CLIENT_LEADER;
 111 extern Atom _XA_WM_COLORMAP_WINDOWS;
 112 extern Atom _XA_WM_COLORMAP_NOTIFY;
 113
 114 extern Atom _XA_GNUSTEP_WM_ATTR;
 115
 116 extern Atom _XA_WINDOWMAKER_MENU;
 117 extern Atom _XA_WINDOWMAKER_WM_PROTOCOLS;
 118 extern Atom _XA_WINDOWMAKER_STATE;
 119 extern Atom _XA_WINDOWMAKER_WM_FUNCTION;
 120 extern Atom _XA_WINDOWMAKER_NOTICEBOARD;
 121 extern Atom _XA_WINDOWMAKER_COMMAND;
 122
 123 extern Atom _XA_GNUSTEP_WM_MINIATURIZE_WINDOW;
 124
 125 #ifdef OFFIX_DND
 126 extern Atom _XA_DND_PROTOCOL;
 127 extern Atom _XA_DND_SELECTION;
 128 #endif
 129 #ifdef XDE_DND
 130 extern Atom _XA_XDE_REQUEST;
 131 extern Atom _XA_XDE_ENTER;
 132 extern Atom _XA_XDE_LEAVE;
 133 extern Atom _XA_XDE_DATA_AVAILABLE;
 134 extern Atom _XDE_FILETYPE;
 135 extern Atom _XDE_URLTYPE;
 136 #endif
 137
 138
 139 /* cursors */
 140 extern Cursor wCursor[WCUR_LAST];
 141
 142 /* special flags */
 143 extern char WDelayedActionSet;
 144
 145 /***** Local *****/
 146
 147 static WScreen **wScreen = NULL;
 148
 149
 150 static unsigned int _NumLockMask = 0;
 151 static unsigned int _ScrollLockMask = 0;
 152
 153
 154
 155 static void manageAllWindows();
 156
 157 extern void NotifyDeadProcess(pid_t pid, unsigned char status);
 158
 159
 160 typedef struct _CrashPanel {
 161     WMWindow *win;              /* main window */
 162
 163       WMLabel *iconL;           /* application icon */
 164       WMLabel *nameL;           /* title of panel */
 165
 166       WMFrame *sepF;            /* separator frame */
 167
 168       WMLabel *noteL;           /* Title of note */
 169       WMLabel *note2L;          /* body of note with what happened */
 170
 171       WMFrame *whatF;           /* "what to do next" frame */
 172         WMPopUpButton *whatP;   /* action selection popup button */
 173
 174       WMButton *okB;            /* ok button */
 175
 176     Bool done;                  /* if finished with this dialog */
 177     int action;                 /* what to do after */
 178
 179     KeyCode retKey;
 180
 181 } CrashPanel;
 182
 183
 184 enum {
 185     WMAbort=0,
 186     WMRestart,
 187     WMStartAlternate
 188 };
 189
 190
 191 static void
 192 handleKeyPress(XEvent *event, void *clientData)
 193 {
 194     CrashPanel *panel = (CrashPanel*)clientData;
 195
 196     if (event->xkey.keycode == panel->retKey) {
 197         WMPerformButtonClick(panel->okB);
 198     }
 199 }
 200
 201
 202 static void
 203 buttonCallback(void *self, void *clientData)
 204 {
 205     CrashPanel *panel = (CrashPanel*)clientData;
 206
 207     panel->done = True;
 208 }
 209
 210
 211 static void
 212 setAction(void *self, void *clientData)
 213 {
 214     WMPopUpButton *pop = (WMPopUpButton*)self;
 215     CrashPanel *panel = (CrashPanel*)clientData;
 216
 217     panel->action = WMGetPopUpButtonSelectedItem(pop);
 218 }
 219
 220
 221 static WMPixmap*
 222 getWindowMakerIconImage(WMScreen *scr)
 223 {
 224     proplist_t dict, key, option, value=NULL;
 225     WMPixmap *pix=NULL;
 226     char *path;
 227
 228     PLSetStringCmpHook(NULL);
 229
 230     key = PLMakeString("Logo.WMPanel");
 231     option = PLMakeString("Icon");
 232
 233     dict = PLGetDictionaryEntry(WDWindowAttributes->dictionary, key);
 234
 235     if (dict) {
 236         value = PLGetDictionaryEntry(dict, option);
 237     }
 238
 239     PLRelease(key);
 240     PLRelease(option);
 241
 242     PLSetStringCmpHook(StringCompareHook);
 243
 244     if (value && PLIsString(value)) {
 245         path = FindImage(wPreferences.icon_path, PLGetString(value));
 246
 247         if (path) {
 248             RImage *image;
 249
 250             image = RLoadImage(WMScreenRContext(scr), path, 0);
 251             if (image) {
 252                 pix = WMCreatePixmapFromRImage(scr, image, 0);
 253                 RDestroyImage(image);
 254             }
 255             free(path);
 256         }
 257     }
 258
 259     return pix;
 260 }
 261
 262
 263 #define PWIDTH  295
 264 #define PHEIGHT 345
 265
 266
 267 static int
 268 showCrashPanel(int whatSig)
 269 {
 270     CrashPanel *panel;
 271     WMScreen *scr;
 272     WMFont *font;
 273     WMPixmap *logo;
 274     Display *newdpy;
 275     int screen_no, scr_width, scr_height;
 276     int action;
 277     char buf[256];
 278
 279     panel = wmalloc(sizeof(CrashPanel));
 280     memset(panel, 0, sizeof(CrashPanel));
 281
 282     /* Close the X connection and open a new one. This is to avoid messing
 283      * Xlib because we call to Xlib functions in a signal handler.
 284      */
 285     XCloseDisplay(dpy);
 286     newdpy = XOpenDisplay("");
 287     if (!newdpy) {
 288         wfatal(_("cannot open connection for crashing dialog panel. Aborting."));
 289         return WMAbort;
 290     }
 291
 292     screen_no = DefaultScreen(newdpy);
 293     scr_width = WidthOfScreen(ScreenOfDisplay(newdpy, screen_no));
 294     scr_height = HeightOfScreen(ScreenOfDisplay(newdpy, screen_no));
 295
 296     scr = WMCreateScreen(newdpy, screen_no);
 297     if (!scr) {
 298         wfatal(_("cannot open connection for crashing dialog panel. Aborting."));
 299         return WMAbort;
 300     }
 301
 302     panel->retKey = XKeysymToKeycode(newdpy, XK_Return);
 303
 304     panel->win = WMCreateWindow(scr, "crashingDialog");
 305     WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
 306     WMMoveWidget(panel->win, (scr_width - PWIDTH)/2, (scr_height - PHEIGHT)/2);
 307
 308     logo = getWindowMakerIconImage(scr);
 309     if (logo) {
 310         panel->iconL = WMCreateLabel(panel->win);
 311         WMResizeWidget(panel->iconL, 64, 64);
 312         WMMoveWidget(panel->iconL, 10, 10);
 313         WMSetLabelImagePosition(panel->iconL, WIPImageOnly);
 314         WMSetLabelImage(panel->iconL, logo);
 315     }
 316
 317     panel->nameL = WMCreateLabel(panel->win);
 318     WMResizeWidget(panel->nameL, 190, 18);
 319     WMMoveWidget(panel->nameL, 80, 35);
 320     WMSetLabelTextAlignment(panel->nameL, WALeft);
 321     font = WMBoldSystemFontOfSize(scr, 18);
 322     WMSetLabelFont(panel->nameL, font);
 323     WMReleaseFont(font);
 324     WMSetLabelText(panel->nameL, _("Fatal error"));
 325
 326     panel->sepF = WMCreateFrame(panel->win);
 327     WMResizeWidget(panel->sepF, PWIDTH+4, 2);
 328     WMMoveWidget(panel->sepF, -2, 80);
 329
 330     panel->noteL = WMCreateLabel(panel->win);
 331     WMResizeWidget(panel->noteL, PWIDTH-20, 40);
 332     WMMoveWidget(panel->noteL, 10, 90);
 333     WMSetLabelTextAlignment(panel->noteL, WAJustified);
 334 #ifdef SYS_SIGLIST_DECLARED
 335     sprintf(buf, _("Window Maker received signal %i\n(%s)."),
 336             whatSig, sys_siglist[whatSig]);
 337 #else
 338     sprintf(buf, _("Window Maker received signal %i."), whatSig);
 339 #endif
 340     WMSetLabelText(panel->noteL, buf);
 341
 342     panel->note2L = WMCreateLabel(panel->win);
 343     WMResizeWidget(panel->note2L, PWIDTH-20, 100);
 344     WMMoveWidget(panel->note2L, 10, 130);
 345     WMSetLabelTextAlignment(panel->note2L, WALeft);
 346     WMSetLabelText(panel->note2L,
 347                    _(" This fatal error occured probably due to a bug."
 348                    " Please fill the included BUGFORM and "
 349                    "report it to bugs@windowmaker.org."));
 350
 351
 352     panel->whatF = WMCreateFrame(panel->win);
 353     WMResizeWidget(panel->whatF, PWIDTH-20, 50);
 354     WMMoveWidget(panel->whatF, 10, 240);
 355     WMSetFrameTitle(panel->whatF, _("What do you want to do now?"));
 356
 357     panel->whatP = WMCreatePopUpButton(panel->whatF);
 358     WMResizeWidget(panel->whatP, PWIDTH-20-70, 20);
 359     WMMoveWidget(panel->whatP, 35, 20);
 360     WMSetPopUpButtonPullsDown(panel->whatP, False);
 361     WMSetPopUpButtonText(panel->whatP, _("Select action"));
 362     WMAddPopUpButtonItem(panel->whatP, _("Abort and leave a core file"));
 363     WMAddPopUpButtonItem(panel->whatP, _("Restart Window Maker"));
 364     WMAddPopUpButtonItem(panel->whatP, _("Start alternate window manager"));
 365     WMSetPopUpButtonAction(panel->whatP, setAction, panel);
 366     WMSetPopUpButtonSelectedItem(panel->whatP, WMRestart);
 367     panel->action = WMRestart;
 368
 369     WMMapSubwidgets(panel->whatF);
 370
 371     panel->okB = WMCreateCommandButton(panel->win);
 372     WMResizeWidget(panel->okB, 80, 26);
 373     WMMoveWidget(panel->okB, 205, 309);
 374     WMSetButtonText(panel->okB, _("OK"));
 375     WMSetButtonImage(panel->okB, WMGetSystemPixmap(scr, WSIReturnArrow));
 376     WMSetButtonAltImage(panel->okB, WMGetSystemPixmap(scr, WSIHighlightedReturnArrow));
 377     WMSetButtonImagePosition(panel->okB, WIPRight);
 378     WMSetButtonAction(panel->okB, buttonCallback, panel);
 379
 380     panel->done = 0;
 381
 382     WMCreateEventHandler(WMWidgetView(panel->win), KeyPressMask,
 383                          handleKeyPress, panel);
 384
 385     WMRealizeWidget(panel->win);
 386     WMMapSubwidgets(panel->win);
 387
 388     WMMapWidget(panel->win);
 389
 390     XSetInputFocus(newdpy, WMWidgetXID(panel->win), RevertToParent, CurrentTime);
 391
 392     while (!panel->done) {
 393         XEvent event;
 394
 395         WMNextEvent(newdpy, &event);
 396         WMHandleEvent(&event);
 397     }
 398
 399     action = panel->action;
 400
 401     WMUnmapWidget(panel->win);
 402     WMDestroyWidget(panel->win);
 403     free(panel);
 404     XCloseDisplay(newdpy);
 405
 406     return action;
 407 }
 408
 409
 410 static int
 411 catchXError(Display *dpy, XErrorEvent *error)
 412 {
 413     char buffer[MAXLINE];
 414
 415     /* ignore some errors */
 416     if (error->resourceid != None
 417         && ((error->error_code == BadDrawable
 418              && error->request_code == X_GetGeometry)
 419             || (error->error_code == BadMatch
 420                 && (error->request_code == X_SetInputFocus))
 421             || (error->error_code == BadWindow)
 422             /*
 423                 && (error->request_code == X_GetWindowAttributes
 424                     || error->request_code == X_SetInputFocus
 425                     || error->request_code == X_ChangeWindowAttributes
 426                     || error->request_code == X_GetProperty
 427                     || error->request_code == X_ChangeProperty
 428                     || error->request_code == X_QueryTree
 429                     || error->request_code == X_GrabButton
 430                     || error->request_code == X_UngrabButton
 431                     || error->request_code == X_SendEvent
 432                     || error->request_code == X_ConfigureWindow))
 433              */
 434             || (error->request_code == X_InstallColormap))) {
 435 #ifndef DEBUG
 436
 437         return 0;
 438 #else
 439         printf("got X error %x %x %x\n", error->request_code,
 440                error->error_code, (unsigned)error->resourceid);
 441         return 0;
 442 #endif
 443     }
 444     FormatXError(dpy, error, buffer, MAXLINE);
 445     wwarning(_("internal X error: %s\n"), buffer);
 446     return -1;
 447 }
 448
 449
 450 /*
 451  *----------------------------------------------------------------------
 452  * handleXIO-
 453  *      Handle X shutdowns and other stuff.
 454  *----------------------------------------------------------------------
 455  */
 456 static int
 457 handleXIO(Display *dpy)
 458 {
 459     dpy = NULL;
 460     Exit(0);
 461     return 0;
 462 }
 463
 464
 465 /*
 466  *----------------------------------------------------------------------
 467  * delayedAction-
 468  *      Action to be executed after the signal() handler is exited.
 469  *----------------------------------------------------------------------
 470  */
 471 static void
 472 delayedAction(void *cdata)
 473 {
 474     WDelayedActionSet = 0;
 475     /*
 476      * Make the event dispatcher do whatever it needs to do,
 477      * including handling zombie processes, restart and exit
 478      * signals.
 479      */
 480     DispatchEvent(NULL);
 481 }
 482
 483
 484
 485 /*
 486  *----------------------------------------------------------------------
 487  * handleSig--
 488  *      general signal handler. Exits the program gently.
 489  *----------------------------------------------------------------------
 490  */
 491 static RETSIGTYPE
 492 handleSig(int sig)
 493 {
 494     static int already_crashed = 0;
 495     int dumpcore = 0;
 496 #ifndef NO_EMERGENCY_AUTORESTART
 497     int crashAction;
 498     char *argv[2];
 499
 500     argv[1] = NULL;
 501 #endif
 502
 503     /*
 504      * No functions that potentially do Xlib calls should be called from
 505      * here. Xlib calls are not reentrant so the integrity of Xlib is
 506      * not guaranteed if a Xlib call is made from a signal handler.
 507      */
 508     if (sig == SIGUSR1) {
 509 #ifdef SYS_SIGLIST_DECLARED
 510         wwarning(_("got signal %i (%s) - restarting\n"), sig, sys_siglist[sig]);
 511 #else
 512         wwarning(_("got signal %i - restarting\n"), sig);
 513 #endif
 514
 515         WCHANGE_STATE(WSTATE_NEED_RESTART);
 516         /* setup idle handler, so that this will be handled when
 517          * the select() is returned becaused of the signal, even if
 518          * there are no X events in the queue */
 519         if (!WDelayedActionSet) {
 520             WDelayedActionSet = 1;
 521             WMAddIdleHandler(delayedAction, NULL);
 522         }
 523         return;
 524     } else if (sig == SIGTERM || sig == SIGHUP) {
 525 #ifdef SYS_SIGLIST_DECLARED
 526         wwarning(_("got signal %i (%s) - exiting...\n"), sig, sys_siglist[sig]);
 527 #else
 528         wwarning(_("got signal %i - exiting...\n"), sig);
 529 #endif
 530
 531         WCHANGE_STATE(WSTATE_NEED_EXIT);
 532
 533         if (!WDelayedActionSet) {
 534             WDelayedActionSet = 1;
 535             WMAddIdleHandler(delayedAction, NULL);
 536         }
 537         return;
 538     }
 539
 540 #ifdef SYS_SIGLIST_DECLARED
 541     wfatal(_("got signal %i (%s)\n"), sig, sys_siglist[sig]);
 542 #else
 543     wfatal(_("got signal %i\n"), sig);
 544 #endif
 545
 546     /* Setting the signal behaviour back to default and then reraising the
 547      * signal is a cleaner way to make program exit and core dump than calling
 548      * abort(), since it correctly returns from the signal handler and sets
 549      * the flags accordingly. -Dan
 550      */
 551     if (sig==SIGSEGV || sig==SIGFPE || sig==SIGBUS || sig==SIGILL
 552         || sig==SIGABRT) {
 553         if (already_crashed) {
 554             wfatal(_("crashed while trying to do some post-crash cleanup. Aborting immediatelly."));
 555             signal(sig, SIG_DFL);
 556             raise(sig);
 557             return;
 558         }
 559         already_crashed = 1;
 560
 561         dumpcore = 1;
 562
 563 #ifndef NO_EMERGENCY_AUTORESTART
 564         crashAction = showCrashPanel(sig);
 565
 566         if (crashAction == WMAbort) {
 567             signal(sig, SIG_DFL);
 568             raise(sig);
 569             return;
 570         }
 571
 572         if (crashAction == WMRestart) {
 573             /* we try to restart Window Maker */
 574             wwarning(_("trying to restart Window Maker..."));
 575             execvp(Arguments[0], Arguments);
 576             wwarning(_("we failed to restart Window Maker."));
 577             /* fallback to alternate window manager then */
 578         }
 579
 580         wwarning(_("trying to start alternate window manager..."));
 581
 582         argv[0] = FALLBACK_WINDOWMANAGER;
 583         execvp(FALLBACK_WINDOWMANAGER, argv);
 584
 585         argv[0] = "fvwm";
 586         execvp("fvwm", argv);
 587
 588         argv[0] = "twm";
 589         execvp("twm", argv);
 590
 591         wfatal(_("failed to start alternate window manager. Aborting."));
 592 #else
 593         wfatal(_("a fatal error has occured, probably due to a bug. "
 594                  "Please fill the included BUGFORM and report it."));
 595 #endif /* !NO_EMERGENCY_AUTORESTART */
 596
 597         signal(sig, SIG_DFL);
 598         raise(sig);
 599         return;
 600
 601     }
 602
 603     wAbort(dumpcore);
 604 }
 605
 606
 607 static RETSIGTYPE
 608 ignoreSig(int signal)
 609 {
 610     return;
 611 }
 612
 613
 614 static RETSIGTYPE
 615 buryChild(int foo)
 616 {
 617     pid_t pid;
 618     int status;
 619
 620     /* R.I.P. */
 621     pid = waitpid(-1, &status, WNOHANG);
 622     if (pid>0) {
 623         NotifyDeadProcess(pid, WEXITSTATUS(status));
 624         /*
 625          * Make sure that the kid will be buried even if there are
 626          * no events in the X event queue
 627          */
 628         if (!WDelayedActionSet) {
 629             WDelayedActionSet = 1;
 630             WMAddIdleHandler(delayedAction, NULL);
 631         }
 632     }
 633 }
 634
 635
 636 static int
 637 getWorkspaceState(Window root, WWorkspaceState **state)
 638 {
 639     Atom type_ret;
 640     int fmt_ret;
 641     unsigned long nitems_ret;
 642     unsigned long bytes_after_ret;
 643     CARD32 *data;
 644
 645     if (XGetWindowProperty(dpy, root, _XA_WINDOWMAKER_STATE, 0, 2,
 646                            True, _XA_WINDOWMAKER_STATE,
 647                            &type_ret, &fmt_ret, &nitems_ret, &bytes_after_ret,
 648                            (unsigned char **)&data)!=Success || !data)
 649       return 0;
 650
 651     *state = malloc(sizeof(WWorkspaceState));
 652     if (*state) {
 653         (*state)->flags = data[0];
 654         (*state)->workspace = data[1];
 655     }
 656     XFree(data);
 657
 658     if (*state && type_ret==_XA_WINDOWMAKER_STATE)
 659       return 1;
 660     else
 661       return 0;
 662 }
 663
 664
 665 static void
 666 getOffendingModifiers()
 667 {
 668     int i;
 669     XModifierKeymap *modmap;
 670     KeyCode nlock, slock;
 671     static int mask_table[8] = {
 672         ShiftMask,LockMask,ControlMask,Mod1Mask,
 673             Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
 674     };
 675
 676     nlock = XKeysymToKeycode(dpy, XK_Num_Lock);
 677     slock = XKeysymToKeycode(dpy, XK_Scroll_Lock);
 678
 679     /*
 680      * Find out the masks for the NumLock and ScrollLock modifiers,
 681      * so that we can bind the grabs for when they are enabled too.
 682      */
 683     modmap = XGetModifierMapping(dpy);
 684
 685     if (modmap!=NULL && modmap->max_keypermod>0) {
 686         for (i=0; i<8*modmap->max_keypermod; i++) {
 687             if (modmap->modifiermap[i]==nlock && nlock!=0)
 688                 _NumLockMask = mask_table[i/modmap->max_keypermod];
 689             else if (modmap->modifiermap[i]==slock && slock!=0)
 690                 _ScrollLockMask = mask_table[i/modmap->max_keypermod];
 691         }
 692     }
 693
 694     if (modmap)
 695         XFreeModifiermap(modmap);
 696 }
 697
 698
 699
 700 #ifdef NUMLOCK_HACK
 701 void
 702 wHackedGrabKey(int keycode, unsigned int modifiers,
 703                Window grab_window, Bool owner_events, int pointer_mode,
 704                int keyboard_mode)
 705 {
 706     if (modifiers == AnyModifier)
 707         return;
 708
 709     /* grab all combinations of the modifier with CapsLock, NumLock and
 710      * ScrollLock. How much memory/CPU does such a monstrosity consume
 711      * in the server?
 712      */
 713     if (_NumLockMask)
 714         XGrabKey(dpy, keycode, modifiers|_NumLockMask,
 715                  grab_window, owner_events, pointer_mode, keyboard_mode);
 716     if (_ScrollLockMask)
 717         XGrabKey(dpy, keycode, modifiers|_ScrollLockMask,
 718                  grab_window, owner_events, pointer_mode, keyboard_mode);
 719     if (_NumLockMask && _ScrollLockMask)
 720         XGrabKey(dpy, keycode, modifiers|_NumLockMask|_ScrollLockMask,
 721                  grab_window, owner_events, pointer_mode, keyboard_mode);
 722     if (_NumLockMask)
 723         XGrabKey(dpy, keycode, modifiers|_NumLockMask|LockMask,
 724                  grab_window, owner_events, pointer_mode, keyboard_mode);
 725     if (_ScrollLockMask)
 726         XGrabKey(dpy, keycode, modifiers|_ScrollLockMask|LockMask,
 727                  grab_window, owner_events, pointer_mode, keyboard_mode);
 728     if (_NumLockMask && _ScrollLockMask)
 729         XGrabKey(dpy, keycode, modifiers|_NumLockMask|_ScrollLockMask|LockMask,
 730                  grab_window, owner_events, pointer_mode, keyboard_mode);
 731     /* phew, I guess that's all, right? */
 732 }
 733 #endif
 734
 735 void
 736 wHackedGrabButton(unsigned int button, unsigned int modifiers,
 737                   Window grab_window, Bool owner_events,
 738                   unsigned int event_mask, int pointer_mode,
 739                   int keyboard_mode, Window confine_to, Cursor cursor)
 740 {
 741     XGrabButton(dpy, button, modifiers, grab_window, owner_events,
 742                 event_mask, pointer_mode, keyboard_mode, confine_to, cursor);
 743
 744     if (modifiers==AnyModifier)
 745         return;
 746
 747     XGrabButton(dpy, button, modifiers|LockMask, grab_window, owner_events,
 748                 event_mask, pointer_mode, keyboard_mode, confine_to, cursor);
 749
 750 #ifdef NUMLOCK_HACK
 751     /* same as above, but for mouse buttons */
 752     if (_NumLockMask)
 753         XGrabButton(dpy, button, modifiers|_NumLockMask,
 754                     grab_window, owner_events, event_mask, pointer_mode,
 755                 keyboard_mode, confine_to, cursor);
 756     if (_ScrollLockMask)
 757         XGrabButton(dpy, button, modifiers|_ScrollLockMask,
 758                     grab_window, owner_events, event_mask, pointer_mode,
 759                     keyboard_mode, confine_to, cursor);
 760     if (_NumLockMask && _ScrollLockMask)
 761         XGrabButton(dpy, button, modifiers|_ScrollLockMask|_NumLockMask,
 762                     grab_window, owner_events, event_mask, pointer_mode,
 763                     keyboard_mode, confine_to, cursor);
 764     if (_NumLockMask)
 765         XGrabButton(dpy, button, modifiers|_NumLockMask|LockMask,
 766                     grab_window, owner_events, event_mask, pointer_mode,
 767                 keyboard_mode, confine_to, cursor);
 768     if (_ScrollLockMask)
 769         XGrabButton(dpy, button, modifiers|_ScrollLockMask|LockMask,
 770                     grab_window, owner_events, event_mask, pointer_mode,
 771                     keyboard_mode, confine_to, cursor);
 772     if (_NumLockMask && _ScrollLockMask)
 773         XGrabButton(dpy, button, modifiers|_ScrollLockMask|_NumLockMask|LockMask,
 774                     grab_window, owner_events, event_mask, pointer_mode,
 775                     keyboard_mode, confine_to, cursor);
 776 #endif /* NUMLOCK_HACK */
 777 }
 778
 779 #ifdef notused
 780 void
 781 wHackedUngrabButton(unsigned int button, unsigned int modifiers,
 782                     Window grab_window)
 783 {
 784     XUngrabButton(dpy, button, modifiers|_NumLockMask,
 785                   grab_window);
 786     XUngrabButton(dpy, button, modifiers|_ScrollLockMask,
 787                   grab_window);
 788     XUngrabButton(dpy, button, modifiers|_NumLockMask|_ScrollLockMask,
 789                   grab_window);
 790     XUngrabButton(dpy, button, modifiers|_NumLockMask|LockMask,
 791                   grab_window);
 792     XUngrabButton(dpy, button, modifiers|_ScrollLockMask|LockMask,
 793                   grab_window);
 794     XUngrabButton(dpy, button, modifiers|_NumLockMask|_ScrollLockMask|LockMask,
 795                   grab_window);
 796 }
 797 #endif
 798
 799
 800
 801 WScreen*
 802 wScreenWithNumber(int i)
 803 {
 804     assert(i < wScreenCount);
 805
 806     return wScreen[i];
 807 }
 808
 809
 810 WScreen*
 811 wScreenForRootWindow(Window window)
 812 {
 813     int i;
 814
 815     if (wScreenCount==1)
 816         return wScreen[0];
 817
 818     /*
 819      * Since the number of heads will probably be small (normally 2),
 820      * it should be faster to use this than a hash table, because
 821      * of the overhead.
 822      */
 823     for (i=0; i<wScreenCount; i++) {
 824         if (wScreen[i]->root_win == window) {
 825             return wScreen[i];
 826         }
 827     }
 828
 829     assert("bad_root_window" && 0);
 830
 831     return NULL;
 832 }
 833
 834
 835 WScreen*
 836 wScreenSearchForRootWindow(Window window)
 837 {
 838     int i;
 839
 840     if (wScreenCount==1)
 841         return wScreen[0];
 842
 843     /*
 844      * Since the number of heads will probably be small (normally 2),
 845      * it should be faster to use this than a hash table, because
 846      * of the overhead.
 847      */
 848     for (i=0; i<wScreenCount; i++) {
 849         if (wScreen[i]->root_win == window) {
 850             return wScreen[i];
 851         }
 852     }
 853
 854     return NULL;
 855 }
 856
 857
 858 WScreen*
 859 wScreenForWindow(Window window)
 860 {
 861     XWindowAttributes attr;
 862
 863     if (wScreenCount==1)
 864         return wScreen[0];
 865
 866     if (XGetWindowAttributes(dpy, window, &attr)) {
 867         return wScreenForRootWindow(attr.root);
 868     }
 869     return NULL;
 870 }
 871
 872
 873
 874 /*
 875  *----------------------------------------------------------
 876  * StartUp--
 877  *      starts the window manager and setup global data.
 878  * Called from main() at startup.
 879  *
 880  * Side effects:
 881  * global data declared in main.c is initialized
 882  *----------------------------------------------------------
 883  */
 884 void
 885 StartUp(Bool defaultScreenOnly)
 886 {
 887     WWorkspaceState *ws_state;
 888     struct sigaction sig_action;
 889     int j, max;
 890
 891     /*
 892      * Ignore CapsLock in modifiers
 893      */
 894     ValidModMask = 0xff & ~LockMask;
 895
 896     getOffendingModifiers();
 897     /*
 898      * Ignore NumLock and ScrollLock too
 899      */
 900     ValidModMask &= ~(_NumLockMask|_ScrollLockMask);
 901
 902
 903     memset(&wKeyBindings, 0, sizeof(wKeyBindings));
 904
 905     wWinContext = XUniqueContext();
 906     wAppWinContext = XUniqueContext();
 907     wStackContext = XUniqueContext();
 908
 909 /*    _XA_VERSION = XInternAtom(dpy, "VERSION", False);*/
 910
 911     _XA_WM_STATE = XInternAtom(dpy, "WM_STATE", False);
 912     _XA_WM_CHANGE_STATE = XInternAtom(dpy, "WM_CHANGE_STATE", False);
 913     _XA_WM_PROTOCOLS = XInternAtom(dpy, "WM_PROTOCOLS", False);
 914     _XA_WM_TAKE_FOCUS = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
 915     _XA_WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
 916     _XA_WM_SAVE_YOURSELF = XInternAtom(dpy, "WM_SAVE_YOURSELF", False);
 917     _XA_WM_CLIENT_LEADER = XInternAtom(dpy, "WM_CLIENT_LEADER", False);
 918     _XA_WM_COLORMAP_WINDOWS = XInternAtom(dpy, "WM_COLORMAP_WINDOWS", False);
 919     _XA_WM_COLORMAP_NOTIFY = XInternAtom(dpy, "WM_COLORMAP_NOTIFY", False);
 920
 921     _XA_GNUSTEP_WM_ATTR = XInternAtom(dpy, GNUSTEP_WM_ATTR_NAME, False);
 922
 923     _XA_WINDOWMAKER_MENU = XInternAtom(dpy, "_WINDOWMAKER_MENU", False);
 924     _XA_WINDOWMAKER_STATE = XInternAtom(dpy, "_WINDOWMAKER_STATE", False);
 925
 926     _XA_WINDOWMAKER_WM_PROTOCOLS =
 927         XInternAtom(dpy, "_WINDOWMAKER_WM_PROTOCOLS", False);
 928
 929     _XA_GNUSTEP_WM_MINIATURIZE_WINDOW =
 930         XInternAtom(dpy, GNUSTEP_WM_MINIATURIZE_WINDOW, False);
 931
 932     _XA_WINDOWMAKER_WM_FUNCTION = XInternAtom(dpy, "_WINDOWMAKER_WM_FUNCTION",
 933                                               False);
 934
 935     _XA_WINDOWMAKER_NOTICEBOARD = XInternAtom(dpy, "_WINDOWMAKER_NOTICEBOARD",
 936                                               False);
 937
 938     _XA_WINDOWMAKER_COMMAND = XInternAtom(dpy, "_WINDOWMAKER_COMMAND", False);
 939
 940 #ifdef OFFIX_DND
 941     _XA_DND_SELECTION = XInternAtom(dpy, "DndSelection", False);
 942     _XA_DND_PROTOCOL = XInternAtom(dpy, "DndProtocol", False);
 943 #endif
 944 #ifdef XDE_DND
 945     _XA_XDE_ENTER = XInternAtom(dpy, "_XDE_ENTER", False);
 946     _XA_XDE_REQUEST = XInternAtom(dpy, "_XDE_REQUEST", False);
 947     _XA_XDE_LEAVE = XInternAtom(dpy, "_XDE_LEAVE", False);
 948     _XA_XDE_DATA_AVAILABLE = XInternAtom(dpy, "_XDE_DATA_AVAILABLE", False);
 949     _XDE_FILETYPE = XInternAtom(dpy, "file:ALL", False);
 950     _XDE_URLTYPE = XInternAtom(dpy, "url:ALL", False);
 951 #endif
 952
 953
 954     /* cursors */
 955     wCursor[WCUR_NORMAL] = XCreateFontCursor(dpy, XC_left_ptr);
 956     wCursor[WCUR_ARROW] = XCreateFontCursor(dpy, XC_top_left_arrow);
 957     wCursor[WCUR_MOVE] = XCreateFontCursor(dpy, XC_fleur);
 958     wCursor[WCUR_RESIZE] = XCreateFontCursor(dpy, XC_sizing);
 959     wCursor[WCUR_WAIT] = XCreateFontCursor(dpy, XC_watch);
 960     wCursor[WCUR_QUESTION] = XCreateFontCursor(dpy, XC_question_arrow);
 961     wCursor[WCUR_TEXT]     = XCreateFontCursor(dpy, XC_xterm); /* odd name???*/
 962
 963     /* emergency exit... */
 964     sig_action.sa_handler = handleSig;
 965     sigemptyset(&sig_action.sa_mask);
 966
 967     /* Here we don't care about SA_RESTART since these signals will close
 968      * wmaker anyway.
 969      * -Dan */
 970     sig_action.sa_flags = 0;
 971     sigaction(SIGINT, &sig_action, NULL);
 972     sigaction(SIGTERM, &sig_action, NULL);
 973     sigaction(SIGHUP, &sig_action, NULL);
 974     sigaction(SIGQUIT, &sig_action, NULL);
 975     sigaction(SIGSEGV, &sig_action, NULL);
 976     sigaction(SIGBUS, &sig_action, NULL);
 977     sigaction(SIGFPE, &sig_action, NULL);
 978     sigaction(SIGABRT, &sig_action, NULL);
 979
 980     /* Here we set SA_RESTART for safety, because SIGUSR1 may not be handled
 981      * immediately.
 982      * -Dan */
 983     sig_action.sa_flags = SA_RESTART;
 984     sigaction(SIGUSR1, &sig_action, NULL);
 985
 986     /* ignore dead pipe */
 987     sig_action.sa_handler = ignoreSig;
 988     sig_action.sa_flags = SA_RESTART;
 989     sigaction(SIGPIPE, &sig_action, NULL);
 990
 991     /* handle dead children */
 992     sig_action.sa_handler = buryChild;
 993     sig_action.sa_flags = SA_NOCLDSTOP|SA_RESTART;
 994     sigaction(SIGCHLD, &sig_action, NULL);
 995
 996     /* Now we unblock all signals, that may have been blocked by the parent
 997      * who exec()-ed us. This can happen for example if Window Maker crashes
 998      * and restarts itself or another window manager from the signal handler.
 999      * In this case, the new proccess inherits the blocked signal mask and
1000      * will no longer react to that signal, until unblocked.
1001      * This is because the signal handler of the proccess who crashed (parent)
1002      * didn't return, and the signal remained blocked. -Dan
1003      */
1004     sigfillset(&sig_action.sa_mask);
1005     sigprocmask(SIG_UNBLOCK, &sig_action.sa_mask, NULL);
1006
1007     /* handle X shutdowns a such */
1008     XSetIOErrorHandler(handleXIO);
1009
1010     /* set hook for out event dispatcher in WINGs event dispatcher */
1011     WMHookEventHandler(DispatchEvent);
1012
1013     /* initialize defaults stuff */
1014     WDWindowMaker = wDefaultsInitDomain("WindowMaker", True);
1015     if (!WDWindowMaker->dictionary) {
1016         wwarning(_("could not read domain \"%s\" from defaults database"),
1017                  "WindowMaker");
1018     }
1019
1020     /* read defaults that don't change until a restart and are
1021      * screen independent */
1022     wReadStaticDefaults(WDWindowMaker ? WDWindowMaker->dictionary : NULL);
1023
1024     /* check sanity of some values */
1025     if (wPreferences.icon_size < 16) {
1026         wwarning(_("icon size is configured to %i, but it's too small. Using 16, instead\n"),
1027                  wPreferences.icon_size);
1028         wPreferences.icon_size = 16;
1029     }
1030
1031     /* init other domains */
1032     WDRootMenu = wDefaultsInitDomain("WMRootMenu", False);
1033     if (!WDRootMenu->dictionary) {
1034         wwarning(_("could not read domain \"%s\" from defaults database"),
1035                  "WMRootMenu");
1036     }
1037
1038     WDWindowAttributes = wDefaultsInitDomain("WMWindowAttributes", True);
1039     if (!WDWindowAttributes->dictionary) {
1040         wwarning(_("could not read domain \"%s\" from defaults database"),
1041                  "WMWindowAttributes");
1042     }
1043
1044     XSetErrorHandler((XErrorHandler)catchXError);
1045
1046 #ifdef SHAPE
1047     /* ignore j */
1048     wShapeSupported = XShapeQueryExtension(dpy, &wShapeEventBase, &j);
1049 #endif
1050
1051     if (defaultScreenOnly) {
1052         max = 1;
1053     } else {
1054         max = ScreenCount(dpy);
1055     }
1056     wScreen = wmalloc(sizeof(WScreen*)*max);
1057
1058     wScreenCount = 0;
1059
1060     /* manage the screens */
1061     for (j = 0; j < max; j++) {
1062         if (defaultScreenOnly || max==1) {
1063             wScreen[wScreenCount] = wScreenInit(DefaultScreen(dpy));
1064             if (!wScreen[wScreenCount]) {
1065                 wfatal(_("it seems that there is already a window manager running"));
1066                 Exit(1);
1067             }
1068         } else {
1069             wScreen[wScreenCount] = wScreenInit(j);
1070             if (!wScreen[wScreenCount]) {
1071                 wwarning(_("could not manage screen %i"), j);
1072                 continue;
1073             }
1074         }
1075         wScreenCount++;
1076     }
1077
1078     /* initialize/restore state for the screens */
1079     for (j = 0; j < wScreenCount; j++) {
1080         /* restore workspace state */
1081         if (!getWorkspaceState(wScreen[j]->root_win, &ws_state)) {
1082             ws_state = NULL;
1083         }
1084
1085         wScreenRestoreState(wScreen[j]);
1086
1087         /* manage all windows that were already here before us */
1088         if (!wPreferences.flags.nodock && wScreen[j]->dock)
1089             wScreen[j]->last_dock = wScreen[j]->dock;
1090
1091         manageAllWindows(wScreen[j]);
1092
1093         /* restore saved menus */
1094         wMenuRestoreState(wScreen[j]);
1095
1096         /* If we're not restarting restore session */
1097         if (ws_state == NULL)
1098             wSessionRestoreState(wScreen[j]);
1099
1100
1101         /* auto-launch apps */
1102         if (!wPreferences.flags.nodock && wScreen[j]->dock) {
1103             wScreen[j]->last_dock = wScreen[j]->dock;
1104             wDockDoAutoLaunch(wScreen[j]->dock, 0);
1105         }
1106         /* auto-launch apps in clip */
1107         if (!wPreferences.flags.noclip) {
1108             int i;
1109             for(i=0; i<wScreen[j]->workspace_count; i++) {
1110                 if (wScreen[j]->workspaces[i]->clip) {
1111                     wScreen[j]->last_dock = wScreen[j]->workspaces[i]->clip;
1112                     wDockDoAutoLaunch(wScreen[j]->workspaces[i]->clip, i);
1113                 }
1114             }
1115         }
1116
1117         /* go to workspace where we were before restart */
1118         if (ws_state) {
1119             wWorkspaceForceChange(wScreen[j], ws_state->workspace);
1120             free(ws_state);
1121         } else {
1122             wSessionRestoreLastWorkspace(wScreen[j]);
1123         }
1124
1125 #ifdef KWM_HINTS
1126         wKWMSetInitializedHint(wScreen[j]);
1127 #endif
1128     }
1129
1130     if (wScreenCount == 0) {
1131         wfatal(_("could not manage any screen"));
1132         Exit(1);
1133     }
1134
1135     if (!wPreferences.flags.noupdates) {
1136         /* setup defaults file polling */
1137         WMAddTimerHandler(3000, wDefaultsCheckDomains, NULL);
1138     }
1139 }
1140
1141
1142
1143
1144 static Bool
1145 windowInList(Window window, Window *list, int count)
1146 {
1147     for (; count>=0; count--) {
1148         if (window == list[count])
1149             return True;
1150     }
1151     return False;
1152 }
1153
1154 /*
1155  *-----------------------------------------------------------------------
1156  * manageAllWindows--
1157  *      Manages all windows in the screen.
1158  *
1159  * Notes:
1160  *      Called when the wm is being started.
1161  *      No events can be processed while the windows are being
1162  * reparented/managed.
1163  *-----------------------------------------------------------------------
1164  */
1165 static void
1166 manageAllWindows(WScreen *scr)
1167 {
1168     Window root, parent;
1169     Window *children;
1170     unsigned int nchildren;
1171     unsigned int i, j;
1172     WWindow *wwin;
1173
1174     XGrabServer(dpy);
1175     XQueryTree(dpy, scr->root_win, &root, &parent, &children, &nchildren);
1176
1177     scr->flags.startup = 1;
1178
1179     /* first remove all icon windows */
1180     for (i = 0; i < nchildren; i++) {
1181         XWMHints *wmhints;
1182
1183         if (children[i]==None)
1184             continue;
1185
1186         wmhints = XGetWMHints(dpy, children[i]);
1187         if (wmhints && (wmhints->flags & IconWindowHint)) {
1188             for (j = 0; j < nchildren; j++)  {
1189                 if (children[j] == wmhints->icon_window) {
1190                     XFree(wmhints);
1191                     wmhints = NULL;
1192                     children[j] = None;
1193                     break;
1194                 }
1195             }
1196         }
1197         if (wmhints) {
1198             XFree(wmhints);
1199         }
1200     }
1201
1202
1203     for (i = 0; i < nchildren; i++) {
1204         if (children[i] == None)
1205             continue;
1206
1207 #ifdef KWM_HINTS
1208         wKWMCheckModule(scr, children[i]);
1209 #endif
1210         wwin = wManageWindow(scr, children[i]);
1211         if (wwin) {
1212             /* apply states got from WSavedState */
1213             /* shaded + minimized is not restored correctly */
1214             if (wwin->flags.shaded) {
1215                 wwin->flags.shaded = 0;
1216                 wShadeWindow(wwin);
1217             }
1218             if (wwin->flags.miniaturized
1219                 && (wwin->transient_for == None
1220                     || wwin->transient_for == scr->root_win
1221                     || !windowInList(wwin->transient_for, children,
1222                                      nchildren))) {
1223
1224                 wwin->flags.skip_next_animation = 1;
1225                 wwin->flags.miniaturized = 0;
1226                 wIconifyWindow(wwin);
1227             } else {
1228                 wClientSetState(wwin, NormalState, None);
1229             }
1230         }
1231     }
1232     XUngrabServer(dpy);
1233
1234     /* hide apps */
1235     wwin = scr->focused_window;
1236     while (wwin) {
1237         if (wwin->flags.hidden) {
1238             WApplication *wapp = wApplicationOf(wwin->main_window);
1239
1240             if (wapp) {
1241                 wwin->flags.hidden = 0;
1242                 wHideApplication(wapp);
1243             } else {
1244                 wwin->flags.hidden = 0;
1245             }
1246         }
1247         wwin = wwin->prev;
1248     }
1249
1250     XFree(children);
1251     scr->flags.startup = 0;
1252     scr->flags.startup2 = 1;
1253
1254     while (XPending(dpy)) {
1255         XEvent ev;
1256         WMNextEvent(dpy, &ev);
1257         WMHandleEvent(&ev);
1258     }
1259     wWorkspaceForceChange(scr, 0);
1260     if (!wPreferences.flags.noclip)
1261         wDockShowIcons(scr->workspaces[scr->current_workspace]->clip);
1262     scr->flags.startup2 = 0;
1263 }
1264
1265
1266