Dogcows Code - chaz/openbox/blob - src/blackbox.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2 // blackbox.cc for Blackbox - an X11 Window manager
   3 // Copyright (c) 2001 - 2002 Sean 'Shaleh' Perry <shaleh@debian.org>
   4 // Copyright (c) 1997 - 2000 Brad Hughes (bhughes@tcac.net)
   5 //
   6 // Permission is hereby granted, free of charge, to any person obtaining a
   7 // copy of this software and associated documentation files (the "Software"),
   8 // to deal in the Software without restriction, including without limitation
   9 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10 // and/or sell copies of the Software, and to permit persons to whom the
  11 // Software is furnished to do so, subject to the following conditions:
  12 //
  13 // The above copyright notice and this permission notice shall be included in
  14 // all copies or substantial portions of the Software.
  15 //
  16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22 // DEALINGS IN THE SOFTWARE.
  23
  24 #ifdef    HAVE_CONFIG_H
  25 #  include "../config.h"
  26 #endif // HAVE_CONFIG_H
  27
  28 extern "C" {
  29 #include <X11/Xlib.h>
  30 #include <X11/Xutil.h>
  31 #include <X11/Xresource.h>
  32 #include <X11/Xatom.h>
  33 #include <X11/cursorfont.h>
  34 #include <X11/keysym.h>
  35
  36 #ifdef    SHAPE
  37 #include <X11/extensions/shape.h>
  38 #endif // SHAPE
  39
  40 #ifdef    HAVE_STDIO_H
  41 #  include <stdio.h>
  42 #endif // HAVE_STDIO_H
  43
  44 #ifdef HAVE_STDLIB_H
  45 #  include <stdlib.h>
  46 #endif // HAVE_STDLIB_H
  47
  48 #ifdef HAVE_STRING_H
  49 #  include <string.h>
  50 #endif // HAVE_STRING_H
  51
  52 #ifdef    HAVE_UNISTD_H
  53 #  include <sys/types.h>
  54 #  include <unistd.h>
  55 #endif // HAVE_UNISTD_H
  56
  57 #ifdef    HAVE_SYS_PARAM_H
  58 #  include <sys/param.h>
  59 #endif // HAVE_SYS_PARAM_H
  60
  61 #ifdef    HAVE_SYS_SELECT_H
  62 #  include <sys/select.h>
  63 #endif // HAVE_SYS_SELECT_H
  64
  65 #ifdef    HAVE_SIGNAL_H
  66 #  include <signal.h>
  67 #endif // HAVE_SIGNAL_H
  68
  69 #ifdef    HAVE_SYS_SIGNAL_H
  70 #  include <sys/signal.h>
  71 #endif // HAVE_SYS_SIGNAL_H
  72
  73 #ifdef    HAVE_SYS_STAT_H
  74 #  include <sys/types.h>
  75 #  include <sys/stat.h>
  76 #endif // HAVE_SYS_STAT_H
  77
  78 #ifdef    TIME_WITH_SYS_TIME
  79 #  include <sys/time.h>
  80 #  include <time.h>
  81 #else // !TIME_WITH_SYS_TIME
  82 #  ifdef    HAVE_SYS_TIME_H
  83 #    include <sys/time.h>
  84 #  else // !HAVE_SYS_TIME_H
  85 #    include <time.h>
  86 #  endif // HAVE_SYS_TIME_H
  87 #endif // TIME_WITH_SYS_TIME
  88
  89 #ifdef    HAVE_LIBGEN_H
  90 #  include <libgen.h>
  91 #endif // HAVE_LIBGEN_H
  92 }
  93
  94 #include <algorithm>
  95 #include <string>
  96 using std::string;
  97
  98 #include "i18n.hh"
  99 #include "blackbox.hh"
 100 #include "Basemenu.hh"
 101 #include "Clientmenu.hh"
 102 #include "GCCache.hh"
 103 #include "Image.hh"
 104 #include "Rootmenu.hh"
 105 #include "Screen.hh"
 106 #include "Slit.hh"
 107 #include "Toolbar.hh"
 108 #include "Util.hh"
 109 #include "Window.hh"
 110 #include "Workspace.hh"
 111 #include "Workspacemenu.hh"
 112
 113
 114 // X event scanner for enter/leave notifies - adapted from twm
 115 struct scanargs {
 116   Window w;
 117   bool leave, inferior, enter;
 118 };
 119
 120 static Bool queueScanner(Display *, XEvent *e, char *args) {
 121   scanargs *scan = (scanargs *) args;
 122   if ((e->type == LeaveNotify) &&
 123       (e->xcrossing.window == scan->w) &&
 124       (e->xcrossing.mode == NotifyNormal)) {
 125     scan->leave = True;
 126     scan->inferior = (e->xcrossing.detail == NotifyInferior);
 127   } else if ((e->type == EnterNotify) && (e->xcrossing.mode == NotifyUngrab)) {
 128     scan->enter = True;
 129   }
 130
 131   return False;
 132 }
 133
 134 Blackbox *blackbox;
 135
 136
 137 Blackbox::Blackbox(char **m_argv, char *dpy_name, char *rc, char *menu)
 138   : BaseDisplay(m_argv[0], dpy_name) {
 139   if (! XSupportsLocale())
 140     fprintf(stderr, "X server does not support locale\n");
 141
 142   if (XSetLocaleModifiers("") == NULL)
 143     fprintf(stderr, "cannot set locale modifiers\n");
 144
 145   ::blackbox = this;
 146   argv = m_argv;
 147   if (! rc) rc = "~/.openbox/rc";
 148   rc_file = expandTilde(rc);
 149   if (! menu) menu = "~/.openbox/menu";
 150   menu_file = expandTilde(menu);
 151
 152   no_focus = False;
 153
 154   resource.auto_raise_delay.tv_sec = resource.auto_raise_delay.tv_usec = 0;
 155
 156   active_screen = 0;
 157   focused_window = (BlackboxWindow *) 0;
 158
 159   XrmInitialize();
 160   load_rc();
 161
 162   init_icccm();
 163
 164   cursor.session = XCreateFontCursor(getXDisplay(), XC_left_ptr);
 165   cursor.move = XCreateFontCursor(getXDisplay(), XC_fleur);
 166   cursor.ll_angle = XCreateFontCursor(getXDisplay(), XC_ll_angle);
 167   cursor.lr_angle = XCreateFontCursor(getXDisplay(), XC_lr_angle);
 168
 169   for (unsigned int i = 0; i < getNumberOfScreens(); i++) {
 170     BScreen *screen = new BScreen(this, i);
 171
 172     if (! screen->isScreenManaged()) {
 173       delete screen;
 174       continue;
 175     }
 176
 177     screenList.push_back(screen);
 178   }
 179
 180   if (screenList.empty()) {
 181     fprintf(stderr,
 182             i18n(blackboxSet, blackboxNoManagableScreens,
 183               "Blackbox::Blackbox: no managable screens found, aborting.\n"));
 184     ::exit(3);
 185   }
 186
 187   // set the screen with mouse to the first managed screen
 188   active_screen = screenList.front();
 189   setFocusedWindow(0);
 190
 191   XSynchronize(getXDisplay(), False);
 192   XSync(getXDisplay(), False);
 193
 194   reconfigure_wait = reread_menu_wait = False;
 195
 196   timer = new BTimer(this, this);
 197   timer->setTimeout(0l);
 198 }
 199
 200
 201 Blackbox::~Blackbox(void) {
 202   std::for_each(screenList.begin(), screenList.end(), PointerAssassin());
 203
 204   std::for_each(menuTimestamps.begin(), menuTimestamps.end(),
 205                 PointerAssassin());
 206
 207   delete timer;
 208 }
 209
 210
 211 void Blackbox::process_event(XEvent *e) {
 212   switch (e->type) {
 213   case ButtonPress: {
 214     // strip the lock key modifiers
 215     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
 216
 217     last_time = e->xbutton.time;
 218
 219     BlackboxWindow *win = (BlackboxWindow *) 0;
 220     Basemenu *menu = (Basemenu *) 0;
 221     Slit *slit = (Slit *) 0;
 222     Toolbar *tbar = (Toolbar *) 0;
 223     BScreen *scrn = (BScreen *) 0;
 224
 225     if ((win = searchWindow(e->xbutton.window))) {
 226       win->buttonPressEvent(&e->xbutton);
 227
 228       /* XXX: is this sane on low colour desktops? */
 229       if (e->xbutton.button == 1)
 230         win->installColormap(True);
 231     } else if ((menu = searchMenu(e->xbutton.window))) {
 232       menu->buttonPressEvent(&e->xbutton);
 233     } else if ((slit = searchSlit(e->xbutton.window))) {
 234       slit->buttonPressEvent(&e->xbutton);
 235     } else if ((tbar = searchToolbar(e->xbutton.window))) {
 236       tbar->buttonPressEvent(&e->xbutton);
 237     } else if ((scrn = searchScreen(e->xbutton.window))) {
 238       scrn->buttonPressEvent(&e->xbutton);
 239       if (active_screen != scrn) {
 240         active_screen = scrn;
 241         // first, set no focus window on the old screen
 242         setFocusedWindow(0);
 243         // and move focus to this screen
 244         setFocusedWindow(0);
 245       }
 246     }
 247     break;
 248   }
 249
 250   case ButtonRelease: {
 251     // strip the lock key modifiers
 252     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
 253
 254     last_time = e->xbutton.time;
 255
 256     BlackboxWindow *win = (BlackboxWindow *) 0;
 257     Basemenu *menu = (Basemenu *) 0;
 258     Toolbar *tbar = (Toolbar *) 0;
 259
 260     if ((win = searchWindow(e->xbutton.window)))
 261       win->buttonReleaseEvent(&e->xbutton);
 262     else if ((menu = searchMenu(e->xbutton.window)))
 263       menu->buttonReleaseEvent(&e->xbutton);
 264     else if ((tbar = searchToolbar(e->xbutton.window)))
 265       tbar->buttonReleaseEvent(&e->xbutton);
 266
 267     break;
 268   }
 269
 270   case ConfigureRequest: {
 271     // compress configure requests...
 272     XEvent realevent;
 273     unsigned int i = 0;
 274     while(XCheckTypedWindowEvent(getXDisplay(), e->xconfigurerequest.window,
 275                                  ConfigureRequest, &realevent)) {
 276       i++;
 277     }
 278     if ( i > 0 )
 279       e = &realevent;
 280
 281     BlackboxWindow *win = (BlackboxWindow *) 0;
 282     Slit *slit = (Slit *) 0;
 283
 284     if ((win = searchWindow(e->xconfigurerequest.window))) {
 285       win->configureRequestEvent(&e->xconfigurerequest);
 286     } else if ((slit = searchSlit(e->xconfigurerequest.window))) {
 287       slit->configureRequestEvent(&e->xconfigurerequest);
 288     } else {
 289       if (validateWindow(e->xconfigurerequest.window)) {
 290         XWindowChanges xwc;
 291
 292         xwc.x = e->xconfigurerequest.x;
 293         xwc.y = e->xconfigurerequest.y;
 294         xwc.width = e->xconfigurerequest.width;
 295         xwc.height = e->xconfigurerequest.height;
 296         xwc.border_width = e->xconfigurerequest.border_width;
 297         xwc.sibling = e->xconfigurerequest.above;
 298         xwc.stack_mode = e->xconfigurerequest.detail;
 299
 300         XConfigureWindow(getXDisplay(), e->xconfigurerequest.window,
 301                          e->xconfigurerequest.value_mask, &xwc);
 302       }
 303     }
 304
 305     break;
 306   }
 307
 308   case MapRequest: {
 309 #ifdef    DEBUG
 310     fprintf(stderr, "Blackbox::process_event(): MapRequest for 0x%lx\n",
 311             e->xmaprequest.window);
 312 #endif // DEBUG
 313
 314     BlackboxWindow *win = searchWindow(e->xmaprequest.window);
 315
 316     if (! win) {
 317       BScreen *screen = searchScreen(e->xmaprequest.parent);
 318
 319       if (! screen) {
 320         /*
 321           we got a map request for a window who's parent isn't root. this
 322           can happen in only one circumstance:
 323
 324             a client window unmapped a managed window, and then remapped it
 325             somewhere between unmapping the client window and reparenting it
 326             to root.
 327
 328           regardless of how it happens, we need to find the screen that
 329           the window is on
 330         */
 331         XWindowAttributes wattrib;
 332         if (! XGetWindowAttributes(getXDisplay(), e->xmaprequest.window,
 333                                    &wattrib)) {
 334           // failed to get the window attributes, perhaps the window has
 335           // now been destroyed?
 336           break;
 337         }
 338
 339         screen = searchScreen(wattrib.root);
 340         assert(screen != 0); // this should never happen
 341       }
 342
 343       screen->manageWindow(e->xmaprequest.window);
 344     }
 345
 346     break;
 347   }
 348
 349   case UnmapNotify: {
 350     BlackboxWindow *win = (BlackboxWindow *) 0;
 351     Slit *slit = (Slit *) 0;
 352
 353     if ((win = searchWindow(e->xunmap.window))) {
 354       win->unmapNotifyEvent(&e->xunmap);
 355     } else if ((slit = searchSlit(e->xunmap.window))) {
 356       slit->unmapNotifyEvent(&e->xunmap);
 357     }
 358
 359     break;
 360   }
 361
 362   case DestroyNotify: {
 363     BlackboxWindow *win = (BlackboxWindow *) 0;
 364     Slit *slit = (Slit *) 0;
 365     BWindowGroup *group = (BWindowGroup *) 0;
 366
 367     if ((win = searchWindow(e->xdestroywindow.window))) {
 368       win->destroyNotifyEvent(&e->xdestroywindow);
 369     } else if ((slit = searchSlit(e->xdestroywindow.window))) {
 370       slit->removeClient(e->xdestroywindow.window, False);
 371     } else if ((group = searchGroup(e->xdestroywindow.window))) {
 372       delete group;
 373     }
 374
 375     break;
 376   }
 377
 378   case ReparentNotify: {
 379     /*
 380       this event is quite rare and is usually handled in unmapNotify
 381       however, if the window is unmapped when the reparent event occurs
 382       the window manager never sees it because an unmap event is not sent
 383       to an already unmapped window.
 384     */
 385     BlackboxWindow *win = searchWindow(e->xreparent.window);
 386     if (win) {
 387       win->reparentNotifyEvent(&e->xreparent);
 388     } else {
 389       Slit *slit = searchSlit(e->xreparent.window);
 390       if (slit && slit->getWindowID() != e->xreparent.parent)
 391         slit->removeClient(e->xreparent.window, True);
 392     }
 393     break;
 394   }
 395
 396   case MotionNotify: {
 397     // motion notify compression...
 398     XEvent realevent;
 399     unsigned int i = 0;
 400     while (XCheckTypedWindowEvent(getXDisplay(), e->xmotion.window,
 401                                   MotionNotify, &realevent)) {
 402       i++;
 403     }
 404
 405     // if we have compressed some motion events, use the last one
 406     if ( i > 0 )
 407       e = &realevent;
 408
 409     // strip the lock key modifiers
 410     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
 411
 412     last_time = e->xmotion.time;
 413
 414     BlackboxWindow *win = (BlackboxWindow *) 0;
 415     Basemenu *menu = (Basemenu *) 0;
 416
 417     if ((win = searchWindow(e->xmotion.window)))
 418       win->motionNotifyEvent(&e->xmotion);
 419     else if ((menu = searchMenu(e->xmotion.window)))
 420       menu->motionNotifyEvent(&e->xmotion);
 421
 422     break;
 423   }
 424
 425   case PropertyNotify: {
 426     last_time = e->xproperty.time;
 427
 428     if (e->xproperty.state != PropertyDelete) {
 429       BlackboxWindow *win = searchWindow(e->xproperty.window);
 430
 431       if (win)
 432         win->propertyNotifyEvent(e->xproperty.atom);
 433     }
 434
 435     break;
 436   }
 437
 438   case EnterNotify: {
 439     last_time = e->xcrossing.time;
 440
 441     BScreen *screen = (BScreen *) 0;
 442     BlackboxWindow *win = (BlackboxWindow *) 0;
 443     Basemenu *menu = (Basemenu *) 0;
 444     Toolbar *tbar = (Toolbar *) 0;
 445     Slit *slit = (Slit *) 0;
 446
 447     if (e->xcrossing.mode == NotifyGrab) break;
 448
 449     XEvent dummy;
 450     scanargs sa;
 451     sa.w = e->xcrossing.window;
 452     sa.enter = sa.leave = False;
 453     XCheckIfEvent(getXDisplay(), &dummy, queueScanner, (char *) &sa);
 454
 455     if ((e->xcrossing.window == e->xcrossing.root) &&
 456         (screen = searchScreen(e->xcrossing.window))) {
 457       screen->getImageControl()->installRootColormap();
 458     } else if ((win = searchWindow(e->xcrossing.window))) {
 459       if (win->getScreen()->isSloppyFocus() &&
 460           (! win->isFocused()) && (! no_focus)) {
 461         if (((! sa.leave) || sa.inferior) && win->isVisible()) {
 462           if (win->setInputFocus())
 463             win->installColormap(True); // XXX: shouldnt we honour no install?
 464         }
 465       }
 466     } else if ((menu = searchMenu(e->xcrossing.window))) {
 467       menu->enterNotifyEvent(&e->xcrossing);
 468     } else if ((tbar = searchToolbar(e->xcrossing.window))) {
 469       tbar->enterNotifyEvent(&e->xcrossing);
 470     } else if ((slit = searchSlit(e->xcrossing.window))) {
 471       slit->enterNotifyEvent(&e->xcrossing);
 472     }
 473     break;
 474   }
 475
 476   case LeaveNotify: {
 477     last_time = e->xcrossing.time;
 478
 479     BlackboxWindow *win = (BlackboxWindow *) 0;
 480     Basemenu *menu = (Basemenu *) 0;
 481     Toolbar *tbar = (Toolbar *) 0;
 482     Slit *slit = (Slit *) 0;
 483
 484     if ((menu = searchMenu(e->xcrossing.window)))
 485       menu->leaveNotifyEvent(&e->xcrossing);
 486     else if ((win = searchWindow(e->xcrossing.window)))
 487       win->installColormap(False);
 488     else if ((tbar = searchToolbar(e->xcrossing.window)))
 489       tbar->leaveNotifyEvent(&e->xcrossing);
 490     else if ((slit = searchSlit(e->xcrossing.window)))
 491       slit->leaveNotifyEvent(&e->xcrossing);
 492     break;
 493   }
 494
 495   case Expose: {
 496     // compress expose events
 497     XEvent realevent;
 498     unsigned int i = 0;
 499     int ex1, ey1, ex2, ey2;
 500     ex1 = e->xexpose.x;
 501     ey1 = e->xexpose.y;
 502     ex2 = ex1 + e->xexpose.width - 1;
 503     ey2 = ey1 + e->xexpose.height - 1;
 504     while (XCheckTypedWindowEvent(getXDisplay(), e->xexpose.window,
 505                                   Expose, &realevent)) {
 506       i++;
 507
 508       // merge expose area
 509       ex1 = std::min(realevent.xexpose.x, ex1);
 510       ey1 = std::min(realevent.xexpose.y, ey1);
 511       ex2 = std::max(realevent.xexpose.x + realevent.xexpose.width - 1, ex2);
 512       ey2 = std::max(realevent.xexpose.y + realevent.xexpose.height - 1, ey2);
 513     }
 514     if ( i > 0 )
 515       e = &realevent;
 516
 517     // use the merged area
 518     e->xexpose.x = ex1;
 519     e->xexpose.y = ey1;
 520     e->xexpose.width = ex2 - ex1 + 1;
 521     e->xexpose.height = ey2 - ey1 + 1;
 522
 523     BlackboxWindow *win = (BlackboxWindow *) 0;
 524     Basemenu *menu = (Basemenu *) 0;
 525     Toolbar *tbar = (Toolbar *) 0;
 526
 527     if ((win = searchWindow(e->xexpose.window)))
 528       win->exposeEvent(&e->xexpose);
 529     else if ((menu = searchMenu(e->xexpose.window)))
 530       menu->exposeEvent(&e->xexpose);
 531     else if ((tbar = searchToolbar(e->xexpose.window)))
 532       tbar->exposeEvent(&e->xexpose);
 533
 534     break;
 535   }
 536
 537   case KeyPress: {
 538     Toolbar *tbar = searchToolbar(e->xkey.window);
 539
 540     if (tbar && tbar->isEditing())
 541       tbar->keyPressEvent(&e->xkey);
 542
 543     break;
 544   }
 545
 546   case ColormapNotify: {
 547     BScreen *screen = searchScreen(e->xcolormap.window);
 548
 549     if (screen)
 550       screen->setRootColormapInstalled((e->xcolormap.state ==
 551                                         ColormapInstalled) ? True : False);
 552
 553     break;
 554   }
 555
 556   case FocusIn: {
 557     if (e->xfocus.detail != NotifyNonlinear) {
 558       /*
 559         don't process FocusIns when:
 560         1. the new focus window isn't an ancestor or inferior of the old
 561         focus window (NotifyNonlinear)
 562       */
 563       break;
 564     }
 565
 566     BlackboxWindow *win = searchWindow(e->xfocus.window);
 567     if (win) {
 568       if (! win->isFocused())
 569         win->setFocusFlag(True);
 570
 571       /*
 572         set the event window to None.  when the FocusOut event handler calls
 573         this function recursively, it uses this as an indication that focus
 574         has moved to a known window.
 575       */
 576       e->xfocus.window = None;
 577     }
 578
 579     break;
 580   }
 581
 582   case FocusOut: {
 583     if (e->xfocus.detail != NotifyNonlinear) {
 584       /*
 585         don't process FocusOuts when:
 586         2. the new focus window isn't an ancestor or inferior of the old
 587         focus window (NotifyNonlinear)
 588       */
 589       break;
 590     }
 591
 592     BlackboxWindow *win = searchWindow(e->xfocus.window);
 593     if (win && win->isFocused()) {
 594       /*
 595         before we mark "win" as unfocused, we need to verify that focus is
 596         going to a known location, is in a known location, or set focus
 597         to a known location.
 598       */
 599
 600       XEvent event;
 601       // don't check the current focus if FocusOut was generated during a grab
 602       bool check_focus = (e->xfocus.mode == NotifyNormal);
 603
 604       /*
 605         First, check if there is a pending FocusIn event waiting.  if there
 606         is, process it and determine if focus has moved to another window
 607         (the FocusIn event handler sets the window in the event
 608         structure to None to indicate this).
 609       */
 610       if (XCheckTypedEvent(getXDisplay(), FocusIn, &event)) {
 611
 612         process_event(&event);
 613         if (event.xfocus.window == None) {
 614           // focus has moved
 615           check_focus = False;
 616         }
 617       }
 618
 619       if (check_focus) {
 620         /*
 621           Second, we query the X server for the current input focus.
 622           to make sure that we keep a consistent state.
 623         */
 624         BlackboxWindow *focus;
 625         Window w;
 626         int revert;
 627         XGetInputFocus(getXDisplay(), &w, &revert);
 628         focus = searchWindow(w);
 629         if (focus) {
 630           /*
 631             focus got from "win" to "focus" under some very strange
 632             circumstances, and we need to make sure that the focus indication
 633             is correct.
 634           */
 635           setFocusedWindow(focus);
 636         } else {
 637           // we have no idea where focus went... so we set it to somewhere
 638           setFocusedWindow(0);
 639         }
 640       }
 641     }
 642
 643     break;
 644   }
 645
 646   case ClientMessage: {
 647     if (e->xclient.format == 32) {
 648       if (e->xclient.message_type == getWMChangeStateAtom()) {
 649         BlackboxWindow *win = searchWindow(e->xclient.window);
 650         if (! win || ! win->validateClient()) return;
 651
 652         if (e->xclient.data.l[0] == IconicState)
 653           win->iconify();
 654         if (e->xclient.data.l[0] == NormalState)
 655           win->deiconify();
 656       } else if(e->xclient.message_type == getBlackboxChangeWorkspaceAtom()) {
 657         BScreen *screen = searchScreen(e->xclient.window);
 658
 659         if (screen && e->xclient.data.l[0] >= 0 &&
 660             e->xclient.data.l[0] <
 661             static_cast<signed>(screen->getWorkspaceCount()))
 662           screen->changeWorkspaceID(e->xclient.data.l[0]);
 663       } else if (e->xclient.message_type == getBlackboxChangeWindowFocusAtom()) {
 664         BlackboxWindow *win = searchWindow(e->xclient.window);
 665
 666         if (win && win->isVisible() && win->setInputFocus())
 667           win->installColormap(True);
 668       } else if (e->xclient.message_type == getBlackboxCycleWindowFocusAtom()) {
 669         BScreen *screen = searchScreen(e->xclient.window);
 670
 671         if (screen) {
 672           if (! e->xclient.data.l[0])
 673             screen->prevFocus();
 674           else
 675             screen->nextFocus();
 676         }
 677       } else if (e->xclient.message_type == getBlackboxChangeAttributesAtom()) {
 678         BlackboxWindow *win = searchWindow(e->xclient.window);
 679
 680         if (win && win->validateClient()) {
 681           BlackboxHints net;
 682           net.flags = e->xclient.data.l[0];
 683           net.attrib = e->xclient.data.l[1];
 684           net.workspace = e->xclient.data.l[2];
 685           net.stack = e->xclient.data.l[3];
 686           net.decoration = e->xclient.data.l[4];
 687
 688           win->changeBlackboxHints(&net);
 689         }
 690       }
 691     }
 692
 693     break;
 694   }
 695
 696   case NoExpose:
 697   case ConfigureNotify:
 698   case MapNotify:
 699     break; // not handled, just ignore
 700
 701   default: {
 702 #ifdef    SHAPE
 703     if (e->type == getShapeEventBase()) {
 704       XShapeEvent *shape_event = (XShapeEvent *) e;
 705       BlackboxWindow *win = searchWindow(e->xany.window);
 706
 707       if (win)
 708         win->shapeEvent(shape_event);
 709     }
 710 #endif // SHAPE
 711   }
 712   } // switch
 713 }
 714
 715
 716 bool Blackbox::handleSignal(int sig) {
 717   switch (sig) {
 718   case SIGHUP:
 719     reconfigure();
 720     break;
 721
 722   case SIGUSR1:
 723     reload_rc();
 724     break;
 725
 726   case SIGUSR2:
 727     rereadMenu();
 728     break;
 729
 730   case SIGPIPE:
 731   case SIGSEGV:
 732   case SIGFPE:
 733   case SIGINT:
 734   case SIGTERM:
 735     shutdown();
 736
 737   default:
 738     return False;
 739   }
 740
 741   return True;
 742 }
 743
 744
 745 void Blackbox::init_icccm(void) {
 746   xa_wm_colormap_windows =
 747     XInternAtom(getXDisplay(), "WM_COLORMAP_WINDOWS", False);
 748   xa_wm_protocols = XInternAtom(getXDisplay(), "WM_PROTOCOLS", False);
 749   xa_wm_state = XInternAtom(getXDisplay(), "WM_STATE", False);
 750   xa_wm_change_state = XInternAtom(getXDisplay(), "WM_CHANGE_STATE", False);
 751   xa_wm_delete_window = XInternAtom(getXDisplay(), "WM_DELETE_WINDOW", False);
 752   xa_wm_take_focus = XInternAtom(getXDisplay(), "WM_TAKE_FOCUS", False);
 753   motif_wm_hints = XInternAtom(getXDisplay(), "_MOTIF_WM_HINTS", False);
 754
 755   blackbox_hints = XInternAtom(getXDisplay(), "_BLACKBOX_HINTS", False);
 756   blackbox_attributes =
 757     XInternAtom(getXDisplay(), "_BLACKBOX_ATTRIBUTES", False);
 758   blackbox_change_attributes =
 759     XInternAtom(getXDisplay(), "_BLACKBOX_CHANGE_ATTRIBUTES", False);
 760   blackbox_structure_messages =
 761     XInternAtom(getXDisplay(), "_BLACKBOX_STRUCTURE_MESSAGES", False);
 762   blackbox_notify_startup =
 763     XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_STARTUP", False);
 764   blackbox_notify_window_add =
 765     XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_ADD", False);
 766   blackbox_notify_window_del =
 767     XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_DEL", False);
 768   blackbox_notify_current_workspace =
 769     XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_CURRENT_WORKSPACE", False);
 770   blackbox_notify_workspace_count =
 771     XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WORKSPACE_COUNT", False);
 772   blackbox_notify_window_focus =
 773     XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_FOCUS", False);
 774   blackbox_notify_window_raise =
 775     XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_RAISE", False);
 776   blackbox_notify_window_lower =
 777     XInternAtom(getXDisplay(), "_BLACKBOX_NOTIFY_WINDOW_LOWER", False);
 778   blackbox_change_workspace =
 779     XInternAtom(getXDisplay(), "_BLACKBOX_CHANGE_WORKSPACE", False);
 780   blackbox_change_window_focus =
 781     XInternAtom(getXDisplay(), "_BLACKBOX_CHANGE_WINDOW_FOCUS", False);
 782   blackbox_cycle_window_focus =
 783     XInternAtom(getXDisplay(), "_BLACKBOX_CYCLE_WINDOW_FOCUS", False);
 784
 785 #ifdef    NEWWMSPEC
 786   net_supported = XInternAtom(getXDisplay(), "_NET_SUPPORTED", False);
 787   net_client_list = XInternAtom(getXDisplay(), "_NET_CLIENT_LIST", False);
 788   net_client_list_stacking =
 789     XInternAtom(getXDisplay(), "_NET_CLIENT_LIST_STACKING", False);
 790   net_number_of_desktops =
 791     XInternAtom(getXDisplay(), "_NET_NUMBER_OF_DESKTOPS", False);
 792   net_desktop_geometry =
 793     XInternAtom(getXDisplay(), "_NET_DESKTOP_GEOMETRY", False);
 794   net_desktop_viewport =
 795     XInternAtom(getXDisplay(), "_NET_DESKTOP_VIEWPORT", False);
 796   net_current_desktop =
 797     XInternAtom(getXDisplay(), "_NET_CURRENT_DESKTOP", False);
 798   net_desktop_names = XInternAtom(getXDisplay(), "_NET_DESKTOP_NAMES", False);
 799   net_active_window = XInternAtom(getXDisplay(), "_NET_ACTIVE_WINDOW", False);
 800   net_workarea = XInternAtom(getXDisplay(), "_NET_WORKAREA", False);
 801   net_supporting_wm_check =
 802     XInternAtom(getXDisplay(), "_NET_SUPPORTING_WM_CHECK", False);
 803   net_virtual_roots = XInternAtom(getXDisplay(), "_NET_VIRTUAL_ROOTS", False);
 804   net_close_window = XInternAtom(getXDisplay(), "_NET_CLOSE_WINDOW", False);
 805   net_wm_moveresize = XInternAtom(getXDisplay(), "_NET_WM_MOVERESIZE", False);
 806   net_properties = XInternAtom(getXDisplay(), "_NET_PROPERTIES", False);
 807   net_wm_name = XInternAtom(getXDisplay(), "_NET_WM_NAME", False);
 808   net_wm_desktop = XInternAtom(getXDisplay(), "_NET_WM_DESKTOP", False);
 809   net_wm_window_type =
 810     XInternAtom(getXDisplay(), "_NET_WM_WINDOW_TYPE", False);
 811   net_wm_state = XInternAtom(getXDisplay(), "_NET_WM_STATE", False);
 812   net_wm_strut = XInternAtom(getXDisplay(), "_NET_WM_STRUT", False);
 813   net_wm_icon_geometry =
 814     XInternAtom(getXDisplay(), "_NET_WM_ICON_GEOMETRY", False);
 815   net_wm_icon = XInternAtom(getXDisplay(), "_NET_WM_ICON", False);
 816   net_wm_pid = XInternAtom(getXDisplay(), "_NET_WM_PID", False);
 817   net_wm_handled_icons =
 818     XInternAtom(getXDisplay(), "_NET_WM_HANDLED_ICONS", False);
 819   net_wm_ping = XInternAtom(getXDisplay(), "_NET_WM_PING", False);
 820 #endif // NEWWMSPEC
 821
 822 #ifdef    HAVE_GETPID
 823   blackbox_pid = XInternAtom(getXDisplay(), "_BLACKBOX_PID", False);
 824 #endif // HAVE_GETPID
 825 }
 826
 827
 828 bool Blackbox::validateWindow(Window window) {
 829   XEvent event;
 830   if (XCheckTypedWindowEvent(getXDisplay(), window, DestroyNotify, &event)) {
 831     XPutBackEvent(getXDisplay(), &event);
 832
 833     return False;
 834   }
 835
 836   return True;
 837 }
 838
 839
 840 BScreen *Blackbox::searchScreen(Window window) {
 841   ScreenList::iterator it = screenList.begin();
 842
 843   for (; it != screenList.end(); ++it) {
 844     BScreen *s = *it;
 845     if (s->getRootWindow() == window)
 846       return s;
 847   }
 848
 849   return (BScreen *) 0;
 850 }
 851
 852
 853 BlackboxWindow *Blackbox::searchWindow(Window window) {
 854   WindowLookup::iterator it = windowSearchList.find(window);
 855   if (it != windowSearchList.end())
 856     return it->second;
 857
 858   return (BlackboxWindow*) 0;
 859 }
 860
 861
 862 BWindowGroup *Blackbox::searchGroup(Window window) {
 863   GroupLookup::iterator it = groupSearchList.find(window);
 864   if (it != groupSearchList.end())
 865     return it->second;
 866
 867   return (BWindowGroup *) 0;
 868 }
 869
 870
 871 Basemenu *Blackbox::searchMenu(Window window) {
 872   MenuLookup::iterator it = menuSearchList.find(window);
 873   if (it != menuSearchList.end())
 874     return it->second;
 875
 876   return (Basemenu*) 0;
 877 }
 878
 879
 880 Toolbar *Blackbox::searchToolbar(Window window) {
 881   ToolbarLookup::iterator it = toolbarSearchList.find(window);
 882   if (it != toolbarSearchList.end())
 883     return it->second;
 884
 885   return (Toolbar*) 0;
 886 }
 887
 888
 889 Slit *Blackbox::searchSlit(Window window) {
 890   SlitLookup::iterator it = slitSearchList.find(window);
 891   if (it != slitSearchList.end())
 892     return it->second;
 893
 894   return (Slit*) 0;
 895 }
 896
 897
 898 void Blackbox::saveWindowSearch(Window window, BlackboxWindow *data) {
 899   windowSearchList.insert(WindowLookupPair(window, data));
 900 }
 901
 902
 903 void Blackbox::saveGroupSearch(Window window, BWindowGroup *data) {
 904   groupSearchList.insert(GroupLookupPair(window, data));
 905 }
 906
 907
 908 void Blackbox::saveMenuSearch(Window window, Basemenu *data) {
 909   menuSearchList.insert(MenuLookupPair(window, data));
 910 }
 911
 912
 913 void Blackbox::saveToolbarSearch(Window window, Toolbar *data) {
 914   toolbarSearchList.insert(ToolbarLookupPair(window, data));
 915 }
 916
 917
 918 void Blackbox::saveSlitSearch(Window window, Slit *data) {
 919   slitSearchList.insert(SlitLookupPair(window, data));
 920 }
 921
 922
 923 void Blackbox::removeWindowSearch(Window window) {
 924   windowSearchList.erase(window);
 925 }
 926
 927
 928 void Blackbox::removeGroupSearch(Window window) {
 929   groupSearchList.erase(window);
 930 }
 931
 932
 933 void Blackbox::removeMenuSearch(Window window) {
 934   menuSearchList.erase(window);
 935 }
 936
 937
 938 void Blackbox::removeToolbarSearch(Window window) {
 939   toolbarSearchList.erase(window);
 940 }
 941
 942
 943 void Blackbox::removeSlitSearch(Window window) {
 944   slitSearchList.erase(window);
 945 }
 946
 947
 948 void Blackbox::restart(const char *prog) {
 949   shutdown();
 950
 951   if (prog) {
 952     execlp(prog, prog, NULL);
 953     perror(prog);
 954   }
 955
 956   // fall back in case the above execlp doesn't work
 957   execvp(argv[0], argv);
 958   string name = basename(argv[0]);
 959   execvp(name.c_str(), argv);
 960 }
 961
 962
 963 void Blackbox::shutdown(void) {
 964   BaseDisplay::shutdown();
 965
 966   XSetInputFocus(getXDisplay(), PointerRoot, None, CurrentTime);
 967
 968   std::for_each(screenList.begin(), screenList.end(),
 969                 std::mem_fun(&BScreen::shutdown));
 970
 971   XSync(getXDisplay(), False);
 972
 973   save_rc();
 974 }
 975
 976
 977 void Blackbox::save_rc(void) {
 978   XrmDatabase new_blackboxrc = (XrmDatabase) 0;
 979   char rc_string[1024];
 980
 981   load_rc();
 982
 983   sprintf(rc_string, "session.colorsPerChannel:  %d",
 984           resource.colors_per_channel);
 985   XrmPutLineResource(&new_blackboxrc, rc_string);
 986
 987   sprintf(rc_string, "session.doubleClickInterval:  %lu",
 988           resource.double_click_interval);
 989   XrmPutLineResource(&new_blackboxrc, rc_string);
 990
 991   sprintf(rc_string, "session.autoRaiseDelay:  %lu",
 992           ((resource.auto_raise_delay.tv_sec * 1000) +
 993            (resource.auto_raise_delay.tv_usec / 1000)));
 994   XrmPutLineResource(&new_blackboxrc, rc_string);
 995
 996   sprintf(rc_string, "session.cacheLife: %lu", resource.cache_life / 60000);
 997   XrmPutLineResource(&new_blackboxrc, rc_string);
 998
 999   sprintf(rc_string, "session.cacheMax: %lu", resource.cache_max);
1000   XrmPutLineResource(&new_blackboxrc, rc_string);
1001
1002   ScreenList::iterator it = screenList.begin();
1003   for (; it != screenList.end(); ++it) {
1004     BScreen *screen = *it;
1005     int screen_number = screen->getScreenNumber();
1006
1007     char *placement = (char *) 0;
1008
1009     switch (screen->getSlitPlacement()) {
1010     case Slit::TopLeft: placement = "TopLeft"; break;
1011     case Slit::CenterLeft: placement = "CenterLeft"; break;
1012     case Slit::BottomLeft: placement = "BottomLeft"; break;
1013     case Slit::TopCenter: placement = "TopCenter"; break;
1014     case Slit::BottomCenter: placement = "BottomCenter"; break;
1015     case Slit::TopRight: placement = "TopRight"; break;
1016     case Slit::BottomRight: placement = "BottomRight"; break;
1017     case Slit::CenterRight: default: placement = "CenterRight"; break;
1018     }
1019
1020     sprintf(rc_string, "session.screen%d.slit.placement: %s", screen_number,
1021             placement);
1022     XrmPutLineResource(&new_blackboxrc, rc_string);
1023
1024     sprintf(rc_string, "session.screen%d.slit.direction: %s", screen_number,
1025             ((screen->getSlitDirection() == Slit::Horizontal) ? "Horizontal" :
1026              "Vertical"));
1027     XrmPutLineResource(&new_blackboxrc, rc_string);
1028
1029     sprintf(rc_string, "session.screen%d.slit.onTop: %s", screen_number,
1030             ((screen->getSlit()->isOnTop()) ? "True" : "False"));
1031     XrmPutLineResource(&new_blackboxrc, rc_string);
1032
1033     sprintf(rc_string, "session.screen%d.slit.autoHide: %s", screen_number,
1034             ((screen->getSlit()->doAutoHide()) ? "True" : "False"));
1035     XrmPutLineResource(&new_blackboxrc, rc_string);
1036
1037     sprintf(rc_string, "session.opaqueMove: %s",
1038             ((screen->doOpaqueMove()) ? "True" : "False"));
1039     XrmPutLineResource(&new_blackboxrc, rc_string);
1040
1041     sprintf(rc_string, "session.imageDither: %s",
1042             ((screen->getImageControl()->doDither()) ? "True" : "False"));
1043     XrmPutLineResource(&new_blackboxrc, rc_string);
1044
1045     sprintf(rc_string, "session.screen%d.fullMaximization: %s", screen_number,
1046             ((screen->doFullMax()) ? "True" : "False"));
1047     XrmPutLineResource(&new_blackboxrc, rc_string);
1048
1049     sprintf(rc_string, "session.screen%d.focusNewWindows: %s", screen_number,
1050             ((screen->doFocusNew()) ? "True" : "False"));
1051     XrmPutLineResource(&new_blackboxrc, rc_string);
1052
1053     sprintf(rc_string, "session.screen%d.focusLastWindow: %s", screen_number,
1054             ((screen->doFocusLast()) ? "True" : "False"));
1055     XrmPutLineResource(&new_blackboxrc, rc_string);
1056
1057     sprintf(rc_string, "session.screen%d.rowPlacementDirection: %s",
1058             screen_number,
1059             ((screen->getRowPlacementDirection() == BScreen::LeftRight) ?
1060              "LeftToRight" : "RightToLeft"));
1061     XrmPutLineResource(&new_blackboxrc, rc_string);
1062
1063     sprintf(rc_string, "session.screen%d.colPlacementDirection: %s",
1064             screen_number,
1065             ((screen->getColPlacementDirection() == BScreen::TopBottom) ?
1066              "TopToBottom" : "BottomToTop"));
1067     XrmPutLineResource(&new_blackboxrc, rc_string);
1068
1069     switch (screen->getPlacementPolicy()) {
1070     case BScreen::CascadePlacement:
1071       placement = "CascadePlacement";
1072       break;
1073     case BScreen::ColSmartPlacement:
1074       placement = "ColSmartPlacement";
1075       break;
1076
1077     case BScreen::RowSmartPlacement:
1078     default:
1079       placement = "RowSmartPlacement";
1080       break;
1081     }
1082     sprintf(rc_string, "session.screen%d.windowPlacement:  %s", screen_number,
1083             placement);
1084     XrmPutLineResource(&new_blackboxrc, rc_string);
1085
1086     string fmodel;
1087     if (screen->isSloppyFocus()) {
1088       fmodel = "SloppyFocus";
1089       if (screen->doAutoRaise()) fmodel += " AutoRaise";
1090       if (screen->doClickRaise()) fmodel += " ClickRaise";
1091     } else {
1092       fmodel = "ClickToFocus";
1093     }
1094     sprintf(rc_string, "session.screen%d.focusModel:  %s", screen_number,
1095             fmodel.c_str());
1096     XrmPutLineResource(&new_blackboxrc, rc_string);
1097
1098     sprintf(rc_string, "session.screen%d.workspaces:  %d", screen_number,
1099             screen->getWorkspaceCount());
1100     XrmPutLineResource(&new_blackboxrc, rc_string);
1101
1102     sprintf(rc_string, "session.screen%d.toolbar.onTop:  %s", screen_number,
1103             ((screen->getToolbar()->isOnTop()) ? "True" : "False"));
1104     XrmPutLineResource(&new_blackboxrc, rc_string);
1105
1106     sprintf(rc_string, "session.screen%d.toolbar.autoHide:  %s",
1107             screen_number,
1108             ((screen->getToolbar()->doAutoHide()) ? "True" : "False"));
1109     XrmPutLineResource(&new_blackboxrc, rc_string);
1110
1111     switch (screen->getToolbarPlacement()) {
1112     case Toolbar::TopLeft: placement = "TopLeft"; break;
1113     case Toolbar::BottomLeft: placement = "BottomLeft"; break;
1114     case Toolbar::TopCenter: placement = "TopCenter"; break;
1115     case Toolbar::TopRight: placement = "TopRight"; break;
1116     case Toolbar::BottomRight: placement = "BottomRight"; break;
1117     case Toolbar::BottomCenter: default: placement = "BottomCenter"; break;
1118     }
1119
1120     sprintf(rc_string, "session.screen%d.toolbar.placement: %s",
1121             screen_number, placement);
1122     XrmPutLineResource(&new_blackboxrc, rc_string);
1123
1124     load_rc(screen);
1125
1126     // these are static, but may not be saved in the users .blackboxrc,
1127     // writing these resources will allow the user to edit them at a later
1128     // time... but loading the defaults before saving allows us to rewrite the
1129     // users changes...
1130
1131 #ifdef    HAVE_STRFTIME
1132     sprintf(rc_string, "session.screen%d.strftimeFormat: %s", screen_number,
1133             screen->getStrftimeFormat());
1134     XrmPutLineResource(&new_blackboxrc, rc_string);
1135 #else // !HAVE_STRFTIME
1136     sprintf(rc_string, "session.screen%d.dateFormat:  %s", screen_number,
1137             ((screen->getDateFormat() == B_EuropeanDate) ?
1138              "European" : "American"));
1139     XrmPutLineResource(&new_blackboxrc, rc_string);
1140
1141     sprintf(rc_string, "session.screen%d.clockFormat:  %d", screen_number,
1142             ((screen->isClock24Hour()) ? 24 : 12));
1143     XrmPutLineResource(&new_blackboxrc, rc_string);
1144 #endif // HAVE_STRFTIME
1145
1146     sprintf(rc_string, "session.screen%d.edgeSnapThreshold: %d",
1147             screen_number, screen->getEdgeSnapThreshold());
1148     XrmPutLineResource(&new_blackboxrc, rc_string);
1149
1150     sprintf(rc_string, "session.screen%d.toolbar.widthPercent:  %d",
1151             screen_number, screen->getToolbarWidthPercent());
1152     XrmPutLineResource(&new_blackboxrc, rc_string);
1153
1154     // write out the user's workspace names
1155
1156     string save_string = screen->getWorkspace(0)->getName();
1157     for (unsigned int i = 1; i < screen->getWorkspaceCount(); ++i) {
1158       save_string += ',';
1159       save_string += screen->getWorkspace(i)->getName();
1160     }
1161
1162     char *resource_string = new char[save_string.length() + 48];
1163     sprintf(resource_string, "session.screen%d.workspaceNames:  %s",
1164             screen_number, save_string.c_str());
1165     XrmPutLineResource(&new_blackboxrc, resource_string);
1166
1167     delete [] resource_string;
1168   }
1169
1170   XrmDatabase old_blackboxrc = XrmGetFileDatabase(rc_file.c_str());
1171
1172   XrmMergeDatabases(new_blackboxrc, &old_blackboxrc);
1173   XrmPutFileDatabase(old_blackboxrc, rc_file.c_str());
1174   XrmDestroyDatabase(old_blackboxrc);
1175 }
1176
1177
1178 void Blackbox::load_rc(void) {
1179   XrmDatabase database = (XrmDatabase) 0;
1180
1181   database = XrmGetFileDatabase(rc_file.c_str());
1182
1183   XrmValue value;
1184   char *value_type;
1185   int int_value;
1186   unsigned long long_value;
1187
1188   resource.colors_per_channel = 4;
1189   if (XrmGetResource(database, "session.colorsPerChannel",
1190                      "Session.ColorsPerChannel", &value_type, &value) &&
1191       sscanf(value.addr, "%d", &int_value) == 1) {
1192     resource.colors_per_channel = int_value;
1193     if (resource.colors_per_channel < 2) resource.colors_per_channel = 2;
1194     if (resource.colors_per_channel > 6) resource.colors_per_channel = 6;
1195   }
1196
1197   if (XrmGetResource(database, "session.styleFile", "Session.StyleFile",
1198                      &value_type, &value))
1199     resource.style_file = expandTilde(value.addr);
1200   else
1201     resource.style_file = DEFAULTSTYLE;
1202
1203   resource.double_click_interval = 250;
1204   if (XrmGetResource(database, "session.doubleClickInterval",
1205                      "Session.DoubleClickInterval", &value_type, &value) &&
1206       sscanf(value.addr, "%lu", &long_value) == 1) {
1207     resource.double_click_interval = long_value;
1208   }
1209
1210   resource.auto_raise_delay.tv_usec = 400;
1211   if (XrmGetResource(database, "session.autoRaiseDelay",
1212                      "Session.AutoRaiseDelay", &value_type, &value) &&
1213       sscanf(value.addr, "%lu", &long_value) == 1) {
1214     resource.auto_raise_delay.tv_usec = long_value;
1215   }
1216
1217   resource.auto_raise_delay.tv_sec = resource.auto_raise_delay.tv_usec / 1000;
1218   resource.auto_raise_delay.tv_usec -=
1219     (resource.auto_raise_delay.tv_sec * 1000);
1220   resource.auto_raise_delay.tv_usec *= 1000;
1221
1222   resource.cache_life = 5l;
1223   if (XrmGetResource(database, "session.cacheLife", "Session.CacheLife",
1224                      &value_type, &value) &&
1225       sscanf(value.addr, "%lu", &long_value) == 1) {
1226     resource.cache_life = long_value;
1227   }
1228   resource.cache_life *= 60000;
1229
1230   resource.cache_max = 200;
1231   if (XrmGetResource(database, "session.cacheMax", "Session.CacheMax",
1232                      &value_type, &value) &&
1233       sscanf(value.addr, "%lu", &long_value) == 1) {
1234     resource.cache_max = long_value;
1235   }
1236 }
1237
1238
1239 void Blackbox::load_rc(BScreen *screen) {
1240   XrmDatabase database = (XrmDatabase) 0;
1241
1242   database = XrmGetFileDatabase(rc_file.c_str());
1243
1244   XrmValue value;
1245   char *value_type, name_lookup[1024], class_lookup[1024];
1246   int screen_number = screen->getScreenNumber();
1247   int int_value;
1248
1249   sprintf(name_lookup,  "session.screen%d.fullMaximization", screen_number);
1250   sprintf(class_lookup, "Session.Screen%d.FullMaximization", screen_number);
1251   screen->saveFullMax(False);
1252   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1253                      &value) &&
1254       ! strncasecmp(value.addr, "true", value.size)) {
1255     screen->saveFullMax(True);
1256   }
1257
1258   sprintf(name_lookup,  "session.screen%d.focusNewWindows", screen_number);
1259   sprintf(class_lookup, "Session.Screen%d.FocusNewWindows", screen_number);
1260   screen->saveFocusNew(False);
1261   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1262                      &value) &&
1263       ! strncasecmp(value.addr, "true", value.size)) {
1264     screen->saveFocusNew(True);
1265   }
1266
1267   sprintf(name_lookup,  "session.screen%d.focusLastWindow", screen_number);
1268   sprintf(class_lookup, "Session.Screen%d.focusLastWindow", screen_number);
1269   screen->saveFocusLast(False);
1270   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1271                      &value) &&
1272       ! strncasecmp(value.addr, "true", value.size)) {
1273     screen->saveFocusLast(True);
1274   }
1275
1276   sprintf(name_lookup,  "session.screen%d.rowPlacementDirection",
1277           screen_number);
1278   sprintf(class_lookup, "Session.Screen%d.RowPlacementDirection",
1279           screen_number);
1280   screen->saveRowPlacementDirection(BScreen::LeftRight);
1281   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1282                      &value) &&
1283       ! strncasecmp(value.addr, "righttoleft", value.size)) {
1284     screen->saveRowPlacementDirection(BScreen::RightLeft);
1285   }
1286
1287   sprintf(name_lookup,  "session.screen%d.colPlacementDirection",
1288           screen_number);
1289   sprintf(class_lookup, "Session.Screen%d.ColPlacementDirection",
1290           screen_number);
1291   screen->saveColPlacementDirection(BScreen::TopBottom);
1292   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1293                      &value) &&
1294       ! strncasecmp(value.addr, "bottomtotop", value.size)) {
1295     screen->saveColPlacementDirection(BScreen::BottomTop);
1296   }
1297
1298   sprintf(name_lookup,  "session.screen%d.workspaces", screen_number);
1299   sprintf(class_lookup, "Session.Screen%d.Workspaces", screen_number);
1300   screen->saveWorkspaces(1);
1301   if (XrmGetResource(database, name_lookup, class_lookup,
1302                      &value_type, &value) &&
1303       sscanf(value.addr, "%d", &int_value) == 1 &&
1304       int_value > 0 && int_value < 128) {
1305     screen->saveWorkspaces(int_value);
1306   }
1307
1308   sprintf(name_lookup,  "session.screen%d.toolbar.widthPercent",
1309           screen_number);
1310   sprintf(class_lookup, "Session.Screen%d.Toolbar.WidthPercent",
1311           screen_number);
1312   screen->saveToolbarWidthPercent(66);
1313   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1314                      &value) &&
1315       sscanf(value.addr, "%d", &int_value) == 1 &&
1316       int_value > 0 && int_value <= 100) {
1317     screen->saveToolbarWidthPercent(int_value);
1318   }
1319
1320   sprintf(name_lookup, "session.screen%d.toolbar.placement", screen_number);
1321   sprintf(class_lookup, "Session.Screen%d.Toolbar.Placement", screen_number);
1322   screen->saveToolbarPlacement(Toolbar::BottomCenter);
1323   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1324                      &value)) {
1325     if (! strncasecmp(value.addr, "TopLeft", value.size))
1326       screen->saveToolbarPlacement(Toolbar::TopLeft);
1327     else if (! strncasecmp(value.addr, "BottomLeft", value.size))
1328       screen->saveToolbarPlacement(Toolbar::BottomLeft);
1329     else if (! strncasecmp(value.addr, "TopCenter", value.size))
1330       screen->saveToolbarPlacement(Toolbar::TopCenter);
1331     else if (! strncasecmp(value.addr, "TopRight", value.size))
1332       screen->saveToolbarPlacement(Toolbar::TopRight);
1333     else if (! strncasecmp(value.addr, "BottomRight", value.size))
1334       screen->saveToolbarPlacement(Toolbar::BottomRight);
1335   }
1336   screen->removeWorkspaceNames();
1337
1338   sprintf(name_lookup,  "session.screen%d.workspaceNames", screen_number);
1339   sprintf(class_lookup, "Session.Screen%d.WorkspaceNames", screen_number);
1340   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1341                      &value)) {
1342     string search = value.addr;
1343     string::const_iterator it = search.begin(),
1344       end = search.end();
1345     while (1) {
1346       string::const_iterator tmp = it; // current string.begin()
1347       it = std::find(tmp, end, ',');   // look for comma between tmp and end
1348       screen->addWorkspaceName(string(tmp, it)); // string = search[tmp:it]
1349       if (it == end) break;
1350       ++it;
1351     }
1352   }
1353
1354   sprintf(name_lookup,  "session.screen%d.toolbar.onTop", screen_number);
1355   sprintf(class_lookup, "Session.Screen%d.Toolbar.OnTop", screen_number);
1356   screen->saveToolbarOnTop(False);
1357   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1358                      &value) &&
1359       ! strncasecmp(value.addr, "true", value.size)) {
1360     screen->saveToolbarOnTop(True);
1361   }
1362
1363   sprintf(name_lookup,  "session.screen%d.toolbar.autoHide", screen_number);
1364   sprintf(class_lookup, "Session.Screen%d.Toolbar.autoHide", screen_number);
1365   screen->saveToolbarAutoHide(False);
1366   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1367                      &value) &&
1368       ! strncasecmp(value.addr, "true", value.size)) {
1369     screen->saveToolbarAutoHide(True);
1370   }
1371
1372   sprintf(name_lookup,  "session.screen%d.focusModel", screen_number);
1373   sprintf(class_lookup, "Session.Screen%d.FocusModel", screen_number);
1374   screen->saveSloppyFocus(True);
1375   screen->saveAutoRaise(False);
1376   screen->saveClickRaise(False);
1377   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1378                      &value)) {
1379     string fmodel = value.addr;
1380
1381     if (fmodel.find("ClickToFocus") != string::npos) {
1382       screen->saveSloppyFocus(False);
1383     } else {
1384       // must be sloppy
1385
1386       if (fmodel.find("AutoRaise") != string::npos)
1387         screen->saveAutoRaise(True);
1388       if (fmodel.find("ClickRaise") != string::npos)
1389         screen->saveClickRaise(True);
1390     }
1391   }
1392
1393   sprintf(name_lookup,  "session.screen%d.windowPlacement", screen_number);
1394   sprintf(class_lookup, "Session.Screen%d.WindowPlacement", screen_number);
1395   screen->savePlacementPolicy(BScreen::RowSmartPlacement);
1396   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1397                      &value)) {
1398     if (! strncasecmp(value.addr, "RowSmartPlacement", value.size))
1399       /* pass */;
1400     else if (! strncasecmp(value.addr, "ColSmartPlacement", value.size))
1401       screen->savePlacementPolicy(BScreen::ColSmartPlacement);
1402     else if (! strncasecmp(value.addr, "CascadePlacement", value.size))
1403       screen->savePlacementPolicy(BScreen::CascadePlacement);
1404   }
1405
1406   sprintf(name_lookup, "session.screen%d.slit.placement", screen_number);
1407   sprintf(class_lookup, "Session.Screen%d.Slit.Placement", screen_number);
1408   screen->saveSlitPlacement(Slit::CenterRight);
1409   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1410                      &value)) {
1411     if (! strncasecmp(value.addr, "TopLeft", value.size))
1412       screen->saveSlitPlacement(Slit::TopLeft);
1413     else if (! strncasecmp(value.addr, "CenterLeft", value.size))
1414       screen->saveSlitPlacement(Slit::CenterLeft);
1415     else if (! strncasecmp(value.addr, "BottomLeft", value.size))
1416       screen->saveSlitPlacement(Slit::BottomLeft);
1417     else if (! strncasecmp(value.addr, "TopCenter", value.size))
1418       screen->saveSlitPlacement(Slit::TopCenter);
1419     else if (! strncasecmp(value.addr, "BottomCenter", value.size))
1420       screen->saveSlitPlacement(Slit::BottomCenter);
1421     else if (! strncasecmp(value.addr, "TopRight", value.size))
1422       screen->saveSlitPlacement(Slit::TopRight);
1423     else if (! strncasecmp(value.addr, "BottomRight", value.size))
1424       screen->saveSlitPlacement(Slit::BottomRight);
1425   }
1426
1427   sprintf(name_lookup, "session.screen%d.slit.direction", screen_number);
1428   sprintf(class_lookup, "Session.Screen%d.Slit.Direction", screen_number);
1429   screen->saveSlitDirection(Slit::Vertical);
1430   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1431                      &value) &&
1432       ! strncasecmp(value.addr, "Horizontal", value.size)) {
1433     screen->saveSlitDirection(Slit::Horizontal);
1434   }
1435
1436   sprintf(name_lookup, "session.screen%d.slit.onTop", screen_number);
1437   sprintf(class_lookup, "Session.Screen%d.Slit.OnTop", screen_number);
1438   screen->saveSlitOnTop(False);
1439   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1440                      &value) &&
1441       ! strncasecmp(value.addr, "True", value.size)) {
1442     screen->saveSlitOnTop(True);
1443   }
1444
1445   sprintf(name_lookup, "session.screen%d.slit.autoHide", screen_number);
1446   sprintf(class_lookup, "Session.Screen%d.Slit.AutoHide", screen_number);
1447   screen->saveSlitAutoHide(False);
1448   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1449                      &value) &&
1450       ! strncasecmp(value.addr, "true", value.size)) {
1451     screen->saveSlitAutoHide(True);
1452   }
1453
1454 #ifdef    HAVE_STRFTIME
1455   sprintf(name_lookup,  "session.screen%d.strftimeFormat", screen_number);
1456   sprintf(class_lookup, "Session.Screen%d.StrftimeFormat", screen_number);
1457   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1458                      &value)) {
1459     screen->saveStrftimeFormat(value.addr);
1460   } else {
1461     screen->saveStrftimeFormat("%I:%M %p");
1462   }
1463 #else //  HAVE_STRFTIME
1464   sprintf(name_lookup,  "session.screen%d.dateFormat", screen_number);
1465   sprintf(class_lookup, "Session.Screen%d.DateFormat", screen_number);
1466   screen->saveDateFormat(B_AmericanDate);
1467   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1468                      &value)) {
1469     if (! strncasecmp(value.addr, "european", value.size))
1470       screen->saveDateFormat(B_EuropeanDate);
1471   }
1472
1473   sprintf(name_lookup,  "session.screen%d.clockFormat", screen_number);
1474   sprintf(class_lookup, "Session.Screen%d.ClockFormat", screen_number);
1475   screen->saveClock24Hour(False);
1476   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1477                      &value) &&
1478       sscanf(value.addr, "%d", &int_value) == 1 && int_value == 24) {
1479     screen->saveClock24Hour(True);
1480   }
1481 #endif // HAVE_STRFTIME
1482
1483   sprintf(name_lookup,  "session.screen%d.edgeSnapThreshold", screen_number);
1484   sprintf(class_lookup, "Session.Screen%d.EdgeSnapThreshold", screen_number);
1485   if (XrmGetResource(database, name_lookup, class_lookup, &value_type,
1486                      &value) &&
1487       sscanf(value.addr, "%d", &int_value) == 1) {
1488     screen->saveEdgeSnapThreshold(int_value);
1489   }
1490
1491   screen->saveImageDither(True);
1492   if (XrmGetResource(database, "session.imageDither", "Session.ImageDither",
1493                      &value_type, &value) &&
1494       ! strncasecmp("false", value.addr, value.size)) {
1495     screen->saveImageDither(False);
1496   }
1497
1498   screen->saveOpaqueMove(False);
1499   if (XrmGetResource(database, "session.opaqueMove", "Session.OpaqueMove",
1500                      &value_type, &value) &&
1501       ! strncasecmp("true", value.addr, value.size)) {
1502     screen->saveOpaqueMove(True);
1503   }
1504
1505   XrmDestroyDatabase(database);
1506 }
1507
1508
1509 void Blackbox::reload_rc(void) {
1510   load_rc();
1511   reconfigure();
1512 }
1513
1514
1515 void Blackbox::reconfigure(void) {
1516   reconfigure_wait = True;
1517
1518   if (! timer->isTiming()) timer->start();
1519 }
1520
1521
1522 void Blackbox::real_reconfigure(void) {
1523   XrmDatabase new_blackboxrc = (XrmDatabase) 0;
1524   char *style = new char[resource.style_file.length() + 20];
1525
1526   sprintf(style, "session.styleFile: %s", getStyleFilename());
1527   XrmPutLineResource(&new_blackboxrc, style);
1528
1529   delete [] style;
1530
1531   XrmDatabase old_blackboxrc = XrmGetFileDatabase(rc_file.c_str());
1532
1533   XrmMergeDatabases(new_blackboxrc, &old_blackboxrc);
1534   XrmPutFileDatabase(old_blackboxrc, rc_file.c_str());
1535   if (old_blackboxrc) XrmDestroyDatabase(old_blackboxrc);
1536
1537   std::for_each(menuTimestamps.begin(), menuTimestamps.end(),
1538                 PointerAssassin());
1539   menuTimestamps.clear();
1540
1541   gcCache()->purge();
1542
1543   std::for_each(screenList.begin(), screenList.end(),
1544                 std::mem_fun(&BScreen::reconfigure));
1545 }
1546
1547
1548 void Blackbox::checkMenu(void) {
1549   bool reread = False;
1550   MenuTimestampList::iterator it = menuTimestamps.begin();
1551   for(; it != menuTimestamps.end(); ++it) {
1552     MenuTimestamp *tmp = *it;
1553     struct stat buf;
1554
1555     if (! stat(tmp->filename.c_str(), &buf)) {
1556       if (tmp->timestamp != buf.st_ctime)
1557         reread = True;
1558     } else {
1559       reread = True;
1560     }
1561   }
1562
1563   if (reread) rereadMenu();
1564 }
1565
1566
1567 void Blackbox::rereadMenu(void) {
1568   reread_menu_wait = True;
1569
1570   if (! timer->isTiming()) timer->start();
1571 }
1572
1573
1574 void Blackbox::real_rereadMenu(void) {
1575   std::for_each(menuTimestamps.begin(), menuTimestamps.end(),
1576                 PointerAssassin());
1577   menuTimestamps.clear();
1578
1579   std::for_each(screenList.begin(), screenList.end(),
1580                 std::mem_fun(&BScreen::rereadMenu));
1581 }
1582
1583
1584 void Blackbox::saveStyleFilename(const string& filename) {
1585   assert(! filename.empty());
1586   resource.style_file = filename;
1587 }
1588
1589
1590 void Blackbox::addMenuTimestamp(const string& filename) {
1591   assert(! filename.empty());
1592   bool found = False;
1593
1594   MenuTimestampList::iterator it = menuTimestamps.begin();
1595   for (; it != menuTimestamps.end() && !found; ++it) {
1596     if ((*it)->filename == filename) found = True;
1597   }
1598   if (! found) {
1599     struct stat buf;
1600
1601     if (! stat(filename.c_str(), &buf)) {
1602       MenuTimestamp *ts = new MenuTimestamp;
1603
1604       ts->filename = filename;
1605       ts->timestamp = buf.st_ctime;
1606
1607       menuTimestamps.push_back(ts);
1608     }
1609   }
1610 }
1611
1612
1613 void Blackbox::timeout(void) {
1614   if (reconfigure_wait)
1615     real_reconfigure();
1616
1617   if (reread_menu_wait)
1618     real_rereadMenu();
1619
1620   reconfigure_wait = reread_menu_wait = False;
1621 }
1622
1623
1624 void Blackbox::setFocusedWindow(BlackboxWindow *win) {
1625   if (focused_window && focused_window == win) // nothing to do
1626     return;
1627
1628   BScreen *old_screen = 0;
1629
1630   if (focused_window) {
1631     focused_window->setFocusFlag(False);
1632     old_screen = focused_window->getScreen();
1633   }
1634
1635   if (win && ! win->isIconic()) {
1636     // the active screen is the one with the last focused window...
1637     // this will keep focus on this screen no matter where the mouse goes,
1638     // so multihead keybindings will continue to work on that screen until the
1639     // user focuses a window on a different screen.
1640     active_screen = win->getScreen();
1641     focused_window = win;
1642   } else {
1643     focused_window = 0;
1644     if (! old_screen) {
1645       if (active_screen) {
1646         // set input focus to the toolbar of the screen with mouse
1647         XSetInputFocus(getXDisplay(),
1648                        active_screen->getToolbar()->getWindowID(),
1649                        RevertToPointerRoot, CurrentTime);
1650       } else {
1651         // set input focus to the toolbar of the first managed screen
1652         XSetInputFocus(getXDisplay(),
1653                        screenList.front()->getToolbar()->getWindowID(),
1654                        RevertToPointerRoot, CurrentTime);
1655       }
1656     } else {
1657       // set input focus to the toolbar of the last screen
1658       XSetInputFocus(getXDisplay(), old_screen->getToolbar()->getWindowID(),
1659                      RevertToPointerRoot, CurrentTime);
1660     }
1661   }
1662
1663   if (active_screen && active_screen->isScreenManaged()) {
1664     active_screen->getToolbar()->redrawWindowLabel(True);
1665     active_screen->updateNetizenWindowFocus();
1666   }
1667
1668   if (old_screen && old_screen != active_screen) {
1669     old_screen->getToolbar()->redrawWindowLabel(True);
1670     old_screen->updateNetizenWindowFocus();
1671   }
1672 }