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   load_rc();
 201
 202 #ifdef    HAVE_GETPID
 203   openbox_pid = XInternAtom(getXDisplay(), "_BLACKBOX_PID", False);
 204 #endif // HAVE_GETPID
 205
 206   screenList = new LinkedList<BScreen>;
 207   for (int i = 0; i < getNumberOfScreens(); i++) {
 208     BScreen *screen = new BScreen(this, i);
 209
 210     if (! screen->isScreenManaged()) {
 211       delete screen;
 212       continue;
 213     }
 214
 215     screenList->insert(screen);
 216   }
 217
 218   if (! screenList->count()) {
 219     fprintf(stderr,
 220             i18n->getMessage(openboxSet, openboxNoManagableScreens,
 221                "Openbox::Openbox: no managable screens found, aborting.\n"));
 222     ::exit(3);
 223   }
 224
 225   XSynchronize(getXDisplay(), False);
 226   XSync(getXDisplay(), False);
 227
 228   reconfigure_wait = reread_menu_wait = False;
 229
 230   timer = new BTimer(this, this);
 231   timer->setTimeout(0);
 232   timer->fireOnce(True);
 233
 234   ungrab();
 235 }
 236
 237
 238 Openbox::~Openbox(void) {
 239   while (screenList->count())
 240     delete screenList->remove(0);
 241
 242   while (menuTimestamps->count()) {
 243     MenuTimestamp *ts = menuTimestamps->remove(0);
 244
 245     if (ts->filename)
 246       delete [] ts->filename;
 247
 248     delete ts;
 249   }
 250
 251   if (resource.menu_file)
 252     delete [] resource.menu_file;
 253
 254   if (resource.style_file)
 255     delete [] resource.style_file;
 256
 257   delete timer;
 258
 259   delete screenList;
 260   delete menuTimestamps;
 261
 262   delete windowSearchList;
 263   delete menuSearchList;
 264   delete toolbarSearchList;
 265   delete groupSearchList;
 266
 267   delete [] rc_file;
 268
 269 #ifdef    SLIT
 270   delete slitSearchList;
 271 #endif // SLIT
 272 }
 273
 274
 275 void Openbox::process_event(XEvent *e) {
 276   if ((masked == e->xany.window) && masked_window &&
 277       (e->type == MotionNotify)) {
 278     last_time = e->xmotion.time;
 279     masked_window->motionNotifyEvent(&e->xmotion);
 280
 281     return;
 282   }
 283
 284   switch (e->type) {
 285   case ButtonPress: {
 286     // strip the lock key modifiers
 287     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
 288
 289     last_time = e->xbutton.time;
 290
 291     OpenboxWindow *win = (OpenboxWindow *) 0;
 292     Basemenu *menu = (Basemenu *) 0;
 293
 294 #ifdef    SLIT
 295     Slit *slit = (Slit *) 0;
 296 #endif // SLIT
 297
 298     Toolbar *tbar = (Toolbar *) 0;
 299
 300     if ((win = searchWindow(e->xbutton.window))) {
 301       win->buttonPressEvent(&e->xbutton);
 302
 303       if (e->xbutton.button == 1)
 304         win->installColormap(True);
 305     } else if ((menu = searchMenu(e->xbutton.window))) {
 306       menu->buttonPressEvent(&e->xbutton);
 307
 308 #ifdef    SLIT
 309     } else if ((slit = searchSlit(e->xbutton.window))) {
 310       slit->buttonPressEvent(&e->xbutton);
 311 #endif // SLIT
 312
 313     } else if ((tbar = searchToolbar(e->xbutton.window))) {
 314       tbar->buttonPressEvent(&e->xbutton);
 315     } else {
 316       LinkedListIterator<BScreen> it(screenList);
 317       BScreen *screen = it.current();
 318       for (; screen; it++, screen = it.current()) {
 319         if (e->xbutton.window == screen->getRootWindow()) {
 320           if (e->xbutton.button == 1) {
 321             if (! screen->isRootColormapInstalled())
 322               screen->getImageControl()->installRootColormap();
 323
 324             if (screen->getWorkspacemenu()->isVisible())
 325               screen->getWorkspacemenu()->hide();
 326
 327             if (screen->getRootmenu()->isVisible())
 328               screen->getRootmenu()->hide();
 329           } else if (e->xbutton.button == 2) {
 330             int mx = e->xbutton.x_root -
 331               (screen->getWorkspacemenu()->getWidth() / 2);
 332             int my = e->xbutton.y_root -
 333               (screen->getWorkspacemenu()->getTitleHeight() / 2);
 334
 335             if (mx < 0) mx = 0;
 336             if (my < 0) my = 0;
 337
 338             if (mx + screen->getWorkspacemenu()->getWidth() >
 339                 screen->getWidth())
 340               mx = screen->getWidth() -
 341                 screen->getWorkspacemenu()->getWidth() -
 342                 screen->getBorderWidth();
 343
 344             if (my + screen->getWorkspacemenu()->getHeight() >
 345                 screen->getHeight())
 346               my = screen->getHeight() -
 347                 screen->getWorkspacemenu()->getHeight() -
 348                 screen->getBorderWidth();
 349
 350             screen->getWorkspacemenu()->move(mx, my);
 351
 352             if (! screen->getWorkspacemenu()->isVisible()) {
 353               screen->getWorkspacemenu()->removeParent();
 354               screen->getWorkspacemenu()->show();
 355             }
 356           } else if (e->xbutton.button == 3) {
 357             int mx = e->xbutton.x_root -
 358               (screen->getRootmenu()->getWidth() / 2);
 359             int my = e->xbutton.y_root -
 360               (screen->getRootmenu()->getTitleHeight() / 2);
 361
 362             if (mx < 0) mx = 0;
 363             if (my < 0) my = 0;
 364
 365             if (mx + screen->getRootmenu()->getWidth() > screen->getWidth())
 366               mx = screen->getWidth() -
 367                 screen->getRootmenu()->getWidth() -
 368                 screen->getBorderWidth();
 369
 370             if (my + screen->getRootmenu()->getHeight() > screen->getHeight())
 371                 my = screen->getHeight() -
 372                   screen->getRootmenu()->getHeight() -
 373                   screen->getBorderWidth();
 374
 375             screen->getRootmenu()->move(mx, my);
 376
 377             if (! screen->getRootmenu()->isVisible()) {
 378               checkMenu();
 379               screen->getRootmenu()->show();
 380             }
 381           } else if (e->xbutton.button == 4) {
 382             if ((screen->getCurrentWorkspaceID()-1)<0)
 383               screen->changeWorkspaceID(screen->getWorkspaceCount()-1);
 384             else
 385               screen->changeWorkspaceID(screen->getCurrentWorkspaceID()-1);
 386           } else if (e->xbutton.button == 5) {
 387             if ((screen->getCurrentWorkspaceID()+1)>screen->getWorkspaceCount()-1)
 388               screen->changeWorkspaceID(0);
 389             else
 390               screen->changeWorkspaceID(screen->getCurrentWorkspaceID()+1);
 391           }
 392         }
 393       }
 394     }
 395
 396     break;
 397   }
 398
 399   case ButtonRelease: {
 400     // strip the lock key modifiers
 401     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
 402
 403     last_time = e->xbutton.time;
 404
 405     OpenboxWindow *win = (OpenboxWindow *) 0;
 406     Basemenu *menu = (Basemenu *) 0;
 407     Toolbar *tbar = (Toolbar *) 0;
 408
 409     if ((win = searchWindow(e->xbutton.window)))
 410       win->buttonReleaseEvent(&e->xbutton);
 411     else if ((menu = searchMenu(e->xbutton.window)))
 412       menu->buttonReleaseEvent(&e->xbutton);
 413     else if ((tbar = searchToolbar(e->xbutton.window)))
 414       tbar->buttonReleaseEvent(&e->xbutton);
 415
 416     break;
 417   }
 418
 419   case ConfigureRequest: {
 420     OpenboxWindow *win = (OpenboxWindow *) 0;
 421
 422 #ifdef    SLIT
 423     Slit *slit = (Slit *) 0;
 424 #endif // SLIT
 425
 426     if ((win = searchWindow(e->xconfigurerequest.window))) {
 427       win->configureRequestEvent(&e->xconfigurerequest);
 428
 429 #ifdef    SLIT
 430     } else if ((slit = searchSlit(e->xconfigurerequest.window))) {
 431       slit->configureRequestEvent(&e->xconfigurerequest);
 432 #endif // SLIT
 433
 434     } else {
 435       grab();
 436
 437       if (validateWindow(e->xconfigurerequest.window)) {
 438         XWindowChanges xwc;
 439
 440         xwc.x = e->xconfigurerequest.x;
 441         xwc.y = e->xconfigurerequest.y;
 442         xwc.width = e->xconfigurerequest.width;
 443         xwc.height = e->xconfigurerequest.height;
 444         xwc.border_width = e->xconfigurerequest.border_width;
 445         xwc.sibling = e->xconfigurerequest.above;
 446         xwc.stack_mode = e->xconfigurerequest.detail;
 447
 448         XConfigureWindow(getXDisplay(), e->xconfigurerequest.window,
 449                          e->xconfigurerequest.value_mask, &xwc);
 450       }
 451
 452       ungrab();
 453     }
 454
 455     break;
 456   }
 457
 458   case MapRequest: {
 459 #ifdef    DEBUG
 460     fprintf(stderr,
 461             i18n->getMessage(openboxSet, openboxMapRequest,
 462                  "Openbox::process_event(): MapRequest for 0x%lx\n"),
 463             e->xmaprequest.window);
 464 #endif // DEBUG
 465
 466     OpenboxWindow *win = searchWindow(e->xmaprequest.window);
 467
 468     if (! win)
 469       win = new OpenboxWindow(this, e->xmaprequest.window);
 470
 471     if ((win = searchWindow(e->xmaprequest.window)))
 472       win->mapRequestEvent(&e->xmaprequest);
 473
 474     break;
 475   }
 476
 477   case MapNotify: {
 478     OpenboxWindow *win = searchWindow(e->xmap.window);
 479
 480     if (win)
 481       win->mapNotifyEvent(&e->xmap);
 482
 483       break;
 484   }
 485
 486   case UnmapNotify: {
 487     OpenboxWindow *win = (OpenboxWindow *) 0;
 488
 489 #ifdef    SLIT
 490     Slit *slit = (Slit *) 0;
 491 #endif // SLIT
 492
 493     if ((win = searchWindow(e->xunmap.window))) {
 494       win->unmapNotifyEvent(&e->xunmap);
 495       if (focused_window == win)
 496         focused_window = (OpenboxWindow *) 0;
 497 #ifdef    SLIT
 498     } else if ((slit = searchSlit(e->xunmap.window))) {
 499       slit->removeClient(e->xunmap.window);
 500 #endif // SLIT
 501
 502     }
 503
 504     break;
 505   }
 506
 507   case DestroyNotify: {
 508     OpenboxWindow *win = (OpenboxWindow *) 0;
 509
 510 #ifdef    SLIT
 511     Slit *slit = (Slit *) 0;
 512 #endif // SLIT
 513
 514     if ((win = searchWindow(e->xdestroywindow.window))) {
 515       win->destroyNotifyEvent(&e->xdestroywindow);
 516       if (focused_window == win)
 517         focused_window = (OpenboxWindow *) 0;
 518 #ifdef    SLIT
 519     } else if ((slit = searchSlit(e->xdestroywindow.window))) {
 520       slit->removeClient(e->xdestroywindow.window, False);
 521 #endif // SLIT
 522     }
 523
 524     break;
 525   }
 526
 527   case MotionNotify: {
 528     // strip the lock key modifiers
 529     e->xbutton.state &= ~(NumLockMask | ScrollLockMask | LockMask);
 530
 531     last_time = e->xmotion.time;
 532
 533     OpenboxWindow *win = (OpenboxWindow *) 0;
 534     Basemenu *menu = (Basemenu *) 0;
 535
 536     if ((win = searchWindow(e->xmotion.window)))
 537       win->motionNotifyEvent(&e->xmotion);
 538     else if ((menu = searchMenu(e->xmotion.window)))
 539       menu->motionNotifyEvent(&e->xmotion);
 540
 541     break;
 542   }
 543
 544   case PropertyNotify: {
 545     last_time = e->xproperty.time;
 546
 547     if (e->xproperty.state != PropertyDelete) {
 548       OpenboxWindow *win = searchWindow(e->xproperty.window);
 549
 550       if (win)
 551         win->propertyNotifyEvent(e->xproperty.atom);
 552     }
 553
 554     break;
 555   }
 556
 557   case EnterNotify: {
 558     last_time = e->xcrossing.time;
 559
 560     BScreen *screen = (BScreen *) 0;
 561     OpenboxWindow *win = (OpenboxWindow *) 0;
 562     Basemenu *menu = (Basemenu *) 0;
 563     Toolbar *tbar = (Toolbar *) 0;
 564
 565 #ifdef    SLIT
 566     Slit *slit = (Slit *) 0;
 567 #endif // SLIT
 568
 569     if (e->xcrossing.mode == NotifyGrab) break;
 570
 571     XEvent dummy;
 572     scanargs sa;
 573     sa.w = e->xcrossing.window;
 574     sa.enter = sa.leave = False;
 575     XCheckIfEvent(getXDisplay(), &dummy, queueScanner, (char *) &sa);
 576
 577     if ((e->xcrossing.window == e->xcrossing.root) &&
 578         (screen = searchScreen(e->xcrossing.window))) {
 579       screen->getImageControl()->installRootColormap();
 580     } else if ((win = searchWindow(e->xcrossing.window))) {
 581       if (win->getScreen()->isSloppyFocus() &&
 582           (! win->isFocused()) && (! no_focus)) {
 583         grab();
 584
 585         if (((! sa.leave) || sa.inferior) && win->isVisible() &&
 586             win->setInputFocus())
 587           win->installColormap(True);
 588
 589         ungrab();
 590       }
 591     } else if ((menu = searchMenu(e->xcrossing.window))) {
 592       menu->enterNotifyEvent(&e->xcrossing);
 593     } else if ((tbar = searchToolbar(e->xcrossing.window))) {
 594       tbar->enterNotifyEvent(&e->xcrossing);
 595 #ifdef    SLIT
 596     } else if ((slit = searchSlit(e->xcrossing.window))) {
 597       slit->enterNotifyEvent(&e->xcrossing);
 598 #endif // SLIT
 599     }
 600     break;
 601   }
 602
 603   case LeaveNotify: {
 604     last_time = e->xcrossing.time;
 605
 606     OpenboxWindow *win = (OpenboxWindow *) 0;
 607     Basemenu *menu = (Basemenu *) 0;
 608     Toolbar *tbar = (Toolbar *) 0;
 609
 610 #ifdef    SLIT
 611     Slit *slit = (Slit *) 0;
 612 #endif // SLIT
 613
 614     if ((menu = searchMenu(e->xcrossing.window)))
 615       menu->leaveNotifyEvent(&e->xcrossing);
 616     else if ((win = searchWindow(e->xcrossing.window)))
 617       win->installColormap(False);
 618     else if ((tbar = searchToolbar(e->xcrossing.window)))
 619       tbar->leaveNotifyEvent(&e->xcrossing);
 620 #ifdef    SLIT
 621     else if ((slit = searchSlit(e->xcrossing.window)))
 622       slit->leaveNotifyEvent(&e->xcrossing);
 623 #endif // SLIT
 624
 625     break;
 626   }
 627
 628   case Expose: {
 629     OpenboxWindow *win = (OpenboxWindow *) 0;
 630     Basemenu *menu = (Basemenu *) 0;
 631     Toolbar *tbar = (Toolbar *) 0;
 632
 633     if ((win = searchWindow(e->xexpose.window)))
 634       win->exposeEvent(&e->xexpose);
 635     else if ((menu = searchMenu(e->xexpose.window)))
 636       menu->exposeEvent(&e->xexpose);
 637     else if ((tbar = searchToolbar(e->xexpose.window)))
 638       tbar->exposeEvent(&e->xexpose);
 639
 640     break;
 641   }
 642
 643   case KeyPress: {
 644     Toolbar *tbar = searchToolbar(e->xkey.window);
 645
 646     if (tbar && tbar->isEditing())
 647       tbar->keyPressEvent(&e->xkey);
 648
 649     break;
 650   }
 651
 652   case ColormapNotify: {
 653     BScreen *screen = searchScreen(e->xcolormap.window);
 654
 655     if (screen)
 656       screen->setRootColormapInstalled((e->xcolormap.state ==
 657                                         ColormapInstalled) ? True : False);
 658
 659     break;
 660   }
 661
 662   case FocusIn: {
 663     if (e->xfocus.mode == NotifyUngrab || e->xfocus.detail == NotifyPointer)
 664       break;
 665
 666     OpenboxWindow *win = searchWindow(e->xfocus.window);
 667     if (win && ! win->isFocused())
 668       setFocusedWindow(win);
 669
 670     break;
 671   }
 672
 673   case FocusOut:
 674     break;
 675
 676   case ClientMessage: {
 677     if (e->xclient.format == 32) {
 678       if (e->xclient.message_type == getWMChangeStateAtom()) {
 679         OpenboxWindow *win = searchWindow(e->xclient.window);
 680         if (! win || ! win->validateClient()) return;
 681
 682         if (e->xclient.data.l[0] == IconicState)
 683           win->iconify();
 684         if (e->xclient.data.l[0] == NormalState)
 685           win->deiconify();
 686       } else if (e->xclient.message_type == getOpenboxChangeWorkspaceAtom()) {
 687         BScreen *screen = searchScreen(e->xclient.window);
 688
 689         if (screen && e->xclient.data.l[0] >= 0 &&
 690             e->xclient.data.l[0] < screen->getWorkspaceCount())
 691           screen->changeWorkspaceID(e->xclient.data.l[0]);
 692       } else if (e->xclient.message_type == getOpenboxChangeWindowFocusAtom()) {
 693         OpenboxWindow *win = searchWindow(e->xclient.window);
 694
 695         if (win && win->isVisible() && win->setInputFocus())
 696           win->installColormap(True);
 697       } else if (e->xclient.message_type == getOpenboxCycleWindowFocusAtom()) {
 698         BScreen *screen = searchScreen(e->xclient.window);
 699
 700         if (screen) {
 701           if (! e->xclient.data.l[0])
 702             screen->prevFocus();
 703           else
 704             screen->nextFocus();
 705         }
 706       } else if (e->xclient.message_type == getOpenboxChangeAttributesAtom()) {
 707         OpenboxWindow *win = searchWindow(e->xclient.window);
 708
 709         if (win && win->validateClient()) {
 710           OpenboxHints net;
 711           net.flags = e->xclient.data.l[0];
 712           net.attrib = e->xclient.data.l[1];
 713           net.workspace = e->xclient.data.l[2];
 714           net.stack = e->xclient.data.l[3];
 715           net.decoration = e->xclient.data.l[4];
 716
 717           win->changeOpenboxHints(&net);
 718         }
 719       }
 720     }
 721
 722     break;
 723   }
 724
 725
 726   default: {
 727 #ifdef    SHAPE
 728     if (e->type == getShapeEventBase()) {
 729       XShapeEvent *shape_event = (XShapeEvent *) e;
 730       OpenboxWindow *win = (OpenboxWindow *) 0;
 731
 732       if ((win = searchWindow(e->xany.window)) ||
 733           (shape_event->kind != ShapeBounding))
 734         win->shapeEvent(shape_event);
 735     }
 736 #endif // SHAPE
 737
 738   }
 739   } // switch
 740 }
 741
 742
 743 Bool Openbox::handleSignal(int sig) {
 744   switch (sig) {
 745   case SIGHUP:
 746     reconfigure();
 747     break;
 748
 749   case SIGUSR1:
 750     reload_rc();
 751     break;
 752
 753   case SIGUSR2:
 754     rereadMenu();
 755     break;
 756
 757   case SIGPIPE:
 758   case SIGSEGV:
 759   case SIGFPE:
 760   case SIGINT:
 761   case SIGTERM:
 762     shutdown();
 763
 764   default:
 765     return False;
 766   }
 767
 768   return True;
 769 }
 770
 771
 772 BScreen *Openbox::searchScreen(Window window) {
 773   LinkedListIterator<BScreen> it(screenList);
 774
 775   for (BScreen *curr = it.current(); curr; it++, curr = it.current()) {
 776     if (curr->getRootWindow() == window) {
 777       return curr;
 778     }
 779   }
 780
 781   return (BScreen *) 0;
 782 }
 783
 784
 785 OpenboxWindow *Openbox::searchWindow(Window window) {
 786   LinkedListIterator<WindowSearch> it(windowSearchList);
 787
 788   for (WindowSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 789       if (tmp->getWindow() == window) {
 790         return tmp->getData();
 791       }
 792   }
 793
 794   return (OpenboxWindow *) 0;
 795 }
 796
 797
 798 OpenboxWindow *Openbox::searchGroup(Window window, OpenboxWindow *win) {
 799   OpenboxWindow *w = (OpenboxWindow *) 0;
 800   LinkedListIterator<WindowSearch> it(groupSearchList);
 801
 802   for (WindowSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 803     if (tmp->getWindow() == window) {
 804       w = tmp->getData();
 805       if (w->getClientWindow() != win->getClientWindow())
 806         return win;
 807     }
 808   }
 809
 810   return (OpenboxWindow *) 0;
 811 }
 812
 813
 814 Basemenu *Openbox::searchMenu(Window window) {
 815   LinkedListIterator<MenuSearch> it(menuSearchList);
 816
 817   for (MenuSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 818     if (tmp->getWindow() == window)
 819       return tmp->getData();
 820   }
 821
 822   return (Basemenu *) 0;
 823 }
 824
 825
 826 Toolbar *Openbox::searchToolbar(Window window) {
 827   LinkedListIterator<ToolbarSearch> it(toolbarSearchList);
 828
 829   for (ToolbarSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 830     if (tmp->getWindow() == window)
 831       return tmp->getData();
 832   }
 833
 834   return (Toolbar *) 0;
 835 }
 836
 837
 838 #ifdef    SLIT
 839 Slit *Openbox::searchSlit(Window window) {
 840   LinkedListIterator<SlitSearch> it(slitSearchList);
 841
 842   for (SlitSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 843     if (tmp->getWindow() == window)
 844       return tmp->getData();
 845   }
 846
 847   return (Slit *) 0;
 848 }
 849 #endif // SLIT
 850
 851
 852 void Openbox::saveWindowSearch(Window window, OpenboxWindow *data) {
 853   windowSearchList->insert(new WindowSearch(window, data));
 854 }
 855
 856
 857 void Openbox::saveGroupSearch(Window window, OpenboxWindow *data) {
 858   groupSearchList->insert(new WindowSearch(window, data));
 859 }
 860
 861
 862 void Openbox::saveMenuSearch(Window window, Basemenu *data) {
 863   menuSearchList->insert(new MenuSearch(window, data));
 864 }
 865
 866
 867 void Openbox::saveToolbarSearch(Window window, Toolbar *data) {
 868   toolbarSearchList->insert(new ToolbarSearch(window, data));
 869 }
 870
 871
 872 #ifdef    SLIT
 873 void Openbox::saveSlitSearch(Window window, Slit *data) {
 874   slitSearchList->insert(new SlitSearch(window, data));
 875 }
 876 #endif // SLIT
 877
 878
 879 void Openbox::removeWindowSearch(Window window) {
 880   LinkedListIterator<WindowSearch> it(windowSearchList);
 881   for (WindowSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 882     if (tmp->getWindow() == window) {
 883       windowSearchList->remove(tmp);
 884       delete tmp;
 885       break;
 886     }
 887   }
 888 }
 889
 890
 891 void Openbox::removeGroupSearch(Window window) {
 892   LinkedListIterator<WindowSearch> it(groupSearchList);
 893   for (WindowSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 894     if (tmp->getWindow() == window) {
 895       groupSearchList->remove(tmp);
 896       delete tmp;
 897       break;
 898     }
 899   }
 900 }
 901
 902
 903 void Openbox::removeMenuSearch(Window window) {
 904   LinkedListIterator<MenuSearch> it(menuSearchList);
 905   for (MenuSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 906     if (tmp->getWindow() == window) {
 907       menuSearchList->remove(tmp);
 908       delete tmp;
 909       break;
 910     }
 911   }
 912 }
 913
 914
 915 void Openbox::removeToolbarSearch(Window window) {
 916   LinkedListIterator<ToolbarSearch> it(toolbarSearchList);
 917   for (ToolbarSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 918     if (tmp->getWindow() == window) {
 919       toolbarSearchList->remove(tmp);
 920       delete tmp;
 921       break;
 922     }
 923   }
 924 }
 925
 926
 927 #ifdef    SLIT
 928 void Openbox::removeSlitSearch(Window window) {
 929   LinkedListIterator<SlitSearch> it(slitSearchList);
 930   for (SlitSearch *tmp = it.current(); tmp; it++, tmp = it.current()) {
 931     if (tmp->getWindow() == window) {
 932       slitSearchList->remove(tmp);
 933       delete tmp;
 934       break;
 935     }
 936   }
 937 }
 938 #endif // SLIT
 939
 940
 941 void Openbox::restart(const char *prog) {
 942   shutdown();
 943
 944   if (prog) {
 945     execlp(prog, prog, NULL);
 946     perror(prog);
 947   }
 948
 949   // fall back in case the above execlp doesn't work
 950   execvp(argv[0], argv);
 951   execvp(basename(argv[0]), argv);
 952 }
 953
 954
 955 void Openbox::shutdown(void) {
 956   BaseDisplay::shutdown();
 957
 958   XSetInputFocus(getXDisplay(), PointerRoot, None, CurrentTime);
 959
 960   LinkedListIterator<BScreen> it(screenList);
 961   for (BScreen *s = it.current(); s; it++, s = it.current())
 962     s->shutdown();
 963
 964   XSync(getXDisplay(), False);
 965
 966   save_rc();
 967 }
 968
 969
 970 void Openbox::save_rc(void) {
 971   config.setAutoSave(false);
 972
 973   config.setValue("session.menuFile", getMenuFilename());
 974   config.setValue("session.colorsPerChannel",
 975                   resource.colors_per_channel);
 976   config.setValue("session.doubleClickInterval",
 977                   (long)resource.double_click_interval);
 978   config.setValue("session.autoRaiseDelay",
 979           ((resource.auto_raise_delay.tv_sec * 1000) +
 980            (resource.auto_raise_delay.tv_usec / 1000)));
 981   config.setValue("session.cacheLife", (long)resource.cache_life / 60000);
 982   config.setValue("session.cacheMax", (long)resource.cache_max);
 983
 984   LinkedListIterator<BScreen> it(screenList);
 985   for (BScreen *screen = it.current(); screen; it++, screen = it.current()) {
 986 //  ScreenList::iterator it = screenList.begin();
 987 //  for (; it != screenList.end(); ++it) {
 988 //    BScreen *screen = *it;
 989     char rc_string[1024];
 990     const int screen_number = screen->getScreenNumber();
 991
 992     char *placement = (char *) 0;
 993
 994     switch (screen->getSlitPlacement()) {
 995     case Slit::TopLeft: placement = "TopLeft"; break;
 996     case Slit::CenterLeft: placement = "CenterLeft"; break;
 997     case Slit::BottomLeft: placement = "BottomLeft"; break;
 998     case Slit::TopCenter: placement = "TopCenter"; break;
 999     case Slit::BottomCenter: placement = "BottomCenter"; break;
1000     case Slit::TopRight: placement = "TopRight"; break;
1001     case Slit::BottomRight: placement = "BottomRight"; break;
1002     case Slit::CenterRight: default: placement = "CenterRight"; break;
1003     }
1004     sprintf(rc_string, "session.screen%d.slit.placement", screen_number);
1005     config.setValue(rc_string, placement);
1006
1007     sprintf(rc_string, "session.screen%d.slit.direction", screen_number);
1008     config.setValue(rc_string,
1009                     screen->getSlitDirection() == Slit::Horizontal ?
1010                     "Horizontal" : "Vertical");
1011
1012     sprintf(rc_string, "session.screen%d.slit.onTop", screen_number);
1013     config.setValue(rc_string, screen->getSlit()->isOnTop() ? "True" : "False");
1014
1015     sprintf(rc_string, "session.screen%d.slit.autoHide", screen_number);
1016     config.setValue(rc_string, screen->getSlit()->doAutoHide() ?
1017                     "True" : "False");
1018
1019     config.setValue("session.opaqueMove",
1020                     (screen->doOpaqueMove()) ? "True" : "False");
1021     config.setValue("session.imageDither",
1022                     (screen->getImageControl()->doDither()) ? "True" : "False");
1023
1024     sprintf(rc_string, "session.screen%d.fullMaximization", screen_number);
1025     config.setValue(rc_string, screen->doFullMax() ? "True" : "False");
1026
1027     sprintf(rc_string, "session.screen%d.focusNewWindows", screen_number);
1028     config.setValue(rc_string, screen->doFocusNew() ? "True" : "False");
1029
1030     sprintf(rc_string, "session.screen%d.focusLastWindow", screen_number);
1031     config.setValue(rc_string, screen->doFocusLast() ? "True" : "False");
1032
1033     sprintf(rc_string, "session.screen%d.rowPlacementDirection", screen_number);
1034     config.setValue(rc_string,
1035                     screen->getRowPlacementDirection() == BScreen::LeftRight ?
1036                     "LeftToRight" : "RightToLeft");
1037
1038     sprintf(rc_string, "session.screen%d.colPlacementDirection", screen_number);
1039     config.setValue(rc_string,
1040                     screen->getColPlacementDirection() == BScreen::TopBottom ?
1041                     "TopToBottom" : "BottomToTop");
1042
1043     switch (screen->getPlacementPolicy()) {
1044     case BScreen::CascadePlacement: placement = "CascadePlacement"; break;
1045     case BScreen::ColSmartPlacement: placement = "ColSmartPlacement"; break;
1046     default:
1047     case BScreen::RowSmartPlacement: placement = "RowSmartPlacement"; break;
1048     }
1049     sprintf(rc_string, "session.screen%d.windowPlacement", screen_number);
1050     config.setValue(rc_string, placement);
1051
1052     sprintf(rc_string, "session.screen%d.focusModel", screen_number);
1053     config.setValue(rc_string,
1054                     (screen->isSloppyFocus() ?
1055                      (screen->doAutoRaise() ? "AutoRaiseSloppyFocus" :
1056                       "SloppyFocus") : "ClickToFocus"));
1057
1058     sprintf(rc_string, "session.screen%d.workspaces", screen_number);
1059     config.setValue(rc_string, screen->getWorkspaceCount());
1060
1061     sprintf(rc_string, "session.screen%d.toolbar.onTop", screen_number);
1062     config.setValue(rc_string, screen->getToolbar()->isOnTop() ?
1063                     "True" : "False");
1064
1065     sprintf(rc_string, "session.screen%d.toolbar.autoHide", screen_number);
1066     config.setValue(rc_string, screen->getToolbar()->doAutoHide() ?
1067                     "True" : "False");
1068
1069     switch (screen->getToolbarPlacement()) {
1070     case Toolbar::TopLeft: placement = "TopLeft"; break;
1071     case Toolbar::BottomLeft: placement = "BottomLeft"; break;
1072     case Toolbar::TopCenter: placement = "TopCenter"; break;
1073     case Toolbar::TopRight: placement = "TopRight"; break;
1074     case Toolbar::BottomRight: placement = "BottomRight"; break;
1075     default:
1076     case Toolbar::BottomCenter: placement = "BottomCenter"; break;
1077     }
1078
1079     sprintf(rc_string, "session.screen%d.toolbar.placement", screen_number);
1080     config.setValue(rc_string, placement);
1081
1082 #ifdef    HAVE_STRFTIME
1083     sprintf(rc_string, "session.screen%d.strftimeFormat", screen_number);
1084     config.setValue(rc_string, screen->getStrftimeFormat());
1085 #else // !HAVE_STRFTIME
1086     sprintf(rc_string, "session.screen%d.dateFormat", screen_number);
1087     config.setValue(rc_string, screen->getDateFormat() == B_EuropeanDate ?
1088                     "European" : "American");
1089
1090     sprintf(rc_string, "session.screen%d.clockFormat", screen_number);
1091     config.setValue(rc_string, screen->isClock24Hour() ? 24 : 12);
1092 #endif // HAVE_STRFTIME
1093
1094     sprintf(rc_string, "session.screen%d.edgeSnapThreshold", screen_number);
1095     config.setValue(rc_string, screen->getEdgeSnapThreshold());
1096
1097     sprintf(rc_string, "session.screen%d.toolbar.widthPercent", screen_number);
1098     config.setValue(rc_string, screen->getToolbarWidthPercent());
1099
1100     // write out the user's workspace names
1101     int i, len = 0;
1102     for (i = 0; i < screen->getWorkspaceCount(); i++)
1103       len += strlen((screen->getWorkspace(i)->getName()) ?
1104         screen->getWorkspace(i)->getName() : "Null") + 1;
1105
1106     char *resource_string = new char[len + 1024],
1107       *save_string = new char[len], *save_string_pos = save_string,
1108       *name_string_pos;
1109     if (save_string) {
1110       for (i = 0; i < screen->getWorkspaceCount(); i++) {
1111         len = strlen((screen->getWorkspace(i)->getName()) ?
1112          screen->getWorkspace(i)->getName() : "Null") + 1;
1113         name_string_pos =
1114           (char *) ((screen->getWorkspace(i)->getName()) ?
1115                     screen->getWorkspace(i)->getName() : "Null");
1116
1117         while (--len) *(save_string_pos++) = *(name_string_pos++);
1118         *(save_string_pos++) = ',';
1119       }
1120     }
1121
1122     *(--save_string_pos) = '\0';
1123
1124     sprintf(resource_string, "session.screen%d.workspaceNames", screen_number);
1125     config.setValue(resource_string, save_string);
1126
1127     delete [] resource_string;
1128     delete [] save_string;
1129 /*
1130     std::string save_string = screen->getWorkspace(0)->getName();
1131     for (unsigned int i = 1; i < screen->getWorkspaceCount(); ++i) {
1132       save_string += ',';
1133       save_string += screen->getWorkspace(i)->getName();
1134     }
1135
1136     char *resource_string = new char[save_string.length() + 48];
1137     sprintf(resource_string, "session.screen%d.workspaceNames", screen_number);
1138     config.setValue(rc_string, save_string);
1139
1140     delete [] resource_string;*/
1141   }
1142
1143   config.setAutoSave(true);
1144   config.save();
1145 }
1146
1147 void Openbox::load_rc(void) {
1148   if (!config.load())
1149     return;
1150
1151   std::string s;
1152   long l;
1153
1154   if (resource.menu_file)
1155     delete [] resource.menu_file;
1156   if (config.getValue("session.menuFile", "Session.MenuFile", s))
1157     resource.menu_file = bstrdup(s.c_str());
1158   else
1159     resource.menu_file = bstrdup(DEFAULTMENU);
1160
1161   if (config.getValue("session.colorsPerChannel", "Session.ColorsPerChannel",
1162                       l))
1163     resource.colors_per_channel = (l < 2 ? 2 : (l > 6 ? 6 : l)); // >= 2, <= 6
1164   else
1165     resource.colors_per_channel = 4;
1166
1167   if (resource.style_file)
1168     delete [] resource.style_file;
1169   if (config.getValue("session.styleFile", "Session.StyleFile", s))
1170     resource.style_file = bstrdup(s.c_str());
1171   else
1172     resource.style_file = bstrdup(DEFAULTSTYLE);
1173
1174   if (resource.titlebar_layout)
1175     delete [] resource.titlebar_layout;
1176   if (config.getValue("session.titlebarLayout", "Session.TitlebarLayout", s))
1177     resource.titlebar_layout = bstrdup(s.c_str());
1178   else
1179     resource.titlebar_layout = bstrdup("ILMC");
1180
1181   if (config.getValue("session.doubleClickInterval",
1182                       "Session.DoubleClickInterval", l))
1183     resource.double_click_interval = l;
1184   else
1185     resource.double_click_interval = 250;
1186
1187   if (!config.getValue("session.autoRaiseDelay", "Session.AutoRaiseDelay", l))
1188     resource.auto_raise_delay.tv_usec = l;
1189   else
1190     resource.auto_raise_delay.tv_usec = 400;
1191   resource.auto_raise_delay.tv_sec = resource.auto_raise_delay.tv_usec / 1000;
1192   resource.auto_raise_delay.tv_usec -=
1193     (resource.auto_raise_delay.tv_sec * 1000);
1194   resource.auto_raise_delay.tv_usec *= 1000;
1195
1196   if (config.getValue("session.cacheLife", "Session.CacheLife", l))
1197     resource.cache_life = l;
1198   else
1199     resource.cache_life = 51;
1200   resource.cache_life *= 60000;
1201
1202   if (config.getValue("session.cacheMax", "Session.CacheMax", l))
1203     resource.cache_max = l;
1204   else
1205     resource.cache_max = 200;
1206 }
1207
1208
1209 void Openbox::load_rc(BScreen *screen) {
1210   assert (screen != NULL);
1211   const int screen_number = screen->getScreenNumber();
1212   assert (screen_number >= 0);
1213
1214   if (!config.load())
1215     return;
1216
1217   std::string s;
1218   long l;
1219   bool b;
1220   char name_lookup[1024], class_lookup[1024];
1221
1222   sprintf(name_lookup,  "session.screen%d.fullMaximization", screen_number);
1223   sprintf(class_lookup, "Session.Screen%d.FullMaximization", screen_number);
1224   if (config.getValue(name_lookup, class_lookup, b))
1225     screen->saveFullMax((Bool)b);
1226   else
1227     screen->saveFullMax(False);
1228
1229   sprintf(name_lookup,  "session.screen%d.focusNewWindows", screen_number);
1230   sprintf(class_lookup, "Session.Screen%d.FocusNewWindows", screen_number);
1231   if (config.getValue(name_lookup, class_lookup, b))
1232     screen->saveFocusNew((Bool)b);
1233   else
1234     screen->saveFocusNew(False);
1235
1236   sprintf(name_lookup,  "session.screen%d.focusLastWindow", screen_number);
1237   sprintf(class_lookup, "Session.Screen%d.focusLastWindow", screen_number);
1238   if (config.getValue(name_lookup, class_lookup, b))
1239     screen->saveFocusLast((Bool)b);
1240   else
1241     screen->saveFocusLast(False);
1242
1243   sprintf(name_lookup,  "session.screen%d.rowPlacementDirection",
1244           screen_number);
1245   sprintf(class_lookup, "Session.Screen%d.RowPlacementDirection",
1246           screen_number);
1247   if (config.getValue(name_lookup, class_lookup, s)) {
1248     if (0 == strncasecmp(s.c_str(), "righttoleft", s.length()))
1249       screen->saveRowPlacementDirection(BScreen::RightLeft);
1250     else
1251       screen->saveRowPlacementDirection(BScreen::LeftRight);
1252   } else
1253     screen->saveRowPlacementDirection(BScreen::LeftRight);
1254
1255   sprintf(name_lookup,  "session.screen%d.colPlacementDirection",
1256           screen_number);
1257   sprintf(class_lookup, "Session.Screen%d.ColPlacementDirection",
1258           screen_number);
1259   if (config.getValue(name_lookup, class_lookup, s)) {
1260     if (0 == strncasecmp(s.c_str(), "bottomtotop", s.length()))
1261       screen->saveColPlacementDirection(BScreen::BottomTop);
1262     else
1263       screen->saveColPlacementDirection(BScreen::TopBottom);
1264   } else
1265     screen->saveColPlacementDirection(BScreen::TopBottom);
1266
1267   sprintf(name_lookup,  "session.screen%d.workspaces", screen_number);
1268   sprintf(class_lookup, "Session.Screen%d.Workspaces", screen_number);
1269   if (config.getValue(name_lookup, class_lookup, l))
1270     screen->saveWorkspaces(l);
1271   else
1272     screen->saveWorkspaces(1);
1273
1274   sprintf(name_lookup,  "session.screen%d.toolbar.widthPercent",
1275           screen_number);
1276   sprintf(class_lookup, "Session.Screen%d.Toolbar.WidthPercent",
1277           screen_number);
1278   if (config.getValue(name_lookup, class_lookup, l) && (l > 0 && l <= 100))
1279     screen->saveToolbarWidthPercent(l);
1280   else
1281     screen->saveToolbarWidthPercent(66);
1282
1283   sprintf(name_lookup, "session.screen%d.toolbar.placement", screen_number);
1284   sprintf(class_lookup, "Session.Screen%d.Toolbar.Placement", screen_number);
1285   if (config.getValue(name_lookup, class_lookup, s)) {
1286     if (0 == strncasecmp(s.c_str(), "TopLeft", s.length()))
1287       screen->saveToolbarPlacement(Toolbar::TopLeft);
1288     else if (0 == strncasecmp(s.c_str(), "BottomLeft", s.length()))
1289       screen->saveToolbarPlacement(Toolbar::BottomLeft);
1290     else if (0 == strncasecmp(s.c_str(), "TopCenter", s.length()))
1291       screen->saveToolbarPlacement(Toolbar::TopCenter);
1292     else if (0 == strncasecmp(s.c_str(), "TopRight", s.length()))
1293       screen->saveToolbarPlacement(Toolbar::TopRight);
1294     else if ( 0 == strncasecmp(s.c_str(), "BottomRight", s.length()))
1295       screen->saveToolbarPlacement(Toolbar::BottomRight);
1296     else
1297       screen->saveToolbarPlacement(Toolbar::BottomCenter);
1298   } else
1299     screen->saveToolbarPlacement(Toolbar::BottomCenter);
1300
1301   screen->removeWorkspaceNames();
1302   sprintf(name_lookup,  "session.screen%d.workspaceNames", screen_number);
1303   sprintf(class_lookup, "Session.Screen%d.WorkspaceNames", screen_number);
1304   if (config.getValue(name_lookup, class_lookup, s)) {
1305   //  for (int i = 0; i < screen->getNumberOfWorkspaces(); i++) {
1306     std::string::const_iterator it = s.begin(), end = s.end();
1307     while(1) {
1308       std::string::const_iterator tmp = it;// current string.begin()
1309       it = std::find(tmp, end, ',');       // look for comma between tmp and end
1310       std::string name(tmp, it);           // name = s[tmp:it]
1311       screen->addWorkspaceName(name.c_str());
1312       if (it == end)
1313         break;
1314       ++it;
1315     }
1316   }
1317
1318   sprintf(name_lookup,  "session.screen%d.toolbar.onTop", screen_number);
1319   sprintf(class_lookup, "Session.Screen%d.Toolbar.OnTop", screen_number);
1320   if (config.getValue(name_lookup, class_lookup, b))
1321     screen->saveToolbarOnTop((Bool)b);
1322   else
1323     screen->saveToolbarOnTop(False);
1324
1325   sprintf(name_lookup,  "session.screen%d.toolbar.autoHide", screen_number);
1326   sprintf(class_lookup, "Session.Screen%d.Toolbar.autoHide", screen_number);
1327   if (config.getValue(name_lookup, class_lookup, b))
1328     screen->saveToolbarAutoHide((Bool)b);
1329   else
1330     screen->saveToolbarAutoHide(False);
1331
1332   sprintf(name_lookup,  "session.screen%d.focusModel", screen_number);
1333   sprintf(class_lookup, "Session.Screen%d.FocusModel", screen_number);
1334   if (config.getValue(name_lookup, class_lookup, s)) {
1335     cout << s << endl;
1336     if (0 == strncasecmp(s.c_str(), "clicktofocus", s.length())) {
1337       screen->saveAutoRaise(False);
1338       screen->saveSloppyFocus(False);
1339     } else if (0 == strncasecmp(s.c_str(), "autoraisesloppyfocus",
1340                                 s.length())) {
1341       screen->saveSloppyFocus(True);
1342       screen->saveAutoRaise(True);
1343     } else {
1344       screen->saveSloppyFocus(True);
1345       screen->saveAutoRaise(False);
1346     }
1347   } else {
1348     screen->saveSloppyFocus(True);
1349     screen->saveAutoRaise(False);
1350   }
1351
1352   sprintf(name_lookup,  "session.screen%d.windowZones", screen_number);
1353   sprintf(class_lookup, "Session.Screen%d.WindowZones", screen_number);
1354   if (config.getValue(name_lookup, class_lookup, l))
1355     screen->saveWindowZones((l == 1 || l == 2 || l == 4) ? l : 1);
1356   else
1357     screen->saveWindowZones(1);
1358
1359   sprintf(name_lookup,  "session.screen%d.windowPlacement", screen_number);
1360   sprintf(class_lookup, "Session.Screen%d.WindowPlacement", screen_number);
1361   if (config.getValue(name_lookup, class_lookup, s)) {
1362     if (0 == strncasecmp(s.c_str(), "RowSmartPlacement", s.length()))
1363       screen->savePlacementPolicy(BScreen::RowSmartPlacement);
1364     else if (0 == strncasecmp(s.c_str(), "ColSmartPlacement", s.length()))
1365       screen->savePlacementPolicy(BScreen::ColSmartPlacement);
1366     else
1367       screen->savePlacementPolicy(BScreen::CascadePlacement);
1368   } else
1369     screen->savePlacementPolicy(BScreen::RowSmartPlacement);
1370
1371 #ifdef    SLIT
1372   sprintf(name_lookup, "session.screen%d.slit.placement", screen_number);
1373   sprintf(class_lookup, "Session.Screen%d.Slit.Placement", screen_number);
1374   if (config.getValue(name_lookup, class_lookup, s)) {
1375     if (0 == strncasecmp(s.c_str(), "TopLeft", s.length()))
1376       screen->saveSlitPlacement(Slit::TopLeft);
1377     else if (0 == strncasecmp(s.c_str(), "CenterLeft", s.length()))
1378       screen->saveSlitPlacement(Slit::CenterLeft);
1379     else if (0 == strncasecmp(s.c_str(), "BottomLeft", s.length()))
1380       screen->saveSlitPlacement(Slit::BottomLeft);
1381     else if (0 == strncasecmp(s.c_str(), "TopCenter", s.length()))
1382       screen->saveSlitPlacement(Slit::TopCenter);
1383     else if (0 == strncasecmp(s.c_str(), "BottomCenter", s.length()))
1384       screen->saveSlitPlacement(Slit::BottomCenter);
1385     else if (0 == strncasecmp(s.c_str(), "TopRight", s.length()))
1386       screen->saveSlitPlacement(Slit::TopRight);
1387     else if (0 == strncasecmp(s.c_str(), "BottomRight", s.length()))
1388       screen->saveSlitPlacement(Slit::BottomRight);
1389     else
1390       screen->saveSlitPlacement(Slit::CenterRight);
1391   } else
1392     screen->saveSlitPlacement(Slit::CenterRight);
1393
1394   sprintf(name_lookup, "session.screen%d.slit.direction", screen_number);
1395   sprintf(class_lookup, "Session.Screen%d.Slit.Direction", screen_number);
1396   if (config.getValue(name_lookup, class_lookup, s)) {
1397     if (0 == strncasecmp(s.c_str(), "Horizontal", s.length()))
1398       screen->saveSlitDirection(Slit::Horizontal);
1399     else
1400       screen->saveSlitDirection(Slit::Vertical);
1401   } else
1402     screen->saveSlitDirection(Slit::Vertical);
1403
1404   sprintf(name_lookup, "session.screen%d.slit.onTop", screen_number);
1405   sprintf(class_lookup, "Session.Screen%d.Slit.OnTop", screen_number);
1406   if (config.getValue(name_lookup, class_lookup, b))
1407     screen->saveSlitOnTop((Bool)b);
1408   else
1409     screen->saveSlitOnTop(False);
1410
1411   sprintf(name_lookup, "session.screen%d.slit.autoHide", screen_number);
1412   sprintf(class_lookup, "Session.Screen%d.Slit.AutoHide", screen_number);
1413   if (config.getValue(name_lookup, class_lookup, b))
1414     screen->saveSlitAutoHide((Bool)b);
1415   else
1416     screen->saveSlitAutoHide(False);
1417 #endif // SLIT
1418
1419 #ifdef    HAVE_STRFTIME
1420   sprintf(name_lookup,  "session.screen%d.strftimeFormat", screen_number);
1421   sprintf(class_lookup, "Session.Screen%d.StrftimeFormat", screen_number);
1422   if (config.getValue(name_lookup, class_lookup, s))
1423     screen->saveStrftimeFormat(s.c_str());
1424   else
1425     screen->saveStrftimeFormat("%I:%M %p");
1426
1427 #else //  HAVE_STRFTIME
1428   sprintf(name_lookup,  "session.screen%d.dateFormat", screen_number);
1429   sprintf(class_lookup, "Session.Screen%d.DateFormat", screen_number);
1430   if (config.getValue(name_lookup, class_lookup, s)) {
1431     if (strncasecmp(s.c_str(), "european", s.length()))
1432       screen->saveDateFormat(B_AmericanDate);
1433     else
1434       screen->saveDateFormat(B_EuropeanDate);
1435   } else
1436     screen->saveDateFormat(B_AmericanDate);
1437
1438   sprintf(name_lookup,  "session.screen%d.clockFormat", screen_number);
1439   sprintf(class_lookup, "Session.Screen%d.ClockFormat", screen_number);
1440   if (config.getValue(name_lookup, class_lookup, l)) {
1441     if (clock == 24)
1442       screen->saveClock24Hour(True);
1443     else
1444       screen->saveClock24Hour(False);
1445   } else
1446     screen->saveClock24Hour(False);
1447 #endif // HAVE_STRFTIME
1448
1449   sprintf(name_lookup,  "session.screen%d.edgeSnapThreshold", screen_number);
1450   sprintf(class_lookup, "Session.Screen%d.EdgeSnapThreshold", screen_number);
1451   if (config.getValue(name_lookup, class_lookup, l))
1452     screen->saveEdgeSnapThreshold(l);
1453   else
1454     screen->saveEdgeSnapThreshold(4);
1455
1456   sprintf(name_lookup,  "session.screen%d.imageDither", screen_number);
1457   sprintf(class_lookup, "Session.Screen%d.ImageDither", screen_number);
1458   if (config.getValue("session.imageDither", "Session.ImageDither", b))
1459     screen->saveImageDither((Bool)b);
1460   else
1461     screen->saveImageDither(True);
1462
1463   sprintf(name_lookup, "session.screen%d.rootCommand", screen_number);
1464   sprintf(class_lookup, "Session.Screen%d.RootCommand", screen_number);
1465   if (config.getValue(name_lookup, class_lookup, s))
1466     screen->saveRootCommand(s.c_str());
1467   else
1468     screen->saveRootCommand(NULL);
1469
1470   if (config.getValue("session.opaqueMove", "Session.OpaqueMove", b))
1471     screen->saveOpaqueMove((Bool)b);
1472   else
1473     screen->saveOpaqueMove(False);
1474 }
1475
1476
1477 void Openbox::reload_rc(void) {
1478   load_rc();
1479   reconfigure();
1480 }
1481
1482
1483 void Openbox::reconfigure(void) {
1484   reconfigure_wait = True;
1485
1486   if (! timer->isTiming()) timer->start();
1487 }
1488
1489
1490 void Openbox::real_reconfigure(void) {
1491   grab();
1492
1493   config.load();
1494   config.setValue("session.styleFile", resource.style_file);    // autosave's
1495
1496   for (int i = 0, n = menuTimestamps->count(); i < n; i++) {
1497     MenuTimestamp *ts = menuTimestamps->remove(0);
1498
1499     if (ts) {
1500       if (ts->filename)
1501         delete [] ts->filename;
1502
1503       delete ts;
1504     }
1505   }
1506
1507   LinkedListIterator<BScreen> it(screenList);
1508   for (BScreen *screen = it.current(); screen; it++, screen = it.current()) {
1509     screen->reconfigure();
1510   }
1511
1512   ungrab();
1513 }
1514
1515
1516 void Openbox::checkMenu(void) {
1517   Bool reread = False;
1518   LinkedListIterator<MenuTimestamp> it(menuTimestamps);
1519   for (MenuTimestamp *tmp = it.current(); tmp && (! reread);
1520        it++, tmp = it.current()) {
1521     struct stat buf;
1522
1523     if (! stat(tmp->filename, &buf)) {
1524       if (tmp->timestamp != buf.st_ctime)
1525         reread = True;
1526     } else {
1527       reread = True;
1528     }
1529   }
1530
1531   if (reread) rereadMenu();
1532 }
1533
1534
1535 void Openbox::rereadMenu(void) {
1536   reread_menu_wait = True;
1537
1538   if (! timer->isTiming()) timer->start();
1539 }
1540
1541
1542 void Openbox::real_rereadMenu(void) {
1543   for (int i = 0, n = menuTimestamps->count(); i < n; i++) {
1544     MenuTimestamp *ts = menuTimestamps->remove(0);
1545
1546     if (ts) {
1547       if (ts->filename)
1548         delete [] ts->filename;
1549
1550       delete ts;
1551     }
1552   }
1553
1554   LinkedListIterator<BScreen> it(screenList);
1555   for (BScreen *screen = it.current(); screen; it++, screen = it.current())
1556     screen->rereadMenu();
1557 }
1558
1559
1560 void Openbox::saveStyleFilename(const char *filename) {
1561   if (resource.style_file)
1562     delete [] resource.style_file;
1563
1564   resource.style_file = bstrdup(filename);
1565 }
1566
1567
1568 void Openbox::saveMenuFilename(const char *filename) {
1569   Bool found = False;
1570
1571   LinkedListIterator<MenuTimestamp> it(menuTimestamps);
1572   for (MenuTimestamp *tmp = it.current(); tmp && (! found);
1573        it++, tmp = it.current()) {
1574     if (! strcmp(tmp->filename, filename)) found = True;
1575   }
1576   if (! found) {
1577     struct stat buf;
1578
1579     if (! stat(filename, &buf)) {
1580       MenuTimestamp *ts = new MenuTimestamp;
1581
1582       ts->filename = bstrdup(filename);
1583       ts->timestamp = buf.st_ctime;
1584
1585       menuTimestamps->insert(ts);
1586     }
1587   }
1588 }
1589
1590
1591 void Openbox::timeout(void) {
1592   if (reconfigure_wait)
1593     real_reconfigure();
1594
1595   if (reread_menu_wait)
1596     real_rereadMenu();
1597
1598   reconfigure_wait = reread_menu_wait = False;
1599 }
1600
1601
1602 void Openbox::setFocusedWindow(OpenboxWindow *win) {
1603   BScreen *old_screen = (BScreen *) 0, *screen = (BScreen *) 0;
1604   OpenboxWindow *old_win = (OpenboxWindow *) 0;
1605   Toolbar *old_tbar = (Toolbar *) 0, *tbar = (Toolbar *) 0;
1606   Workspace *old_wkspc = (Workspace *) 0, *wkspc = (Workspace *) 0;
1607
1608   if (focused_window) {
1609     old_win = focused_window;
1610     old_screen = old_win->getScreen();
1611     old_tbar = old_screen->getToolbar();
1612     old_wkspc = old_screen->getWorkspace(old_win->getWorkspaceNumber());
1613
1614     old_win->setFocusFlag(False);
1615     old_wkspc->getMenu()->setItemSelected(old_win->getWindowNumber(), False);
1616   }
1617
1618   if (win && ! win->isIconic()) {
1619     screen = win->getScreen();
1620     tbar = screen->getToolbar();
1621     wkspc = screen->getWorkspace(win->getWorkspaceNumber());
1622
1623     focused_window = win;
1624
1625     win->setFocusFlag(True);
1626     wkspc->getMenu()->setItemSelected(win->getWindowNumber(), True);
1627   } else {
1628     focused_window = (OpenboxWindow *) 0;
1629   }
1630
1631   if (tbar)
1632     tbar->redrawWindowLabel(True);
1633   if (screen)
1634     screen->updateNetizenWindowFocus();
1635
1636   if (old_tbar && old_tbar != tbar)
1637     old_tbar->redrawWindowLabel(True);
1638   if (old_screen && old_screen != screen)
1639     old_screen->updateNetizenWindowFocus();
1640 }