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

   1 // Screen.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/Xatom.h>
  34 #include <X11/keysym.h>
  35
  36 #include "i18n.h"
  37 #include "openbox.h"
  38 #include "Clientmenu.h"
  39 #include "Iconmenu.h"
  40 #include "Image.h"
  41 #include "Screen.h"
  42
  43 #ifdef    SLIT
  44 #include "Slit.h"
  45 #endif // SLIT
  46
  47 #include "Rootmenu.h"
  48 #include "Toolbar.h"
  49 #include "Window.h"
  50 #include "Workspace.h"
  51 #include "Workspacemenu.h"
  52
  53 #ifdef    HAVE_STDLIB_H
  54 #  include <stdlib.h>
  55 #endif // HAVE_STDLIB_H
  56
  57 #ifdef    HAVE_STRING_H
  58 #  include <string.h>
  59 #endif // HAVE_STRING_H
  60
  61 #ifdef    HAVE_SYS_TYPES_H
  62 #  include <sys/types.h>
  63 #endif // HAVE_SYS_TYPES_H
  64
  65 #ifdef    HAVE_CTYPE_H
  66 #  include <ctype.h>
  67 #endif // HAVE_CTYPE_H
  68
  69 #ifdef    HAVE_DIRENT_H
  70 #  include <dirent.h>
  71 #endif // HAVE_DIRENT_H
  72
  73 #ifdef    HAVE_LOCALE_H
  74 #  include <locale.h>
  75 #endif // HAVE_LOCALE_H
  76
  77 #ifdef    HAVE_UNISTD_H
  78 #  include <sys/types.h>
  79 #  include <unistd.h>
  80 #endif // HAVE_UNISTD_H
  81
  82 #ifdef    HAVE_SYS_STAT_H
  83 #  include <sys/stat.h>
  84 #endif // HAVE_SYS_STAT_H
  85
  86 #ifdef    HAVE_STDARG_H
  87 #  include <stdarg.h>
  88 #endif // HAVE_STDARG_H
  89
  90 #ifndef    HAVE_SNPRINTF
  91 #  include "bsd-snprintf.h"
  92 #endif // !HAVE_SNPRINTF
  93
  94 #ifndef   MAXPATHLEN
  95 #define   MAXPATHLEN 255
  96 #endif // MAXPATHLEN
  97
  98 #ifndef   FONT_ELEMENT_SIZE
  99 #define   FONT_ELEMENT_SIZE 50
 100 #endif // FONT_ELEMENT_SIZE
 101
 102 #include <string>
 103 #include <algorithm>
 104
 105 static Bool running = True;
 106
 107 static int anotherWMRunning(Display *display, XErrorEvent *) {
 108   fprintf(stderr, i18n->getMessage(ScreenSet, ScreenAnotherWMRunning,
 109      "BScreen::BScreen: an error occured while querying the X server.\n"
 110              "  another window manager already running on display %s.\n"),
 111           DisplayString(display));
 112
 113   running = False;
 114
 115   return(-1);
 116 }
 117
 118 struct dcmp {
 119   bool operator()(const char *one, const char *two) const {
 120     return (strcmp(one, two) < 0) ? True : False;
 121   }
 122 };
 123
 124 #ifndef    HAVE_STRCASESTR
 125 static const char * strcasestr(const char *str, const char *ptn) {
 126   const char *s2, *p2;
 127   for( ; *str; str++) {
 128     for(s2=str,p2=ptn; ; s2++,p2++) {
 129       if (!*p2) return str;
 130       if (toupper(*s2) != toupper(*p2)) break;
 131     }
 132   }
 133   return NULL;
 134 }
 135 #endif // HAVE_STRCASESTR
 136
 137 static const char *getFontElement(const char *pattern, char *buf, int bufsiz, ...) {
 138   const char *p, *v;
 139   char *p2;
 140   va_list va;
 141
 142   va_start(va, bufsiz);
 143   buf[bufsiz-1] = 0;
 144   buf[bufsiz-2] = '*';
 145   while((v = va_arg(va, char *)) != NULL) {
 146     p = strcasestr(pattern, v);
 147     if (p) {
 148       strncpy(buf, p+1, bufsiz-2);
 149       p2 = strchr(buf, '-');
 150       if (p2) *p2=0;
 151       va_end(va);
 152       return p;
 153     }
 154   }
 155   va_end(va);
 156   strncpy(buf, "*", bufsiz);
 157   return NULL;
 158 }
 159
 160 static const char *getFontSize(const char *pattern, int *size) {
 161   const char *p;
 162   const char *p2=NULL;
 163   int n=0;
 164
 165   for (p=pattern; 1; p++) {
 166     if (!*p) {
 167       if (p2!=NULL && n>1 && n<72) {
 168         *size = n; return p2+1;
 169       } else {
 170         *size = 16; return NULL;
 171       }
 172     } else if (*p=='-') {
 173       if (n>1 && n<72 && p2!=NULL) {
 174         *size = n;
 175         return p2+1;
 176       }
 177       p2=p; n=0;
 178     } else if (*p>='0' && *p<='9' && p2!=NULL) {
 179       n *= 10;
 180       n += *p-'0';
 181     } else {
 182       p2=NULL; n=0;
 183     }
 184   }
 185 }
 186
 187
 188 BScreen::BScreen(Openbox &ob, int scrn, Resource &conf) : ScreenInfo(ob, scrn),
 189   openbox(ob), config(conf)
 190 {
 191   event_mask = ColormapChangeMask | EnterWindowMask | PropertyChangeMask |
 192                SubstructureRedirectMask | KeyPressMask | KeyReleaseMask |
 193                ButtonPressMask | ButtonReleaseMask;
 194
 195   XErrorHandler old = XSetErrorHandler((XErrorHandler) anotherWMRunning);
 196   XSelectInput(getBaseDisplay().getXDisplay(), getRootWindow(), event_mask);
 197   XSync(getBaseDisplay().getXDisplay(), False);
 198   XSetErrorHandler((XErrorHandler) old);
 199
 200   managed = running;
 201   if (! managed) return;
 202
 203   fprintf(stderr, i18n->getMessage(ScreenSet, ScreenManagingScreen,
 204                      "BScreen::BScreen: managing screen %d "
 205                      "using visual 0x%lx, depth %d\n"),
 206           getScreenNumber(), XVisualIDFromVisual(getVisual()),
 207           getDepth());
 208
 209   rootmenu = 0;
 210
 211   resource.mstyle.t_fontset = resource.mstyle.f_fontset =
 212     resource.tstyle.fontset = resource.wstyle.fontset = (XFontSet) 0;
 213   resource.mstyle.t_font = resource.mstyle.f_font = resource.tstyle.font =
 214     resource.wstyle.font = (XFontStruct *) 0;
 215   resource.root_command = NULL;
 216
 217 #ifdef    HAVE_STRFTIME
 218   resource.strftime_format = 0;
 219 #endif // HAVE_STRFTIME
 220
 221 #ifdef    HAVE_GETPID
 222   pid_t bpid = getpid();
 223
 224   XChangeProperty(getBaseDisplay().getXDisplay(), getRootWindow(),
 225                   openbox.getOpenboxPidAtom(), XA_CARDINAL,
 226                   sizeof(pid_t) * 8, PropModeReplace,
 227                   (unsigned char *) &bpid, 1);
 228 #endif // HAVE_GETPID
 229
 230   XDefineCursor(getBaseDisplay().getXDisplay(), getRootWindow(),
 231                 openbox.getSessionCursor());
 232
 233   workspaceNames = new LinkedList<char>;
 234   workspacesList = new LinkedList<Workspace>;
 235   rootmenuList = new LinkedList<Rootmenu>;
 236   netizenList = new LinkedList<Netizen>;
 237   iconList = new LinkedList<OpenboxWindow>;
 238
 239   image_control =
 240     new BImageControl(openbox, *this, True, openbox.getColorsPerChannel(),
 241                       openbox.getCacheLife(), openbox.getCacheMax());
 242   image_control->installRootColormap();
 243   root_colormap_installed = True;
 244
 245   openbox.load_rc(this);
 246
 247   image_control->setDither(resource.image_dither);
 248
 249   LoadStyle();
 250
 251   XGCValues gcv;
 252   unsigned long gc_value_mask = GCForeground;
 253   if (! i18n->multibyte()) gc_value_mask |= GCFont;
 254
 255   gcv.foreground = WhitePixel(getBaseDisplay().getXDisplay(),
 256                               getScreenNumber())
 257                  ^ BlackPixel(getBaseDisplay().getXDisplay(),
 258                               getScreenNumber());
 259   gcv.function = GXxor;
 260   gcv.subwindow_mode = IncludeInferiors;
 261   opGC = XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 262                    GCForeground | GCFunction | GCSubwindowMode, &gcv);
 263
 264   gcv.foreground = resource.wstyle.l_text_focus.getPixel();
 265   if (resource.wstyle.font)
 266     gcv.font = resource.wstyle.font->fid;
 267   resource.wstyle.l_text_focus_gc =
 268     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 269               gc_value_mask, &gcv);
 270
 271   gcv.foreground = resource.wstyle.l_text_unfocus.getPixel();
 272   if (resource.wstyle.font)
 273     gcv.font = resource.wstyle.font->fid;
 274   resource.wstyle.l_text_unfocus_gc =
 275     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 276               gc_value_mask, &gcv);
 277
 278   gcv.foreground = resource.wstyle.b_pic_focus.getPixel();
 279   resource.wstyle.b_pic_focus_gc =
 280     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 281               GCForeground, &gcv);
 282
 283   gcv.foreground = resource.wstyle.b_pic_unfocus.getPixel();
 284   resource.wstyle.b_pic_unfocus_gc =
 285     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 286               GCForeground, &gcv);
 287
 288   gcv.foreground = resource.mstyle.t_text.getPixel();
 289   if (resource.mstyle.t_font)
 290     gcv.font = resource.mstyle.t_font->fid;
 291   resource.mstyle.t_text_gc =
 292     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 293               gc_value_mask, &gcv);
 294
 295   gcv.foreground = resource.mstyle.f_text.getPixel();
 296   if (resource.mstyle.f_font)
 297     gcv.font = resource.mstyle.f_font->fid;
 298   resource.mstyle.f_text_gc =
 299     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 300               gc_value_mask, &gcv);
 301
 302   gcv.foreground = resource.mstyle.h_text.getPixel();
 303   resource.mstyle.h_text_gc =
 304     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 305               gc_value_mask, &gcv);
 306
 307   gcv.foreground = resource.mstyle.d_text.getPixel();
 308   resource.mstyle.d_text_gc =
 309     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 310               gc_value_mask, &gcv);
 311
 312   gcv.foreground = resource.mstyle.hilite.getColor()->getPixel();
 313   resource.mstyle.hilite_gc =
 314     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 315               gc_value_mask, &gcv);
 316
 317   gcv.foreground = resource.tstyle.l_text.getPixel();
 318   if (resource.tstyle.font)
 319     gcv.font = resource.tstyle.font->fid;
 320   resource.tstyle.l_text_gc =
 321     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 322               gc_value_mask, &gcv);
 323
 324   gcv.foreground = resource.tstyle.w_text.getPixel();
 325   resource.tstyle.w_text_gc =
 326     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 327               gc_value_mask, &gcv);
 328
 329   gcv.foreground = resource.tstyle.c_text.getPixel();
 330   resource.tstyle.c_text_gc =
 331     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 332               gc_value_mask, &gcv);
 333
 334   gcv.foreground = resource.tstyle.b_pic.getPixel();
 335   resource.tstyle.b_pic_gc =
 336     XCreateGC(getBaseDisplay().getXDisplay(), getRootWindow(),
 337               gc_value_mask, &gcv);
 338
 339   const char *s =  i18n->getMessage(ScreenSet, ScreenPositionLength,
 340                                     "0: 0000 x 0: 0000");
 341   int l = strlen(s);
 342
 343   if (i18n->multibyte()) {
 344     XRectangle ink, logical;
 345     XmbTextExtents(resource.wstyle.fontset, s, l, &ink, &logical);
 346     geom_w = logical.width;
 347
 348     geom_h = resource.wstyle.fontset_extents->max_ink_extent.height;
 349   } else {
 350     geom_h = resource.wstyle.font->ascent +
 351              resource.wstyle.font->descent;
 352
 353     geom_w = XTextWidth(resource.wstyle.font, s, l);
 354   }
 355
 356   geom_w += (resource.bevel_width * 2);
 357   geom_h += (resource.bevel_width * 2);
 358
 359   XSetWindowAttributes attrib;
 360   unsigned long mask = CWBorderPixel | CWColormap | CWSaveUnder;
 361   attrib.border_pixel = getBorderColor()->getPixel();
 362   attrib.colormap = getColormap();
 363   attrib.save_under = True;
 364
 365   geom_window =
 366     XCreateWindow(getBaseDisplay().getXDisplay(), getRootWindow(),
 367                   0, 0, geom_w, geom_h, resource.border_width, getDepth(),
 368                   InputOutput, getVisual(), mask, &attrib);
 369   geom_visible = False;
 370
 371   if (resource.wstyle.l_focus.getTexture() & BImage_ParentRelative) {
 372     if (resource.wstyle.t_focus.getTexture() ==
 373                                       (BImage_Flat | BImage_Solid)) {
 374       geom_pixmap = None;
 375       XSetWindowBackground(getBaseDisplay().getXDisplay(), geom_window,
 376                            resource.wstyle.t_focus.getColor()->getPixel());
 377     } else {
 378       geom_pixmap = image_control->renderImage(geom_w, geom_h,
 379                                                &resource.wstyle.t_focus);
 380       XSetWindowBackgroundPixmap(getBaseDisplay().getXDisplay(),
 381                                  geom_window, geom_pixmap);
 382     }
 383   } else {
 384     if (resource.wstyle.l_focus.getTexture() ==
 385                                       (BImage_Flat | BImage_Solid)) {
 386       geom_pixmap = None;
 387       XSetWindowBackground(getBaseDisplay().getXDisplay(), geom_window,
 388                            resource.wstyle.l_focus.getColor()->getPixel());
 389     } else {
 390       geom_pixmap = image_control->renderImage(geom_w, geom_h,
 391                                                &resource.wstyle.l_focus);
 392       XSetWindowBackgroundPixmap(getBaseDisplay().getXDisplay(),
 393                                  geom_window, geom_pixmap);
 394     }
 395   }
 396
 397   workspacemenu = new Workspacemenu(*this);
 398   iconmenu = new Iconmenu(*this);
 399   configmenu = new Configmenu(*this);
 400
 401   Workspace *wkspc = (Workspace *) 0;
 402   if (resource.workspaces != 0) {
 403     for (int i = 0; i < resource.workspaces; ++i) {
 404       wkspc = new Workspace(*this, workspacesList->count());
 405       workspacesList->insert(wkspc);
 406       workspacemenu->insert(wkspc->getName(), wkspc->getMenu());
 407     }
 408   } else {
 409     wkspc = new Workspace(*this, workspacesList->count());
 410     workspacesList->insert(wkspc);
 411     workspacemenu->insert(wkspc->getName(), wkspc->getMenu());
 412   }
 413
 414   workspacemenu->insert(i18n->getMessage(IconSet, IconIcons, "Icons"),
 415                         iconmenu);
 416   workspacemenu->update();
 417
 418   current_workspace = workspacesList->first();
 419   workspacemenu->setItemSelected(2, True);
 420
 421   toolbar = new Toolbar(*this);
 422
 423 #ifdef    SLIT
 424   slit = new Slit(*this, config);
 425 #endif // SLIT
 426
 427   InitMenu();
 428
 429   raiseWindows(0, 0);
 430   rootmenu->update();
 431
 432   changeWorkspaceID(0);
 433
 434   int i;
 435   unsigned int nchild;
 436   Window r, p, *children;
 437   XQueryTree(getBaseDisplay().getXDisplay(), getRootWindow(), &r, &p,
 438              &children, &nchild);
 439
 440   // preen the window list of all icon windows... for better dockapp support
 441   for (i = 0; i < (int) nchild; i++) {
 442     if (children[i] == None) continue;
 443
 444     XWMHints *wmhints = XGetWMHints(getBaseDisplay().getXDisplay(),
 445                                     children[i]);
 446
 447     if (wmhints) {
 448       if ((wmhints->flags & IconWindowHint) &&
 449           (wmhints->icon_window != children[i]))
 450         for (int j = 0; j < (int) nchild; j++)
 451           if (children[j] == wmhints->icon_window) {
 452             children[j] = None;
 453
 454             break;
 455           }
 456
 457       XFree(wmhints);
 458     }
 459   }
 460
 461   // manage shown windows
 462   for (i = 0; i < (int) nchild; ++i) {
 463     if (children[i] == None || (! openbox.validateWindow(children[i])))
 464       continue;
 465
 466     XWindowAttributes attrib;
 467     if (XGetWindowAttributes(getBaseDisplay().getXDisplay(), children[i],
 468                              &attrib)) {
 469       if (attrib.override_redirect) continue;
 470
 471       if (attrib.map_state != IsUnmapped) {
 472         new OpenboxWindow(openbox, children[i], this);
 473
 474         OpenboxWindow *win = openbox.searchWindow(children[i]);
 475         if (win) {
 476           XMapRequestEvent mre;
 477           mre.window = children[i];
 478           win->restoreAttributes();
 479           win->mapRequestEvent(&mre);
 480         }
 481       }
 482     }
 483   }
 484
 485   if (! resource.sloppy_focus)
 486     XSetInputFocus(getBaseDisplay().getXDisplay(), toolbar->getWindowID(),
 487                    RevertToParent, CurrentTime);
 488
 489   XFree(children);
 490   XFlush(getBaseDisplay().getXDisplay());
 491 }
 492
 493
 494 BScreen::~BScreen(void) {
 495   if (! managed) return;
 496
 497   if (geom_pixmap != None)
 498     image_control->removeImage(geom_pixmap);
 499
 500   if (geom_window != None)
 501     XDestroyWindow(getBaseDisplay().getXDisplay(), geom_window);
 502
 503   removeWorkspaceNames();
 504
 505   while (workspacesList->count())
 506     delete workspacesList->remove(0);
 507
 508   while (rootmenuList->count())
 509     rootmenuList->remove(0);
 510
 511   while (iconList->count())
 512     delete iconList->remove(0);
 513
 514   while (netizenList->count())
 515     delete netizenList->remove(0);
 516
 517 #ifdef    HAVE_STRFTIME
 518   if (resource.strftime_format)
 519     delete [] resource.strftime_format;
 520 #endif // HAVE_STRFTIME
 521
 522   delete rootmenu;
 523   delete workspacemenu;
 524   delete iconmenu;
 525   delete configmenu;
 526
 527 #ifdef    SLIT
 528   delete slit;
 529 #endif // SLIT
 530
 531   delete toolbar;
 532   delete image_control;
 533
 534   delete workspacesList;
 535   delete workspaceNames;
 536   delete rootmenuList;
 537   delete iconList;
 538   delete netizenList;
 539
 540   if (resource.wstyle.fontset)
 541     XFreeFontSet(getBaseDisplay().getXDisplay(), resource.wstyle.fontset);
 542   if (resource.mstyle.t_fontset)
 543     XFreeFontSet(getBaseDisplay().getXDisplay(), resource.mstyle.t_fontset);
 544   if (resource.mstyle.f_fontset)
 545     XFreeFontSet(getBaseDisplay().getXDisplay(), resource.mstyle.f_fontset);
 546   if (resource.tstyle.fontset)
 547     XFreeFontSet(getBaseDisplay().getXDisplay(), resource.tstyle.fontset);
 548
 549   if (resource.wstyle.font)
 550     XFreeFont(getBaseDisplay().getXDisplay(), resource.wstyle.font);
 551   if (resource.mstyle.t_font)
 552     XFreeFont(getBaseDisplay().getXDisplay(), resource.mstyle.t_font);
 553   if (resource.mstyle.f_font)
 554     XFreeFont(getBaseDisplay().getXDisplay(), resource.mstyle.f_font);
 555   if (resource.tstyle.font)
 556     XFreeFont(getBaseDisplay().getXDisplay(), resource.tstyle.font);
 557   if (resource.root_command != NULL)
 558     delete [] resource.root_command;
 559
 560   XFreeGC(getBaseDisplay().getXDisplay(), opGC);
 561
 562   XFreeGC(getBaseDisplay().getXDisplay(),
 563           resource.wstyle.l_text_focus_gc);
 564   XFreeGC(getBaseDisplay().getXDisplay(),
 565           resource.wstyle.l_text_unfocus_gc);
 566   XFreeGC(getBaseDisplay().getXDisplay(),
 567           resource.wstyle.b_pic_focus_gc);
 568   XFreeGC(getBaseDisplay().getXDisplay(),
 569           resource.wstyle.b_pic_unfocus_gc);
 570
 571   XFreeGC(getBaseDisplay().getXDisplay(),
 572           resource.mstyle.t_text_gc);
 573   XFreeGC(getBaseDisplay().getXDisplay(),
 574           resource.mstyle.f_text_gc);
 575   XFreeGC(getBaseDisplay().getXDisplay(),
 576           resource.mstyle.h_text_gc);
 577   XFreeGC(getBaseDisplay().getXDisplay(),
 578           resource.mstyle.d_text_gc);
 579   XFreeGC(getBaseDisplay().getXDisplay(),
 580           resource.mstyle.hilite_gc);
 581
 582   XFreeGC(getBaseDisplay().getXDisplay(),
 583           resource.tstyle.l_text_gc);
 584   XFreeGC(getBaseDisplay().getXDisplay(),
 585           resource.tstyle.w_text_gc);
 586   XFreeGC(getBaseDisplay().getXDisplay(),
 587           resource.tstyle.c_text_gc);
 588   XFreeGC(getBaseDisplay().getXDisplay(),
 589           resource.tstyle.b_pic_gc);
 590 }
 591
 592 void BScreen::readDatabaseTexture(const char *rname, const char *rclass,
 593                                   BTexture *texture,
 594                                   unsigned long default_pixel)
 595 {
 596   std::string s;
 597
 598   if (resource.styleconfig.getValue(rname, rclass, s))
 599     image_control->parseTexture(texture, s.c_str());
 600   else
 601     texture->setTexture(BImage_Solid | BImage_Flat);
 602
 603   if (texture->getTexture() & BImage_Solid) {
 604     int clen = strlen(rclass) + 32, nlen = strlen(rname) + 32;
 605
 606     char *colorclass = new char[clen], *colorname = new char[nlen];
 607
 608     sprintf(colorclass, "%s.Color", rclass);
 609     sprintf(colorname,  "%s.color", rname);
 610
 611     readDatabaseColor(colorname, colorclass, texture->getColor(),
 612                       default_pixel);
 613
 614 #ifdef    INTERLACE
 615     sprintf(colorclass, "%s.ColorTo", rclass);
 616     sprintf(colorname,  "%s.colorTo", rname);
 617
 618     readDatabaseColor(colorname, colorclass, texture->getColorTo(),
 619                       default_pixel);
 620 #endif // INTERLACE
 621
 622     delete [] colorclass;
 623     delete [] colorname;
 624
 625     if ((! texture->getColor()->isAllocated()) ||
 626         (texture->getTexture() & BImage_Flat))
 627       return;
 628
 629     XColor xcol;
 630
 631     xcol.red = (unsigned int) (texture->getColor()->getRed() +
 632                                (texture->getColor()->getRed() >> 1));
 633     if (xcol.red >= 0xff) xcol.red = 0xffff;
 634     else xcol.red *= 0xff;
 635     xcol.green = (unsigned int) (texture->getColor()->getGreen() +
 636                                  (texture->getColor()->getGreen() >> 1));
 637     if (xcol.green >= 0xff) xcol.green = 0xffff;
 638     else xcol.green *= 0xff;
 639     xcol.blue = (unsigned int) (texture->getColor()->getBlue() +
 640                                 (texture->getColor()->getBlue() >> 1));
 641     if (xcol.blue >= 0xff) xcol.blue = 0xffff;
 642     else xcol.blue *= 0xff;
 643
 644     if (! XAllocColor(getBaseDisplay().getXDisplay(),
 645                       getColormap(), &xcol))
 646       xcol.pixel = 0;
 647
 648     texture->getHiColor()->setPixel(xcol.pixel);
 649
 650     xcol.red =
 651       (unsigned int) ((texture->getColor()->getRed() >> 2) +
 652                       (texture->getColor()->getRed() >> 1)) * 0xff;
 653     xcol.green =
 654       (unsigned int) ((texture->getColor()->getGreen() >> 2) +
 655                       (texture->getColor()->getGreen() >> 1)) * 0xff;
 656     xcol.blue =
 657       (unsigned int) ((texture->getColor()->getBlue() >> 2) +
 658                       (texture->getColor()->getBlue() >> 1)) * 0xff;
 659
 660     if (! XAllocColor(getBaseDisplay().getXDisplay(),
 661                       getColormap(), &xcol))
 662       xcol.pixel = 0;
 663
 664     texture->getLoColor()->setPixel(xcol.pixel);
 665   } else if (texture->getTexture() & BImage_Gradient) {
 666     int clen = strlen(rclass) + 10, nlen = strlen(rname) + 10;
 667
 668     char *colorclass = new char[clen], *colorname = new char[nlen],
 669       *colortoclass = new char[clen], *colortoname = new char[nlen];
 670
 671     sprintf(colorclass, "%s.Color", rclass);
 672     sprintf(colorname,  "%s.color", rname);
 673
 674     sprintf(colortoclass, "%s.ColorTo", rclass);
 675     sprintf(colortoname,  "%s.colorTo", rname);
 676
 677     readDatabaseColor(colorname, colorclass, texture->getColor(),
 678                       default_pixel);
 679     readDatabaseColor(colortoname, colortoclass, texture->getColorTo(),
 680                       default_pixel);
 681
 682     delete [] colorclass;
 683     delete [] colorname;
 684     delete [] colortoclass;
 685     delete [] colortoname;
 686   }
 687 }
 688
 689
 690 void BScreen::readDatabaseColor(const char *rname, const  char *rclass,
 691                                 BColor *color, unsigned long default_pixel)
 692 {
 693   std::string s;
 694
 695   if (resource.styleconfig.getValue(rname, rclass, s))
 696     image_control->parseColor(color, s.c_str());
 697   else {
 698     // parsing with no color string just deallocates the color, if it has
 699     // been previously allocated
 700     image_control->parseColor(color);
 701     color->setPixel(default_pixel);
 702   }
 703 }
 704
 705
 706 void BScreen::readDatabaseFontSet(const char *rname, const char *rclass,
 707                                   XFontSet *fontset) {
 708   if (! fontset) return;
 709
 710   static char *defaultFont = "fixed";
 711   bool load_default = false;
 712   std::string s;
 713
 714   if (*fontset)
 715     XFreeFontSet(getBaseDisplay().getXDisplay(), *fontset);
 716
 717   if (resource.styleconfig.getValue(rname, rclass, s)) {
 718     if (! (*fontset = createFontSet(s.c_str())))
 719       load_default = true;
 720   } else
 721     load_default = true;
 722
 723   if (load_default) {
 724     *fontset = createFontSet(defaultFont);
 725
 726     if (! *fontset) {
 727       fprintf(stderr, i18n->getMessage(ScreenSet, ScreenDefaultFontLoadFail,
 728                        "BScreen::LoadStyle(): couldn't load default font.\n"));
 729       exit(2);
 730     }
 731   }
 732 }
 733
 734
 735 void BScreen::readDatabaseFont(const char *rname, const char *rclass,
 736                                XFontStruct **font) {
 737   if (! font) return;
 738
 739   static char *defaultFont = "fixed";
 740   bool load_default = false;
 741   std::string s;
 742
 743   if (*font)
 744     XFreeFont(getBaseDisplay().getXDisplay(), *font);
 745
 746   if (resource.styleconfig.getValue(rname, rclass, s)) {
 747     if ((*font = XLoadQueryFont(getBaseDisplay().getXDisplay(),
 748                                 s.c_str())) == NULL) {
 749       fprintf(stderr, i18n->getMessage(ScreenSet, ScreenFontLoadFail,
 750                          "BScreen::LoadStyle(): couldn't load font '%s'\n"),
 751               s.c_str());
 752       load_default = true;
 753     }
 754   } else
 755     load_default = true;
 756
 757   if (load_default) {
 758     if ((*font = XLoadQueryFont(getBaseDisplay().getXDisplay(),
 759                                 defaultFont)) == NULL) {
 760       fprintf(stderr, i18n->getMessage(ScreenSet, ScreenDefaultFontLoadFail,
 761                  "BScreen::LoadStyle(): couldn't load default font.\n"));
 762       exit(2);
 763     }
 764   }
 765 }
 766
 767
 768 XFontSet BScreen::createFontSet(const char *fontname) {
 769   XFontSet fs;
 770   char **missing, *def = "-";
 771   int nmissing, pixel_size = 0, buf_size = 0;
 772   char weight[FONT_ELEMENT_SIZE], slant[FONT_ELEMENT_SIZE];
 773
 774   fs = XCreateFontSet(getBaseDisplay().getXDisplay(),
 775                       fontname, &missing, &nmissing, &def);
 776   if (fs && (! nmissing)) return fs;
 777
 778 #ifdef    HAVE_SETLOCALE
 779   if (! fs) {
 780     if (nmissing) XFreeStringList(missing);
 781
 782     setlocale(LC_CTYPE, "C");
 783     fs = XCreateFontSet(getBaseDisplay().getXDisplay(), fontname,
 784                         &missing, &nmissing, &def);
 785     setlocale(LC_CTYPE, "");
 786   }
 787 #endif // HAVE_SETLOCALE
 788
 789   if (fs) {
 790     XFontStruct **fontstructs;
 791     char **fontnames;
 792     XFontsOfFontSet(fs, &fontstructs, &fontnames);
 793     fontname = fontnames[0];
 794   }
 795
 796   getFontElement(fontname, weight, FONT_ELEMENT_SIZE,
 797                  "-medium-", "-bold-", "-demibold-", "-regular-", NULL);
 798   getFontElement(fontname, slant, FONT_ELEMENT_SIZE,
 799                  "-r-", "-i-", "-o-", "-ri-", "-ro-", NULL);
 800   getFontSize(fontname, &pixel_size);
 801
 802   if (! strcmp(weight, "*")) strncpy(weight, "medium", FONT_ELEMENT_SIZE);
 803   if (! strcmp(slant, "*")) strncpy(slant, "r", FONT_ELEMENT_SIZE);
 804   if (pixel_size < 3) pixel_size = 3;
 805   else if (pixel_size > 97) pixel_size = 97;
 806
 807   buf_size = strlen(fontname) + (FONT_ELEMENT_SIZE * 2) + 64;
 808   char *pattern2 = new char[buf_size];
 809   snprintf(pattern2, buf_size - 1,
 810            "%s,"
 811            "-*-*-%s-%s-*-*-%d-*-*-*-*-*-*-*,"
 812            "-*-*-*-*-*-*-%d-*-*-*-*-*-*-*,*",
 813            fontname, weight, slant, pixel_size, pixel_size);
 814   fontname = pattern2;
 815
 816   if (nmissing) XFreeStringList(missing);
 817   if (fs) XFreeFontSet(getBaseDisplay().getXDisplay(), fs);
 818
 819   fs = XCreateFontSet(getBaseDisplay().getXDisplay(), fontname,
 820                       &missing, &nmissing, &def);
 821   delete [] pattern2;
 822
 823   return fs;
 824 }
 825
 826
 827 void BScreen::reconfigure(void) {
 828   LoadStyle();
 829
 830   XGCValues gcv;
 831   unsigned long gc_value_mask = GCForeground;
 832   if (! i18n->multibyte()) gc_value_mask |= GCFont;
 833
 834   gcv.foreground = WhitePixel(getBaseDisplay().getXDisplay(),
 835                               getScreenNumber());
 836   gcv.function = GXinvert;
 837   gcv.subwindow_mode = IncludeInferiors;
 838   XChangeGC(getBaseDisplay().getXDisplay(), opGC,
 839             GCForeground | GCFunction | GCSubwindowMode, &gcv);
 840
 841   gcv.foreground = resource.wstyle.l_text_focus.getPixel();
 842   if (resource.wstyle.font)
 843     gcv.font = resource.wstyle.font->fid;
 844   XChangeGC(getBaseDisplay().getXDisplay(), resource.wstyle.l_text_focus_gc,
 845             gc_value_mask, &gcv);
 846
 847   gcv.foreground = resource.wstyle.l_text_unfocus.getPixel();
 848   XChangeGC(getBaseDisplay().getXDisplay(), resource.wstyle.l_text_unfocus_gc,
 849             gc_value_mask, &gcv);
 850
 851   gcv.foreground = resource.wstyle.b_pic_focus.getPixel();
 852   XChangeGC(getBaseDisplay().getXDisplay(), resource.wstyle.b_pic_focus_gc,
 853             GCForeground, &gcv);
 854
 855   gcv.foreground = resource.wstyle.b_pic_unfocus.getPixel();
 856   XChangeGC(getBaseDisplay().getXDisplay(), resource.wstyle.b_pic_unfocus_gc,
 857             GCForeground, &gcv);
 858
 859   gcv.foreground = resource.mstyle.t_text.getPixel();
 860   if (resource.mstyle.t_font)
 861     gcv.font = resource.mstyle.t_font->fid;
 862   XChangeGC(getBaseDisplay().getXDisplay(), resource.mstyle.t_text_gc,
 863             gc_value_mask, &gcv);
 864
 865   gcv.foreground = resource.mstyle.f_text.getPixel();
 866   if (resource.mstyle.f_font)
 867     gcv.font = resource.mstyle.f_font->fid;
 868   XChangeGC(getBaseDisplay().getXDisplay(), resource.mstyle.f_text_gc,
 869             gc_value_mask, &gcv);
 870
 871   gcv.foreground = resource.mstyle.h_text.getPixel();
 872   XChangeGC(getBaseDisplay().getXDisplay(), resource.mstyle.h_text_gc,
 873             gc_value_mask, &gcv);
 874
 875   gcv.foreground = resource.mstyle.d_text.getPixel();
 876   XChangeGC(getBaseDisplay().getXDisplay(), resource.mstyle.d_text_gc,
 877             gc_value_mask, &gcv);
 878
 879   gcv.foreground = resource.mstyle.hilite.getColor()->getPixel();
 880   XChangeGC(getBaseDisplay().getXDisplay(), resource.mstyle.hilite_gc,
 881             gc_value_mask, &gcv);
 882
 883   gcv.foreground = resource.tstyle.l_text.getPixel();
 884   if (resource.tstyle.font)
 885     gcv.font = resource.tstyle.font->fid;
 886   XChangeGC(getBaseDisplay().getXDisplay(), resource.tstyle.l_text_gc,
 887             gc_value_mask, &gcv);
 888
 889   gcv.foreground = resource.tstyle.w_text.getPixel();
 890   XChangeGC(getBaseDisplay().getXDisplay(), resource.tstyle.w_text_gc,
 891             gc_value_mask, &gcv);
 892
 893   gcv.foreground = resource.tstyle.c_text.getPixel();
 894   XChangeGC(getBaseDisplay().getXDisplay(), resource.tstyle.c_text_gc,
 895             gc_value_mask, &gcv);
 896
 897   gcv.foreground = resource.tstyle.b_pic.getPixel();
 898   XChangeGC(getBaseDisplay().getXDisplay(), resource.tstyle.b_pic_gc,
 899             gc_value_mask, &gcv);
 900
 901   const char *s = i18n->getMessage(ScreenSet, ScreenPositionLength,
 902                                    "0: 0000 x 0: 0000");
 903   int l = strlen(s);
 904
 905   if (i18n->multibyte()) {
 906     XRectangle ink, logical;
 907     XmbTextExtents(resource.wstyle.fontset, s, l, &ink, &logical);
 908     geom_w = logical.width;
 909
 910     geom_h = resource.wstyle.fontset_extents->max_ink_extent.height;
 911   } else {
 912     geom_w = XTextWidth(resource.wstyle.font, s, l);
 913
 914     geom_h = resource.wstyle.font->ascent +
 915              resource.wstyle.font->descent;
 916   }
 917
 918   geom_w += (resource.bevel_width * 2);
 919   geom_h += (resource.bevel_width * 2);
 920
 921   Pixmap tmp = geom_pixmap;
 922   if (resource.wstyle.l_focus.getTexture() & BImage_ParentRelative) {
 923     if (resource.wstyle.t_focus.getTexture() ==
 924                                       (BImage_Flat | BImage_Solid)) {
 925       geom_pixmap = None;
 926       XSetWindowBackground(getBaseDisplay().getXDisplay(), geom_window,
 927                          resource.wstyle.t_focus.getColor()->getPixel());
 928     } else {
 929       geom_pixmap = image_control->renderImage(geom_w, geom_h,
 930                                                &resource.wstyle.t_focus);
 931       XSetWindowBackgroundPixmap(getBaseDisplay().getXDisplay(),
 932                                  geom_window, geom_pixmap);
 933     }
 934   } else {
 935     if (resource.wstyle.l_focus.getTexture() ==
 936                                       (BImage_Flat | BImage_Solid)) {
 937       geom_pixmap = None;
 938       XSetWindowBackground(getBaseDisplay().getXDisplay(), geom_window,
 939                          resource.wstyle.l_focus.getColor()->getPixel());
 940     } else {
 941       geom_pixmap = image_control->renderImage(geom_w, geom_h,
 942                                                &resource.wstyle.l_focus);
 943       XSetWindowBackgroundPixmap(getBaseDisplay().getXDisplay(),
 944                                  geom_window, geom_pixmap);
 945     }
 946   }
 947   if (tmp) image_control->removeImage(tmp);
 948
 949   XSetWindowBorderWidth(getBaseDisplay().getXDisplay(), geom_window,
 950                         resource.border_width);
 951   XSetWindowBorder(getBaseDisplay().getXDisplay(), geom_window,
 952                    resource.border_color.getPixel());
 953
 954   workspacemenu->reconfigure();
 955   iconmenu->reconfigure();
 956
 957   {
 958     int remember_sub = rootmenu->getCurrentSubmenu();
 959     InitMenu();
 960     raiseWindows(0, 0);
 961     rootmenu->reconfigure();
 962     rootmenu->drawSubmenu(remember_sub);
 963   }
 964
 965   configmenu->reconfigure();
 966
 967   toolbar->reconfigure();
 968
 969 #ifdef    SLIT
 970   slit->reconfigure();
 971 #endif // SLIT
 972
 973   LinkedListIterator<Workspace> wit(workspacesList);
 974   for (Workspace *w = wit.current(); w; wit++, w = wit.current())
 975     w->reconfigure();
 976
 977   LinkedListIterator<OpenboxWindow> iit(iconList);
 978   for (OpenboxWindow *bw = iit.current(); bw; iit++, bw = iit.current())
 979     if (bw->validateClient())
 980       bw->reconfigure();
 981
 982   image_control->timeout();
 983 }
 984
 985
 986 void BScreen::rereadMenu(void) {
 987   InitMenu();
 988   raiseWindows(0, 0);
 989
 990   rootmenu->reconfigure();
 991 }
 992
 993
 994 void BScreen::removeWorkspaceNames(void) {
 995   while (workspaceNames->count())
 996    delete [] workspaceNames->remove(0);
 997 }
 998
 999
