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

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