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