1000 void BScreen::LoadStyle(void) {
1001   Resource &conf = resource.styleconfig;
1002
1003   conf.setFile(openbox.getStyleFilename());
1004   if (!conf.load()) {
1005     conf.setFile(DEFAULTSTYLE);
1006     if (!conf.load()) {
1007       fprintf(stderr, i18n->getMessage(ScreenSet, ScreenDefaultStyleLoadFail,
1008                                        "BScreen::LoadStyle(): couldn't load "
1009                                        "default style.\n"));
1010       exit(2);
1011     }
1012   }
1013
1014   std::string s;
1015   long l;
1016
1017   // load fonts/fontsets
1018
1019   if (i18n->multibyte()) {
1020     readDatabaseFontSet("window.font", "Window.Font",
1021                         &resource.wstyle.fontset);
1022     readDatabaseFontSet("toolbar.font", "Toolbar.Font",
1023                         &resource.tstyle.fontset);
1024     readDatabaseFontSet("menu.title.font", "Menu.Title.Font",
1025                         &resource.mstyle.t_fontset);
1026     readDatabaseFontSet("menu.frame.font", "Menu.Frame.Font",
1027                         &resource.mstyle.f_fontset);
1028
1029     resource.mstyle.t_fontset_extents =
1030       XExtentsOfFontSet(resource.mstyle.t_fontset);
1031     resource.mstyle.f_fontset_extents =
1032       XExtentsOfFontSet(resource.mstyle.f_fontset);
1033     resource.tstyle.fontset_extents =
1034       XExtentsOfFontSet(resource.tstyle.fontset);
1035     resource.wstyle.fontset_extents =
1036       XExtentsOfFontSet(resource.wstyle.fontset);
1037   } else {
1038     readDatabaseFont("window.font", "Window.Font",
1039                      &resource.wstyle.font);
1040     readDatabaseFont("menu.title.font", "Menu.Title.Font",
1041                      &resource.mstyle.t_font);
1042     readDatabaseFont("menu.frame.font", "Menu.Frame.Font",
1043                      &resource.mstyle.f_font);
1044     readDatabaseFont("toolbar.font", "Toolbar.Font",
1045                      &resource.tstyle.font);
1046   }
1047
1048   // load window config
1049   readDatabaseTexture("window.title.focus", "Window.Title.Focus",
1050                       &resource.wstyle.t_focus,
1051                       WhitePixel(getBaseDisplay().getXDisplay(),
1052                                  getScreenNumber()));
1053   readDatabaseTexture("window.title.unfocus", "Window.Title.Unfocus",
1054                       &resource.wstyle.t_unfocus,
1055                       BlackPixel(getBaseDisplay().getXDisplay(),
1056                                  getScreenNumber()));
1057   readDatabaseTexture("window.label.focus", "Window.Label.Focus",
1058                       &resource.wstyle.l_focus,
1059                       WhitePixel(getBaseDisplay().getXDisplay(),
1060                                  getScreenNumber()));
1061   readDatabaseTexture("window.label.unfocus", "Window.Label.Unfocus",
1062                       &resource.wstyle.l_unfocus,
1063                       BlackPixel(getBaseDisplay().getXDisplay(),
1064                                  getScreenNumber()));
1065   readDatabaseTexture("window.handle.focus", "Window.Handle.Focus",
1066                       &resource.wstyle.h_focus,
1067                       WhitePixel(getBaseDisplay().getXDisplay(),
1068                                  getScreenNumber()));
1069   readDatabaseTexture("window.handle.unfocus", "Window.Handle.Unfocus",
1070                       &resource.wstyle.h_unfocus,
1071                       BlackPixel(getBaseDisplay().getXDisplay(),
1072                                  getScreenNumber()));
1073   readDatabaseTexture("window.grip.focus", "Window.Grip.Focus",
1074                       &resource.wstyle.g_focus,
1075                       WhitePixel(getBaseDisplay().getXDisplay(),
1076                                  getScreenNumber()));
1077   readDatabaseTexture("window.grip.unfocus", "Window.Grip.Unfocus",
1078                       &resource.wstyle.g_unfocus,
1079                       BlackPixel(getBaseDisplay().getXDisplay(),
1080                                  getScreenNumber()));
1081   readDatabaseTexture("window.button.focus", "Window.Button.Focus",
1082                       &resource.wstyle.b_focus,
1083                       WhitePixel(getBaseDisplay().getXDisplay(),
1084                                  getScreenNumber()));
1085   readDatabaseTexture("window.button.unfocus", "Window.Button.Unfocus",
1086                       &resource.wstyle.b_unfocus,
1087                       BlackPixel(getBaseDisplay().getXDisplay(),
1088                                  getScreenNumber()));
1089   readDatabaseTexture("window.button.pressed", "Window.Button.Pressed",
1090                       &resource.wstyle.b_pressed,
1091                       BlackPixel(getBaseDisplay().getXDisplay(),
1092                                  getScreenNumber()));
1093   readDatabaseColor("window.frame.focusColor",
1094                     "Window.Frame.FocusColor",
1095                     &resource.wstyle.f_focus,
1096                     WhitePixel(getBaseDisplay().getXDisplay(),
1097                                getScreenNumber()));
1098   readDatabaseColor("window.frame.unfocusColor",
1099                     "Window.Frame.UnfocusColor",
1100                     &resource.wstyle.f_unfocus,
1101                     BlackPixel(getBaseDisplay().getXDisplay(),
1102                                getScreenNumber()));
1103   readDatabaseColor("window.label.focus.textColor",
1104                     "Window.Label.Focus.TextColor",
1105                     &resource.wstyle.l_text_focus,
1106                     BlackPixel(getBaseDisplay().getXDisplay(),
1107                                getScreenNumber()));
1108   readDatabaseColor("window.label.unfocus.textColor",
1109                     "Window.Label.Unfocus.TextColor",
1110                     &resource.wstyle.l_text_unfocus,
1111                     WhitePixel(getBaseDisplay().getXDisplay(),
1112                                getScreenNumber()));
1113   readDatabaseColor("window.button.focus.picColor",
1114                     "Window.Button.Focus.PicColor",
1115                     &resource.wstyle.b_pic_focus,
1116                     BlackPixel(getBaseDisplay().getXDisplay(),
1117                                getScreenNumber()));
1118   readDatabaseColor("window.button.unfocus.picColor",
1119                     "Window.Button.Unfocus.PicColor",
1120                     &resource.wstyle.b_pic_unfocus,
1121                     WhitePixel(getBaseDisplay().getXDisplay(),
1122                                getScreenNumber()));
1123
1124   if (conf.getValue("window.justify", "Window.Justify", s)) {
1125     if (0 == strncasecmp(s.c_str(), "right", s.length()))
1126       resource.wstyle.justify = BScreen::RightJustify;
1127     else if (0 == strncasecmp(s.c_str(), "center", s.length()))
1128       resource.wstyle.justify = BScreen::CenterJustify;
1129     else
1130       resource.wstyle.justify = BScreen::LeftJustify;
1131   } else
1132     resource.wstyle.justify = BScreen::LeftJustify;
1133
1134   // load toolbar config
1135   readDatabaseTexture("toolbar", "Toolbar",
1136                       &resource.tstyle.toolbar,
1137                       BlackPixel(getBaseDisplay().getXDisplay(),
1138                                  getScreenNumber()));
1139   readDatabaseTexture("toolbar.label", "Toolbar.Label",
1140                       &resource.tstyle.label,
1141                       BlackPixel(getBaseDisplay().getXDisplay(),
1142                                  getScreenNumber()));
1143   readDatabaseTexture("toolbar.windowLabel", "Toolbar.WindowLabel",
1144                       &resource.tstyle.window,
1145                       BlackPixel(getBaseDisplay().getXDisplay(),
1146                                  getScreenNumber()));
1147   readDatabaseTexture("toolbar.button", "Toolbar.Button",
1148                       &resource.tstyle.button,
1149                       WhitePixel(getBaseDisplay().getXDisplay(),
1150                                  getScreenNumber()));
1151   readDatabaseTexture("toolbar.button.pressed", "Toolbar.Button.Pressed",
1152                       &resource.tstyle.pressed,
1153                       BlackPixel(getBaseDisplay().getXDisplay(),
1154                                  getScreenNumber()));
1155   readDatabaseTexture("toolbar.clock", "Toolbar.Clock",
1156                       &resource.tstyle.clock,
1157                       BlackPixel(getBaseDisplay().getXDisplay(),
1158                                  getScreenNumber()));
1159   readDatabaseColor("toolbar.label.textColor", "Toolbar.Label.TextColor",
1160                     &resource.tstyle.l_text,
1161                     WhitePixel(getBaseDisplay().getXDisplay(),
1162                                getScreenNumber()));
1163   readDatabaseColor("toolbar.windowLabel.textColor",
1164                     "Toolbar.WindowLabel.TextColor",
1165                     &resource.tstyle.w_text,
1166                     WhitePixel(getBaseDisplay().getXDisplay(),
1167                                getScreenNumber()));
1168   readDatabaseColor("toolbar.clock.textColor", "Toolbar.Clock.TextColor",
1169                     &resource.tstyle.c_text,
1170                     WhitePixel(getBaseDisplay().getXDisplay(),
1171                                getScreenNumber()));
1172   readDatabaseColor("toolbar.button.picColor", "Toolbar.Button.PicColor",
1173                     &resource.tstyle.b_pic,
1174                     BlackPixel(getBaseDisplay().getXDisplay(),
1175                                getScreenNumber()));
1176
1177   if (conf.getValue("toolbar.justify", "Toolbar.Justify", s)) {
1178     if (0 == strncasecmp(s.c_str(), "right", s.length()))
1179       resource.tstyle.justify = BScreen::RightJustify;
1180     else if (0 == strncasecmp(s.c_str(), "center", s.length()))
1181       resource.tstyle.justify = BScreen::CenterJustify;
1182     else
1183       resource.tstyle.justify = BScreen::LeftJustify;
1184   } else
1185     resource.tstyle.justify = BScreen::LeftJustify;
1186
1187   // load menu config
1188   readDatabaseTexture("menu.title", "Menu.Title",
1189                       &resource.mstyle.title,
1190                       WhitePixel(getBaseDisplay().getXDisplay(),
1191                                  getScreenNumber()));
1192   readDatabaseTexture("menu.frame", "Menu.Frame",
1193                       &resource.mstyle.frame,
1194                       BlackPixel(getBaseDisplay().getXDisplay(),
1195                                  getScreenNumber()));
1196   readDatabaseTexture("menu.hilite", "Menu.Hilite",
1197                       &resource.mstyle.hilite,
1198                       WhitePixel(getBaseDisplay().getXDisplay(),
1199                                  getScreenNumber()));
1200   readDatabaseColor("menu.title.textColor", "Menu.Title.TextColor",
1201                     &resource.mstyle.t_text,
1202                     BlackPixel(getBaseDisplay().getXDisplay(),
1203                                getScreenNumber()));
1204   readDatabaseColor("menu.frame.textColor", "Menu.Frame.TextColor",
1205                     &resource.mstyle.f_text,
1206                     WhitePixel(getBaseDisplay().getXDisplay(),
1207                                getScreenNumber()));
1208   readDatabaseColor("menu.frame.disableColor", "Menu.Frame.DisableColor",
1209                     &resource.mstyle.d_text,
1210                     BlackPixel(getBaseDisplay().getXDisplay(),
1211                                getScreenNumber()));
1212   readDatabaseColor("menu.hilite.textColor", "Menu.Hilite.TextColor",
1213                     &resource.mstyle.h_text,
1214                     BlackPixel(getBaseDisplay().getXDisplay(),
1215                                getScreenNumber()));
1216
1217   if (conf.getValue("menu.title.justify", "Menu.Title.Justify", s)) {
1218     if (0 == strncasecmp(s.c_str(), "right", s.length()))
1219       resource.mstyle.t_justify = BScreen::RightJustify;
1220     else if (0 == strncasecmp(s.c_str(), "center", s.length()))
1221       resource.mstyle.t_justify = BScreen::CenterJustify;
1222     else
1223       resource.mstyle.t_justify = BScreen::LeftJustify;
1224   } else
1225     resource.mstyle.t_justify = BScreen::LeftJustify;
1226
1227   if (conf.getValue("menu.frame.justify", "Menu.Frame.Justify", s)) {
1228     if (0 == strncasecmp(s.c_str(), "right", s.length()))
1229       resource.mstyle.f_justify = BScreen::RightJustify;
1230     else if (0 == strncasecmp(s.c_str(), "center", s.length()))
1231       resource.mstyle.f_justify = BScreen::CenterJustify;
1232     else
1233       resource.mstyle.f_justify = BScreen::LeftJustify;
1234   } else
1235     resource.mstyle.f_justify = BScreen::LeftJustify;
1236
1237   if (conf.getValue("menu.bullet", "Menu.Bullet", s)) {
1238     if (0 == strncasecmp(s.c_str(), "empty", s.length()))
1239       resource.mstyle.bullet = Basemenu::Empty;
1240     else if (0 == strncasecmp(s.c_str(), "square", s.length()))
1241       resource.mstyle.bullet = Basemenu::Square;
1242     else if (0 == strncasecmp(s.c_str(), "diamond", s.length()))
1243       resource.mstyle.bullet = Basemenu::Diamond;
1244     else
1245       resource.mstyle.bullet = Basemenu::Triangle;
1246   } else
1247     resource.mstyle.bullet = Basemenu::Triangle;
1248
1249   if (conf.getValue("menu.bullet.position", "Menu.Bullet.Position", s)) {
1250     if (0 == strncasecmp(s.c_str(), "right", s.length()))
1251       resource.mstyle.bullet_pos = Basemenu::Right;
1252     else
1253       resource.mstyle.bullet_pos = Basemenu::Left;
1254   } else
1255     resource.mstyle.bullet_pos = Basemenu::Left;
1256
1257   readDatabaseColor("borderColor", "BorderColor", &resource.border_color,
1258                     BlackPixel(getBaseDisplay().getXDisplay(),
1259                                getScreenNumber()));
1260
1261   // load bevel, border and handle widths
1262   if (conf.getValue("handleWidth", "HandleWidth", l)) {
1263     if (l <= size().w() / 2 && l != 0)
1264       resource.handle_width = l;
1265     else
1266       resource.handle_width = 6;
1267   } else
1268     resource.handle_width = 6;
1269
1270   if (conf.getValue("borderWidth", "BorderWidth", l))
1271     resource.border_width = l;
1272   else
1273     resource.border_width = 1;
1274
1275   if (conf.getValue("bevelWidth", "BevelWidth", l)) {
1276     if (l <= size().w() / 2 && l != 0)
1277       resource.bevel_width = l;
1278     else
1279       resource.bevel_width = 3;
1280   } else
1281     resource.bevel_width = 3;
1282
1283   if (conf.getValue("frameWidth", "FrameWidth", l)) {
1284     if (l <= size().w() / 2)
1285       resource.frame_width = l;
1286     else
1287       resource.frame_width = resource.bevel_width;
1288   } else
1289     resource.frame_width = resource.bevel_width;
1290
1291   const char *cmd = resource.root_command;
1292   if (cmd != NULL || conf.getValue("rootCommand", "RootCommand", s)) {
1293     if (cmd == NULL)
1294       cmd = s.c_str(); // not specified by the screen, so use the one from the
1295                        // style file
1296 #ifndef    __EMX__
1297     char displaystring[MAXPATHLEN];
1298     sprintf(displaystring, "DISPLAY=%s",
1299             DisplayString(getBaseDisplay().getXDisplay()));
1300     sprintf(displaystring + strlen(displaystring) - 1, "%d",
1301             getScreenNumber());
1302
1303     bexec(cmd, displaystring);
1304 #else //   __EMX__
1305     spawnlp(P_NOWAIT, "cmd.exe", "cmd.exe", "/c", cmd, NULL);
1306 #endif // !__EMX__
1307   }
1308 }
1309
1310
1311 void BScreen::addIcon(OpenboxWindow *w) {
1312   if (! w) return;
1313
1314   w->setWorkspace(-1);
1315   w->setWindowNumber(iconList->count());
1316
1317   iconList->insert(w);
1318
1319   iconmenu->insert((const char **) w->getIconTitle());
1320   iconmenu->update();
1321 }
1322
1323
1324 void BScreen::removeIcon(OpenboxWindow *w) {
1325   if (! w) return;
1326
1327   iconList->remove(w->getWindowNumber());
1328
1329   iconmenu->remove(w->getWindowNumber());
1330   iconmenu->update();
1331
1332   LinkedListIterator<OpenboxWindow> it(iconList);
1333   OpenboxWindow *bw = it.current();
1334   for (int i = 0; bw; it++, bw = it.current())
1335     bw->setWindowNumber(i++);
1336 }
1337
1338
1339 OpenboxWindow *BScreen::getIcon(int index) {
1340   if (index >= 0 && index < iconList->count())
1341     return iconList->find(index);
1342
1343   return (OpenboxWindow *) 0;
1344 }
1345
1346
1347 int BScreen::addWorkspace(void) {
1348   Workspace *wkspc = new Workspace(*this, workspacesList->count());
1349   workspacesList->insert(wkspc);
1350
1351   workspacemenu->insert(wkspc->getName(), wkspc->getMenu(),
1352                         wkspc->getWorkspaceID() + 2);
1353   workspacemenu->update();
1354
1355   toolbar->reconfigure();
1356
1357   updateNetizenWorkspaceCount();
1358
1359   return workspacesList->count();
1360 }
1361
1362
1363 int BScreen::removeLastWorkspace(void) {
1364   if (workspacesList->count() == 1)
1365     return 0;
1366
1367   Workspace *wkspc = workspacesList->last();
1368
1369   if (current_workspace->getWorkspaceID() == wkspc->getWorkspaceID())
1370     changeWorkspaceID(current_workspace->getWorkspaceID() - 1);
1371
1372   wkspc->removeAll();
1373
1374   workspacemenu->remove(wkspc->getWorkspaceID() + 2);
1375   workspacemenu->update();
1376
1377   workspacesList->remove(wkspc);
1378   delete wkspc;
1379
1380   toolbar->reconfigure();
1381
1382   updateNetizenWorkspaceCount();
1383
1384   return workspacesList->count();
1385 }
1386
1387
1388 void BScreen::changeWorkspaceID(int id) {
1389   if (! current_workspace) return;
1390
1391   if (id != current_workspace->getWorkspaceID()) {
1392     current_workspace->hideAll();
1393
1394     workspacemenu->setItemSelected(current_workspace->getWorkspaceID() + 2,
1395                                    False);
1396
1397     if (openbox.getFocusedWindow() &&
1398         openbox.getFocusedWindow()->getScreen() == this &&
1399         (! openbox.getFocusedWindow()->isStuck())) {
1400       current_workspace->setLastFocusedWindow(openbox.getFocusedWindow());
1401       openbox.setFocusedWindow((OpenboxWindow *) 0);
1402     }
1403
1404     current_workspace = getWorkspace(id);
1405
1406     workspacemenu->setItemSelected(current_workspace->getWorkspaceID() + 2,
1407                                    True);
1408     toolbar->redrawWorkspaceLabel(True);
1409
1410     current_workspace->showAll();
1411
1412     if (resource.focus_last && current_workspace->getLastFocusedWindow()) {
1413       XSync(openbox.getXDisplay(), False);
1414       current_workspace->getLastFocusedWindow()->setInputFocus();
1415     }
1416   }
1417
1418   updateNetizenCurrentWorkspace();
1419 }
1420
1421
1422 void BScreen::addNetizen(Netizen *n) {
1423   netizenList->insert(n);
1424
1425   n->sendWorkspaceCount();
1426   n->sendCurrentWorkspace();
1427
1428   LinkedListIterator<Workspace> it(workspacesList);
1429   for (Workspace *w = it.current(); w; it++, w = it.current()) {
1430     for (int i = 0; i < w->getCount(); i++)
1431       n->sendWindowAdd(w->getWindow(i)->getClientWindow(),
1432                        w->getWorkspaceID());
1433   }
1434
1435   Window f = ((openbox.getFocusedWindow()) ?
1436               openbox.getFocusedWindow()->getClientWindow() : None);
1437   n->sendWindowFocus(f);
1438 }
1439
1440
1441 void BScreen::removeNetizen(Window w) {
1442   LinkedListIterator<Netizen> it(netizenList);
1443   int i = 0;
1444
1445   for (Netizen *n = it.current(); n; it++, i++, n = it.current())
1446     if (n->getWindowID() == w) {
1447       Netizen *tmp = netizenList->remove(i);
1448       delete tmp;
1449
1450       break;
1451     }
1452 }
1453
1454
1455 void BScreen::updateNetizenCurrentWorkspace(void) {
1456   LinkedListIterator<Netizen> it(netizenList);
1457   for (Netizen *n = it.current(); n; it++, n = it.current())
1458     n->sendCurrentWorkspace();
1459 }
1460
1461
1462 void BScreen::updateNetizenWorkspaceCount(void) {
1463   LinkedListIterator<Netizen> it(netizenList);
1464   for (Netizen *n = it.current(); n; it++, n = it.current())
1465     n->sendWorkspaceCount();
1466 }
1467
1468
1469 void BScreen::updateNetizenWindowFocus(void) {
1470   Window f = ((openbox.getFocusedWindow()) ?
1471               openbox.getFocusedWindow()->getClientWindow() : None);
1472   LinkedListIterator<Netizen> it(netizenList);
1473   for (Netizen *n = it.current(); n; it++, n = it.current())
1474     n->sendWindowFocus(f);
1475 }
1476
1477
1478 void BScreen::updateNetizenWindowAdd(Window w, unsigned long p) {
1479   LinkedListIterator<Netizen> it(netizenList);
1480   for (Netizen *n = it.current(); n; it++, n = it.current())
1481     n->sendWindowAdd(w, p);
1482 }
1483
1484
1485 void BScreen::updateNetizenWindowDel(Window w) {
1486   LinkedListIterator<Netizen> it(netizenList);
1487   for (Netizen *n = it.current(); n; it++, n = it.current())
1488     n->sendWindowDel(w);
1489 }
1490
1491
1492 void BScreen::updateNetizenWindowRaise(Window w) {
1493   LinkedListIterator<Netizen> it(netizenList);
1494   for (Netizen *n = it.current(); n; it++, n = it.current())
1495     n->sendWindowRaise(w);
1496 }
1497
1498
1499 void BScreen::updateNetizenWindowLower(Window w) {
1500   LinkedListIterator<Netizen> it(netizenList);
1501   for (Netizen *n = it.current(); n; it++, n = it.current())
1502     n->sendWindowLower(w);
1503 }
1504
1505
1506 void BScreen::updateNetizenConfigNotify(XEvent *e) {
1507   LinkedListIterator<Netizen> it(netizenList);
1508   for (Netizen *n = it.current(); n; it++, n = it.current())
1509     n->sendConfigNotify(e);
1510 }
1511
1512
1513 void BScreen::raiseWindows(Window *workspace_stack, int num) {
1514   Window *session_stack = new
1515     Window[(num + workspacesList->count() + rootmenuList->count() + 13)];
1516   int i = 0, k = num;
1517
1518   XRaiseWindow(getBaseDisplay().getXDisplay(), iconmenu->getWindowID());
1519   *(session_stack + i++) = iconmenu->getWindowID();
1520
1521   LinkedListIterator<Workspace> wit(workspacesList);
1522   for (Workspace *tmp = wit.current(); tmp; wit++, tmp = wit.current())
1523     *(session_stack + i++) = tmp->getMenu()->getWindowID();
1524
1525   *(session_stack + i++) = workspacemenu->getWindowID();
1526
1527   *(session_stack + i++) = configmenu->getFocusmenu()->getWindowID();
1528   *(session_stack + i++) = configmenu->getPlacementmenu()->getWindowID();
1529   *(session_stack + i++) = configmenu->getWindowID();
1530
1531 #ifdef    SLIT
1532   *(session_stack + i++) = slit->getMenu()->getDirectionmenu()->getWindowID();
1533   *(session_stack + i++) = slit->getMenu()->getPlacementmenu()->getWindowID();
1534   *(session_stack + i++) = slit->getMenu()->getWindowID();
1535 #endif // SLIT
1536
1537   *(session_stack + i++) =
1538     toolbar->getMenu()->getPlacementmenu()->getWindowID();
1539   *(session_stack + i++) = toolbar->getMenu()->getWindowID();
1540
1541   LinkedListIterator<Rootmenu> rit(rootmenuList);
1542   for (Rootmenu *tmp = rit.current(); tmp; rit++, tmp = rit.current())
1543     *(session_stack + i++) = tmp->getWindowID();
1544   *(session_stack + i++) = rootmenu->getWindowID();
1545
1546   if (toolbar->isOnTop())
1547     *(session_stack + i++) = toolbar->getWindowID();
1548
1549 #ifdef    SLIT
1550   if (slit->onTop())
1551     *(session_stack + i++) = slit->getWindowID();
1552 #endif // SLIT
1553
1554   while (k--)
1555     *(session_stack + i++) = *(workspace_stack + k);
1556
1557   XRestackWindows(getBaseDisplay().getXDisplay(), session_stack, i);
1558
1559   delete [] session_stack;
1560 }
1561
1562
1563 #ifdef    HAVE_STRFTIME
1564 void BScreen::saveStrftimeFormat(const char *format) {
1565   if (resource.strftime_format)
1566     delete [] resource.strftime_format;
1567
1568   resource.strftime_format = bstrdup(format);
1569 }
1570 #endif // HAVE_STRFTIME
1571
1572
1573 void BScreen::addWorkspaceName(const char *name) {
1574   workspaceNames->insert(bstrdup(name));
1575 }
1576
1577
1578 char* BScreen::getNameOfWorkspace(int id) {
1579   char *name = (char *) 0;
1580
1581   if (id >= 0 && id < workspaceNames->count()) {
1582     char *wkspc_name = workspaceNames->find(id);
1583
1584     if (wkspc_name)
1585       name = wkspc_name;
1586   }
1587   return name;
1588 }
1589
1590
1591 void BScreen::reassociateWindow(OpenboxWindow *w, int wkspc_id, Bool ignore_sticky) {
1592   if (! w) return;
1593
1594   if (wkspc_id == -1)
1595     wkspc_id = current_workspace->getWorkspaceID();
1596
1597   if (w->getWorkspaceNumber() == wkspc_id)
1598     return;
1599
1600   if (w->isIconic()) {
1601     removeIcon(w);
1602     getWorkspace(wkspc_id)->addWindow(w);
1603   } else if (ignore_sticky || ! w->isStuck()) {
1604     getWorkspace(w->getWorkspaceNumber())->removeWindow(w);
1605     getWorkspace(wkspc_id)->addWindow(w);
1606   }
1607 }
1608
1609
1610 void BScreen::nextFocus(void) {
1611   Bool have_focused = False;
1612   int focused_window_number = -1;
1613   OpenboxWindow *next;
1614
1615   if (openbox.getFocusedWindow()) {
1616     if (openbox.getFocusedWindow()->getScreen()->getScreenNumber() ==
1617         getScreenNumber()) {
1618       have_focused = True;
1619       focused_window_number = openbox.getFocusedWindow()->getWindowNumber();
1620     }
1621   }
1622
1623   if ((getCurrentWorkspace()->getCount() > 1) && have_focused) {
1624     int next_window_number = focused_window_number;
1625     do {
1626       if ((++next_window_number) >= getCurrentWorkspace()->getCount())
1627         next_window_number = 0;
1628
1629       next = getCurrentWorkspace()->getWindow(next_window_number);
1630     } while ((! next->setInputFocus()) && (next_window_number !=
1631                                            focused_window_number));
1632
1633     if (next_window_number != focused_window_number)
1634       getCurrentWorkspace()->raiseWindow(next);
1635   } else if (getCurrentWorkspace()->getCount() >= 1) {
1636     next = current_workspace->getWindow(0);
1637
1638     current_workspace->raiseWindow(next);
1639     next->setInputFocus();
1640   }
1641 }
1642
1643
1644 void BScreen::prevFocus(void) {
1645   Bool have_focused = False;
1646   int focused_window_number = -1;
1647   OpenboxWindow *prev;
1648
1649   if (openbox.getFocusedWindow()) {
1650     if (openbox.getFocusedWindow()->getScreen()->getScreenNumber() ==
1651         getScreenNumber()) {
1652       have_focused = True;
1653       focused_window_number = openbox.getFocusedWindow()->getWindowNumber();
1654     }
1655   }
1656
1657   if ((getCurrentWorkspace()->getCount() > 1) && have_focused) {
1658     int prev_window_number = focused_window_number;
1659     do {
1660       if ((--prev_window_number) < 0)
1661         prev_window_number = getCurrentWorkspace()->getCount() - 1;
1662
1663       prev = getCurrentWorkspace()->getWindow(prev_window_number);
1664     } while ((! prev->setInputFocus()) && (prev_window_number !=
1665                                            focused_window_number));
1666
1667     if (prev_window_number != focused_window_number)
1668       getCurrentWorkspace()->raiseWindow(prev);
1669   } else if (getCurrentWorkspace()->getCount() >= 1) {
1670     prev = current_workspace->getWindow(0);
1671
1672     current_workspace->raiseWindow(prev);
1673     prev->setInputFocus();
1674   }
1675 }
1676
1677
1678 void BScreen::raiseFocus(void) {
1679   Bool have_focused = False;
1680   int focused_window_number = -1;
1681
1682   if (openbox.getFocusedWindow()) {
1683     if (openbox.getFocusedWindow()->getScreen()->getScreenNumber() ==
1684         getScreenNumber()) {
1685       have_focused = True;
1686       focused_window_number = openbox.getFocusedWindow()->getWindowNumber();
1687     }
1688   }
1689
1690   if ((getCurrentWorkspace()->getCount() > 1) && have_focused)
1691     getWorkspace(openbox.getFocusedWindow()->getWorkspaceNumber())->
1692       raiseWindow(openbox.getFocusedWindow());
1693 }
1694
1695
1696 void BScreen::InitMenu(void) {
1697   if (rootmenu) {
1698     while (rootmenuList->count())
1699       rootmenuList->remove(0);
1700
1701     while (rootmenu->getCount())
1702       rootmenu->remove(0);
1703   } else {
1704     rootmenu = new Rootmenu(*this);
1705   }
1706   Bool defaultMenu = True;
1707
1708   if (openbox.getMenuFilename()) {
1709     FILE *menu_file = fopen(openbox.getMenuFilename(), "r");
1710
1711     if (!menu_file) {
1712       perror(openbox.getMenuFilename());
1713     } else {
1714       if (feof(menu_file)) {
1715         fprintf(stderr, i18n->getMessage(ScreenSet, ScreenEmptyMenuFile,
1716                                          "%s: Empty menu file"),
1717                 openbox.getMenuFilename());
1718       } else {
1719         char line[1024], label[1024];
1720         memset(line, 0, 1024);
1721         memset(label, 0, 1024);
1722
1723         while (fgets(line, 1024, menu_file) && ! feof(menu_file)) {
1724           if (line[0] != '#') {
1725             int i, key = 0, index = -1, len = strlen(line);
1726
1727             key = 0;
1728             for (i = 0; i < len; i++) {
1729               if (line[i] == '[') index = 0;
1730               else if (line[i] == ']') break;
1731               else if (line[i] != ' ')
1732                 if (index++ >= 0)
1733                   key += tolower(line[i]);
1734             }
1735
1736             if (key == 517) {
1737               index = -1;
1738               for (i = index; i < len; i++) {
1739                 if (line[i] == '(') index = 0;
1740                 else if (line[i] == ')') break;
1741                 else if (index++ >= 0) {
1742                   if (line[i] == '\\' && i < len - 1) i++;
1743                   label[index - 1] = line[i];
1744                 }
1745               }
1746
1747               if (index == -1) index = 0;
1748               label[index] = '\0';
1749
1750               rootmenu->setLabel(label);
1751               defaultMenu = parseMenuFile(menu_file, rootmenu);
1752               break;
1753             }
1754           }
1755         }
1756       }
1757       fclose(menu_file);
1758     }
1759   }
1760
1761   if (defaultMenu) {
1762     rootmenu->setInternalMenu();
1763     rootmenu->insert(i18n->getMessage(ScreenSet, Screenxterm, "xterm"),
1764                      BScreen::Execute,
1765                      i18n->getMessage(ScreenSet, Screenxterm, "xterm"));
1766     rootmenu->insert(i18n->getMessage(ScreenSet, ScreenRestart, "Restart"),
1767                      BScreen::Restart);
1768     rootmenu->insert(i18n->getMessage(ScreenSet, ScreenExit, "Exit"),
1769                      BScreen::Exit);
1770   } else {
1771     openbox.saveMenuFilename(openbox.getMenuFilename());
1772   }
1773 }
1774
1775
1776 Bool BScreen::parseMenuFile(FILE *file, Rootmenu *menu) {
1777   char line[1024], label[1024], command[1024];
1778
1779   while (! feof(file)) {
1780     memset(line, 0, 1024);
1781     memset(label, 0, 1024);
1782     memset(command, 0, 1024);
1783
1784     if (fgets(line, 1024, file)) {
1785       if (line[0] != '#') {
1786         register int i, key = 0, parse = 0, index = -1,
1787           line_length = strlen(line),
1788           label_length = 0, command_length = 0;
1789
1790         // determine the keyword
1791         key = 0;
1792         for (i = 0; i < line_length; i++) {
1793           if (line[i] == '[') parse = 1;
1794           else if (line[i] == ']') break;
1795           else if (line[i] != ' ')
1796             if (parse)
1797               key += tolower(line[i]);
1798         }
1799
1800         // get the label enclosed in ()'s
1801         parse = 0;
1802
1803         for (i = 0; i < line_length; i++) {
1804           if (line[i] == '(') {
1805             index = 0;
1806             parse = 1;
1807           } else if (line[i] == ')') break;
1808           else if (index++ >= 0) {
1809             if (line[i] == '\\' && i < line_length - 1) i++;
1810             label[index - 1] = line[i];
1811           }
1812         }
1813
1814         if (parse) {
1815           label[index] = '\0';
1816           label_length = index;
1817         } else {
1818           label[0] = '\0';
1819           label_length = 0;
1820         }
1821
1822         // get the command enclosed in {}'s
1823         parse = 0;
1824         index = -1;
1825         for (i = 0; i < line_length; i++) {
1826           if (line[i] == '{') {
1827             index = 0;
1828             parse = 1;
1829           } else if (line[i] == '}') break;
1830           else if (index++ >= 0) {
1831             if (line[i] == '\\' && i < line_length - 1) i++;
1832             command[index - 1] = line[i];
1833           }
1834         }
1835
1836         if (parse) {
1837           command[index] = '\0';
1838           command_length = index;
1839         } else {
1840           command[0] = '\0';
1841           command_length = 0;
1842         }
1843
1844         switch (key) {
1845         case 311: //end
1846           return ((menu->getCount() == 0) ? True : False);
1847
1848           break;
1849
1850         case 333: // nop
1851           menu->insert(label);
1852
1853           break;
1854
1855         case 421: // exec
1856           if ((! *label) && (! *command)) {
1857             fprintf(stderr, i18n->getMessage(ScreenSet, ScreenEXECError,
1858                              "BScreen::parseMenuFile: [exec] error, "
1859                              "no menu label and/or command defined\n"));
1860             continue;
1861           }
1862
1863           menu->insert(label, BScreen::Execute, command);
1864
1865           break;
1866
1867         case 442: // exit
1868           if (! *label) {
1869             fprintf(stderr, i18n->getMessage(ScreenSet, ScreenEXITError,
1870                                      "BScreen::parseMenuFile: [exit] error, "
1871                                      "no menu label defined\n"));
1872             continue;
1873           }
1874
1875           menu->insert(label, BScreen::Exit);
1876
1877           break;
1878
1879         case 561: // style
1880           {
1881             if ((! *label) || (! *command)) {
1882               fprintf(stderr, i18n->getMessage(ScreenSet, ScreenSTYLEError,
1883                                  "BScreen::parseMenuFile: [style] error, "
1884                                  "no menu label and/or filename defined\n"));
1885               continue;
1886             }
1887
1888             char style[MAXPATHLEN];
1889
1890             // perform shell style ~ home directory expansion
1891             char *homedir = 0;
1892             int homedir_len = 0;
1893             if (*command == '~' && *(command + 1) == '/') {
1894               homedir = getenv("HOME");
1895               homedir_len = strlen(homedir);
1896             }
1897
1898             if (homedir && homedir_len != 0) {
1899               strncpy(style, homedir, homedir_len);
1900
1901               strncpy(style + homedir_len, command + 1,
1902                       command_length - 1);
1903               *(style + command_length + homedir_len - 1) = '\0';
1904             } else {
1905               strncpy(style, command, command_length);
1906               *(style + command_length) = '\0';
1907             }
1908
1909             menu->insert(label, BScreen::SetStyle, style);
1910           }
1911
1912           break;
1913
1914         case 630: // config
1915           if (! *label) {
1916             fprintf(stderr, i18n->getMessage(ScreenSet, ScreenCONFIGError,
1917                                "BScreen::parseMenufile: [config] error, "
1918                                "no label defined"));
1919             continue;
1920           }
1921
1922           menu->insert(label, configmenu);
1923
1924           break;
1925
1926         case 740: // include
1927           {
1928             if (! *label) {
1929               fprintf(stderr, i18n->getMessage(ScreenSet, ScreenINCLUDEError,
1930                                  "BScreen::parseMenuFile: [include] error, "
1931                                  "no filename defined\n"));
1932               continue;
1933             }
1934
1935             char newfile[MAXPATHLEN];
1936
1937             // perform shell style ~ home directory expansion
1938             char *homedir = 0;
1939             int homedir_len = 0;
1940             if (*label == '~' && *(label + 1) == '/') {
1941               homedir = getenv("HOME");
1942               homedir_len = strlen(homedir);
1943             }
1944
1945             if (homedir && homedir_len != 0) {
1946               strncpy(newfile, homedir, homedir_len);
1947
1948               strncpy(newfile + homedir_len, label + 1,
1949                       label_length - 1);
1950               *(newfile + label_length + homedir_len - 1) = '\0';
1951             } else {
1952               strncpy(newfile, label, label_length);
1953               *(newfile + label_length) = '\0';
1954             }
1955
1956             if (newfile) {
1957               FILE *submenufile = fopen(newfile, "r");
1958
1959               if (submenufile) {
1960                 struct stat buf;
1961                 if (fstat(fileno(submenufile), &buf) ||
1962                     (! S_ISREG(buf.st_mode))) {
1963                   fprintf(stderr,
1964                           i18n->getMessage(ScreenSet, ScreenINCLUDEErrorReg,
1965                              "BScreen::parseMenuFile: [include] error: "
1966                              "'%s' is not a regular file\n"), newfile);
1967                   break;
1968                 }
1969
1970                 if (! feof(submenufile)) {
1971                   if (! parseMenuFile(submenufile, menu))
1972                     openbox.saveMenuFilename(newfile);
1973
1974                   fclose(submenufile);
1975                 }
1976               } else
1977                 perror(newfile);
1978             }
1979           }
1980
1981           break;
1982
1983         case 767: // submenu
1984           {
1985             if (! *label) {
1986               fprintf(stderr, i18n->getMessage(ScreenSet, ScreenSUBMENUError,
1987                                  "BScreen::parseMenuFile: [submenu] error, "
1988                                  "no menu label defined\n"));
1989               continue;
1990             }
1991
1992             Rootmenu *submenu = new Rootmenu(*this);
1993
1994             if (*command)
1995               submenu->setLabel(command);
1996             else
1997               submenu->setLabel(label);
1998
1999             parseMenuFile(file, submenu);
2000             submenu->update();
2001             menu->insert(label, submenu);
2002             rootmenuList->insert(submenu);
2003           }
2004
2005           break;
2006
2007         case 773: // restart
2008           {
2009             if (! *label) {
2010               fprintf(stderr, i18n->getMessage(ScreenSet, ScreenRESTARTError,
2011                                  "BScreen::parseMenuFile: [restart] error, "
2012                                  "no menu label defined\n"));
2013               continue;
2014             }
2015
2016             if (*command)
2017               menu->insert(label, BScreen::RestartOther, command);
2018             else
2019               menu->insert(label, BScreen::Restart);
2020           }
2021
2022           break;
2023
2024         case 845: // reconfig
2025           {
2026             if (! *label) {
2027               fprintf(stderr, i18n->getMessage(ScreenSet, ScreenRECONFIGError,
2028                                  "BScreen::parseMenuFile: [reconfig] error, "
2029                                  "no menu label defined\n"));
2030               continue;
2031             }
2032
2033             menu->insert(label, BScreen::Reconfigure);
2034           }
2035
2036           break;
2037
2038         case 995: // stylesdir
2039         case 1113: // stylesmenu
2040           {
2041             Bool newmenu = ((key == 1113) ? True : False);
2042
2043             if ((! *label) || ((! *command) && newmenu)) {
2044               fprintf(stderr,
2045                       i18n->getMessage(ScreenSet, ScreenSTYLESDIRError,
2046                          "BScreen::parseMenuFile: [stylesdir/stylesmenu]"
2047                          " error, no directory defined\n"));
2048               continue;
2049             }
2050
2051             char stylesdir[MAXPATHLEN];
2052
2053             char *directory = ((newmenu) ? command : label);
2054             int directory_length = ((newmenu) ? command_length : label_length);
2055
2056             // perform shell style ~ home directory expansion
2057             char *homedir = 0;
2058             int homedir_len = 0;
2059
2060             if (*directory == '~' && *(directory + 1) == '/') {
2061               homedir = getenv("HOME");
2062               homedir_len = strlen(homedir);
2063             }
2064
2065             if (homedir && homedir_len != 0) {
2066               strncpy(stylesdir, homedir, homedir_len);
2067
2068               strncpy(stylesdir + homedir_len, directory + 1,
2069                       directory_length - 1);
2070               *(stylesdir + directory_length + homedir_len - 1) = '\0';
2071             } else {
2072               strncpy(stylesdir, directory, directory_length);
2073               *(stylesdir + directory_length) = '\0';
2074             }
2075
2076             struct stat statbuf;
2077
2078             if (! stat(stylesdir, &statbuf)) {
2079               if (S_ISDIR(statbuf.st_mode)) {
2080                 Rootmenu *stylesmenu;
2081
2082                 if (newmenu)
2083                   stylesmenu = new Rootmenu(*this);
2084                 else
2085                   stylesmenu = menu;
2086
2087                 DIR *d = opendir(stylesdir);
2088                 int entries = 0;
2089                 struct dirent *p;
2090
2091                 // get the total number of directory entries
2092                 while ((p = readdir(d))) entries++;
2093                 rewinddir(d);
2094
2095                 char **ls = new char* [entries];
2096                 int index = 0;
2097                 while ((p = readdir(d)))
2098                   ls[index++] = bstrdup(p->d_name);
2099
2100                 closedir(d);
2101
2102                 std::sort(ls, ls + entries, dcmp());
2103
2104                 int n, slen = strlen(stylesdir);
2105                 for (n = 0; n < entries; n++) {
2106                   if (ls[n][strlen(ls[n])-1] != '~') {
2107                     int nlen = strlen(ls[n]);
2108                     char style[MAXPATHLEN + 1];
2109
2110                     strncpy(style, stylesdir, slen);
2111                     *(style + slen) = '/';
2112                     strncpy(style + slen + 1, ls[n], nlen + 1);
2113
2114                     if ((! stat(style, &statbuf)) && S_ISREG(statbuf.st_mode))
2115                       stylesmenu->insert(ls[n], BScreen::SetStyle, style);
2116                   }
2117
2118                   delete [] ls[n];
2119                 }
2120
2121                 delete [] ls;
2122
2123                 stylesmenu->update();
2124
2125                 if (newmenu) {
2126                   stylesmenu->setLabel(label);
2127                   menu->insert(label, stylesmenu);
2128                   rootmenuList->insert(stylesmenu);
2129                 }
2130
2131                 openbox.saveMenuFilename(stylesdir);
2132               } else {
2133                 fprintf(stderr, i18n->getMessage(ScreenSet,
2134                                                  ScreenSTYLESDIRErrorNotDir,
2135                                    "BScreen::parseMenuFile:"
2136                                    " [stylesdir/stylesmenu] error, %s is not a"
2137                                    " directory\n"), stylesdir);
2138               }
2139             } else {
2140               fprintf(stderr,
2141                       i18n->getMessage(ScreenSet, ScreenSTYLESDIRErrorNoExist,
2142                          "BScreen::parseMenuFile: [stylesdir/stylesmenu]"
2143                          " error, %s does not exist\n"), stylesdir);
2144             }
2145
2146             break;
2147           }
2148
2149         case 1090: // workspaces
2150           {
2151             if (! *label) {
2152               fprintf(stderr,
2153                       i18n->getMessage(ScreenSet, ScreenWORKSPACESError,
2154                                "BScreen:parseMenuFile: [workspaces] error, "
2155                                "no menu label defined\n"));
2156               continue;
2157             }
2158
2159             menu->insert(label, workspacemenu);
2160
2161             break;
2162           }
2163         }
2164       }
2165     }
2166   }
2167
2168   return ((menu->getCount() == 0) ? True : False);
2169 }
2170
2171
2172 void BScreen::shutdown(void) {
2173   openbox.grab();
2174
2175   XSelectInput(getBaseDisplay().getXDisplay(), getRootWindow(), NoEventMask);
2176   XSync(getBaseDisplay().getXDisplay(), False);
2177
2178   LinkedListIterator<Workspace> it(workspacesList);
2179   for (Workspace *w = it.current(); w; it++, w = it.current())
2180     w->shutdown();
2181
2182   while (iconList->count()) {
2183     iconList->first()->restore();
2184     delete iconList->first();
2185   }
2186
2187 #ifdef    SLIT
2188   slit->shutdown();
2189 #endif // SLIT
2190
2191   openbox.ungrab();
2192 }
2193
2194
2195 void BScreen::showPosition(int x, int y) {
2196   if (! geom_visible) {
2197     XMoveResizeWindow(getBaseDisplay().getXDisplay(), geom_window,
2198                       (size().w() - geom_w) / 2,
2199                       (size().h() - geom_h) / 2, geom_w, geom_h);
2200     XMapWindow(getBaseDisplay().getXDisplay(), geom_window);
2201     XRaiseWindow(getBaseDisplay().getXDisplay(), geom_window);
2202
2203     geom_visible = True;
2204   }
2205
2206   char label[1024];
2207
2208   sprintf(label, i18n->getMessage(ScreenSet, ScreenPositionFormat,
2209                                   "X: %4d x Y: %4d"), x, y);
2210
2211   XClearWindow(getBaseDisplay().getXDisplay(), geom_window);
2212
2213   if (i18n->multibyte()) {
2214     XmbDrawString(getBaseDisplay().getXDisplay(), geom_window,
2215                   resource.wstyle.fontset, resource.wstyle.l_text_focus_gc,
2216                   resource.bevel_width, resource.bevel_width -
2217                   resource.wstyle.fontset_extents->max_ink_extent.y,
2218                   label, strlen(label));
2219   } else {
2220     XDrawString(getBaseDisplay().getXDisplay(), geom_window,
2221                 resource.wstyle.l_text_focus_gc,
2222                 resource.bevel_width,
2223                 resource.wstyle.font->ascent +
2224                 resource.bevel_width, label, strlen(label));
2225   }
2226 }
2227
2228
2229 void BScreen::showGeometry(unsigned int gx, unsigned int gy) {
2230   if (! geom_visible) {
2231     XMoveResizeWindow(getBaseDisplay().getXDisplay(), geom_window,
2232                       (size().w() - geom_w) / 2,
2233                       (size().h() - geom_h) / 2, geom_w, geom_h);
2234     XMapWindow(getBaseDisplay().getXDisplay(), geom_window);
2235     XRaiseWindow(getBaseDisplay().getXDisplay(), geom_window);
2236
2237     geom_visible = True;
2238   }
2239
2240   char label[1024];
2241
2242   sprintf(label, i18n->getMessage(ScreenSet, ScreenGeometryFormat,
2243                                   "W: %4d x H: %4d"), gx, gy);
2244
2245   XClearWindow(getBaseDisplay().getXDisplay(), geom_window);
2246
2247   if (i18n->multibyte()) {
2248     XmbDrawString(getBaseDisplay().getXDisplay(), geom_window,
2249                   resource.wstyle.fontset, resource.wstyle.l_text_focus_gc,
2250                   resource.bevel_width, resource.bevel_width -
2251                   resource.wstyle.fontset_extents->max_ink_extent.y,
2252                   label, strlen(label));
2253   } else {
2254     XDrawString(getBaseDisplay().getXDisplay(), geom_window,
2255                 resource.wstyle.l_text_focus_gc,
2256                 resource.bevel_width,
2257                 resource.wstyle.font->ascent +
2258                 resource.bevel_width, label, strlen(label));
2259   }
2260 }
2261
2262 void BScreen::hideGeometry(void) {
2263   if (geom_visible) {
2264     XUnmapWindow(getBaseDisplay().getXDisplay(), geom_window);
2265     geom_visible = False;
2266   }
2267 }
2268
2269 void BScreen::saveToolbarHide(Bool b){
2270   resource.toolbar_total_hide = b;
2271   if (toolbar != NULL){
2272     if (b)
2273       toolbar->unMapToolbar();
2274     else
2275       toolbar->mapToolbar();
2276   }
2277
2278 }