src/screen.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2
   3 #ifdef    HAVE_CONFIG_H
   4 #include "../config.h"
   5 #endif // HAVE_CONFIG_H
   6
   7 extern "C" {
   8 #include <X11/Xatom.h>
   9 #include <X11/keysym.h>
  10
  11 #ifdef    XINERAMA
  12 #  include <X11/Xlib.h>
  13 #  include <X11/extensions/Xinerama.h>
  14 #endif // XINERAMA
  15
  16 #ifdef HAVE_STDLIB_H
  17 #  include <stdlib.h>
  18 #endif // HAVE_STDLIB_H
  19
  20 #ifdef HAVE_STRING_H
  21 #  include <string.h>
  22 #endif // HAVE_STRING_H
  23
  24 #ifdef    HAVE_CTYPE_H
  25 #  include <ctype.h>
  26 #endif // HAVE_CTYPE_H
  27
  28 #ifdef    HAVE_UNISTD_H
  29 #  include <sys/types.h>
  30 #  include <unistd.h>
  31 #endif // HAVE_UNISTD_H
  32
  33 #ifdef    HAVE_DIRENT_H
  34 #  include <dirent.h>
  35 #endif // HAVE_DIRENT_H
  36
  37 #ifdef    HAVE_LOCALE_H
  38 #  include <locale.h>
  39 #endif // HAVE_LOCALE_H
  40
  41 #ifdef    HAVE_SYS_STAT_H
  42 #  include <sys/stat.h>
  43 #endif // HAVE_SYS_STAT_H
  44
  45 #ifdef    HAVE_STDARG_H
  46 #  include <stdarg.h>
  47 #endif // HAVE_STDARG_H
  48 }
  49
  50 #include <assert.h>
  51
  52 #include <algorithm>
  53 #include <functional>
  54 #include <string>
  55 using std::string;
  56
  57 #include "screen.hh"
  58 #include "otk/font.hh"
  59 #include "otk/gccache.hh"
  60 #include "otk/image.hh"
  61 #include "otk/assassin.hh"
  62 #include "openbox.hh"
  63 #include "util.hh"
  64 #include "bbwindow.hh"
  65 #include "workspace.hh"
  66 #include "util.hh"
  67
  68 #ifndef   FONT_ELEMENT_SIZE
  69 #define   FONT_ELEMENT_SIZE 50
  70 #endif // FONT_ELEMENT_SIZE
  71
  72 namespace ob {
  73
  74 static bool running = True;
  75
  76 static int anotherWMRunning(Display *display, XErrorEvent *) {
  77   fprintf(stderr,
  78           "BScreen::BScreen: an error occured while querying the X server.\n"
  79           "  another window manager already running on display %s.\n",
  80           DisplayString(display));
  81
  82   running = False;
  83
  84   return(-1);
  85 }
  86
  87
  88 BScreen::BScreen(Blackbox *bb, unsigned int scrn) : ScreenInfo(scrn) {
  89   blackbox = bb;
  90   screenstr = "session.screen" + itostring(scrn) + '.';
  91   config = blackbox->getConfig();
  92   xatom = blackbox->getXAtom();
  93
  94   event_mask = ColormapChangeMask | EnterWindowMask | PropertyChangeMask |
  95     SubstructureRedirectMask | ButtonPressMask | ButtonReleaseMask;
  96
  97   XErrorHandler old = XSetErrorHandler((XErrorHandler) anotherWMRunning);
  98   XSelectInput(otk::OBDisplay::display, getRootWindow(), event_mask);
  99   XSync(otk::OBDisplay::display, False);
 100   XSetErrorHandler((XErrorHandler) old);
 101
 102   managed = running;
 103   if (! managed) return;
 104
 105   fprintf(stderr, "BScreen::BScreen: managing screen %d "
 106           "using visual 0x%lx, depth %d\n",
 107           getScreenNumber(), XVisualIDFromVisual(getVisual()),
 108           getDepth());
 109
 110   resource.wstyle.font = (otk::BFont *) 0;
 111
 112   geom_pixmap = None;
 113
 114 //  xatom->setSupported(this);    // set-up netwm support
 115 #ifdef    HAVE_GETPID
 116   xatom->setValue(getRootWindow(), otk::OBProperty::blackbox_pid,
 117                   otk::OBProperty::Atom_Cardinal,
 118                   (unsigned long) getpid());
 119 #endif // HAVE_GETPID
 120   unsigned long geometry[] = { getWidth(),
 121                                getHeight()};
 122   xatom->set(getRootWindow(), otk::OBProperty::net_desktop_geometry,
 123              otk::OBProperty::Atom_Cardinal, geometry, 2);
 124   unsigned long viewport[] = {0,0};
 125   xatom->set(getRootWindow(), otk::OBProperty::net_desktop_viewport,
 126              otk::OBProperty::Atom_Cardinal, viewport, 2);
 127
 128
 129   XDefineCursor(otk::OBDisplay::display, getRootWindow(),
 130                 blackbox->getSessionCursor());
 131
 132   updateAvailableArea();
 133
 134   image_control =
 135     new otk::BImageControl(Openbox::instance->timerManager(),
 136                            this, True, blackbox->getColorsPerChannel(),
 137                            blackbox->getCacheLife(), blackbox->getCacheMax());
 138   image_control->installRootColormap();
 139   root_colormap_installed = True;
 140
 141   load_rc();
 142   LoadStyle();
 143
 144   XGCValues gcv;
 145   gcv.foreground = WhitePixel(otk::OBDisplay::display, getScreenNumber())
 146     ^ BlackPixel(otk::OBDisplay::display, getScreenNumber());
 147   gcv.function = GXxor;
 148   gcv.subwindow_mode = IncludeInferiors;
 149   opGC = XCreateGC(otk::OBDisplay::display, getRootWindow(),
 150                    GCForeground | GCFunction | GCSubwindowMode, &gcv);
 151
 152   const char *s = "0: 0000 x 0: 0000";
 153   geom_w = resource.wstyle.font->measureString(s) + resource.bevel_width * 2;
 154   geom_h = resource.wstyle.font->height() + resource.bevel_width * 2;
 155
 156   XSetWindowAttributes attrib;
 157   unsigned long mask = CWBorderPixel | CWColormap | CWSaveUnder;
 158   attrib.border_pixel = getBorderColor()->pixel();
 159   attrib.colormap = getColormap();
 160   attrib.save_under = True;
 161
 162   geom_window = XCreateWindow(otk::OBDisplay::display, getRootWindow(),
 163                               0, 0, geom_w, geom_h, resource.border_width,
 164                               getDepth(), InputOutput, getVisual(),
 165                               mask, &attrib);
 166   geom_visible = False;
 167
 168   otk::BTexture* texture = &(resource.wstyle.l_focus);
 169   geom_pixmap = texture->render(geom_w, geom_h, geom_pixmap);
 170   if (geom_pixmap == ParentRelative) {
 171     texture = &(resource.wstyle.t_focus);
 172     geom_pixmap = texture->render(geom_w, geom_h, geom_pixmap);
 173   }
 174   if (! geom_pixmap)
 175     XSetWindowBackground(otk::OBDisplay::display, geom_window,
 176                          texture->color().pixel());
 177   else
 178     XSetWindowBackgroundPixmap(otk::OBDisplay::display,
 179                                geom_window, geom_pixmap);
 180
 181   if (resource.workspaces > 0) {
 182     for (unsigned int i = 0; i < resource.workspaces; ++i) {
 183       Workspace *wkspc = new Workspace(this, workspacesList.size());
 184       workspacesList.push_back(wkspc);
 185
 186     }
 187   } else {
 188     Workspace *wkspc = new Workspace(this, workspacesList.size());
 189     workspacesList.push_back(wkspc);
 190   }
 191   saveWorkspaceNames();
 192
 193   updateNetizenWorkspaceCount();
 194
 195   current_workspace = workspacesList.front();
 196
 197   xatom->set(getRootWindow(), otk::OBProperty::net_current_desktop,
 198              otk::OBProperty::Atom_Cardinal, 0); //first workspace
 199
 200   raiseWindows(0, 0);     // this also initializes the empty stacking list
 201
 202   updateClientList();     // initialize the client lists, which will be empty
 203   updateAvailableArea();
 204
 205   changeWorkspaceID(0);
 206
 207   unsigned int i, j, nchild;
 208   Window r, p, *children;
 209   XQueryTree(otk::OBDisplay::display, getRootWindow(), &r, &p,
 210              &children, &nchild);
 211
 212   // preen the window list of all icon windows... for better dockapp support
 213   for (i = 0; i < nchild; i++) {
 214     if (children[i] == None) continue;
 215
 216     XWMHints *wmhints = XGetWMHints(otk::OBDisplay::display,
 217                                     children[i]);
 218
 219     if (wmhints) {
 220       if ((wmhints->flags & IconWindowHint) &&
 221           (wmhints->icon_window != children[i])) {
 222         for (j = 0; j < nchild; j++) {
 223           if (children[j] == wmhints->icon_window) {
 224             children[j] = None;
 225             break;
 226           }
 227         }
 228       }
 229
 230       XFree(wmhints);
 231     }
 232   }
 233
 234   // manage shown windows
 235   for (i = 0; i < nchild; ++i) {
 236     if (children[i] == None || ! blackbox->validateWindow(children[i]))
 237       continue;
 238
 239     XWindowAttributes attrib;
 240     if (XGetWindowAttributes(otk::OBDisplay::display, children[i], &attrib)) {
 241       if (attrib.override_redirect) continue;
 242
 243       if (attrib.map_state != IsUnmapped) {
 244         manageWindow(children[i]);
 245       }
 246     }
 247   }
 248
 249   XFree(children);
 250
 251   // call this again just in case a window we found updates the Strut list
 252   updateAvailableArea();
 253 }
 254
 255
 256 BScreen::~BScreen(void) {
 257   if (! managed) return;
 258
 259   if (geom_pixmap != None)
 260     image_control->removeImage(geom_pixmap);
 261
 262   if (geom_window != None)
 263     XDestroyWindow(otk::OBDisplay::display, geom_window);
 264
 265   std::for_each(workspacesList.begin(), workspacesList.end(),
 266                 otk::PointerAssassin());
 267
 268   std::for_each(iconList.begin(), iconList.end(), otk::PointerAssassin());
 269
 270   while (! systrayWindowList.empty())
 271     removeSystrayWindow(systrayWindowList[0]);
 272
 273   delete image_control;
 274
 275   if (resource.wstyle.font)
 276     delete resource.wstyle.font;
 277
 278   if (resource.wstyle.close_button.mask != None)
 279     XFreePixmap(otk::OBDisplay::display, resource.wstyle.close_button.mask);
 280   if (resource.wstyle.max_button.mask != None)
 281     XFreePixmap(otk::OBDisplay::display, resource.wstyle.max_button.mask);
 282   if (resource.wstyle.icon_button.mask != None)
 283     XFreePixmap(otk::OBDisplay::display, resource.wstyle.icon_button.mask);
 284   if (resource.wstyle.stick_button.mask != None)
 285     XFreePixmap(otk::OBDisplay::display, resource.wstyle.stick_button.mask);
 286
 287   resource.wstyle.max_button.mask = resource.wstyle.close_button.mask =
 288     resource.wstyle.icon_button.mask =
 289     resource.wstyle.stick_button.mask = None;
 290
 291   XFreeGC(otk::OBDisplay::display, opGC);
 292 }
 293
 294
 295 void BScreen::saveSloppyFocus(bool s) {
 296   resource.sloppy_focus = s;
 297
 298   string fmodel;
 299   if (resource.sloppy_focus) {
 300     fmodel = "SloppyFocus";
 301     if (resource.auto_raise) fmodel += " AutoRaise";
 302     if (resource.click_raise) fmodel += " ClickRaise";
 303   } else {
 304     fmodel = "ClickToFocus";
 305   }
 306   config->setValue(screenstr + "focusModel", fmodel);
 307 }
 308
 309
 310 void BScreen::saveAutoRaise(bool a) {
 311   resource.auto_raise = a;
 312   saveSloppyFocus(resource.sloppy_focus);
 313 }
 314
 315
 316 void BScreen::saveClickRaise(bool c) {
 317   resource.click_raise = c;
 318   saveSloppyFocus(resource.sloppy_focus);
 319 }
 320
 321
 322 void BScreen::saveImageDither(bool d) {
 323   image_control->setDither(d);
 324   config->setValue(screenstr + "imageDither", doImageDither());
 325 }
 326
 327
 328 void BScreen::saveOpaqueMove(bool o) {
 329   resource.opaque_move = o;
 330   config->setValue(screenstr + "opaqueMove", resource.opaque_move);
 331 }
 332
 333
 334 void BScreen::saveFullMax(bool f) {
 335   resource.full_max = f;
 336   config->setValue(screenstr + "fullMaximization", resource.full_max);
 337 }
 338
 339
 340 void BScreen::saveFocusNew(bool f) {
 341   resource.focus_new = f;
 342   config->setValue(screenstr + "focusNewWindows", resource.focus_new);
 343 }
 344
 345
 346 void BScreen::saveFocusLast(bool f) {
 347   resource.focus_last = f;
 348   config->setValue(screenstr + "focusLastWindow", resource.focus_last);
 349 }
 350
 351
 352 void BScreen::saveAAFonts(bool f) {
 353   resource.aa_fonts = f;
 354   config->setValue(screenstr + "antialiasFonts", resource.aa_fonts);
 355   reconfigure();
 356 }
 357
 358
 359 void BScreen::saveShadowFonts(bool f) {
 360   resource.shadow_fonts = f;
 361   config->setValue(screenstr + "dropShadowFonts", resource.shadow_fonts);
 362   reconfigure();
 363 }
 364
 365
 366 void BScreen::saveWindowToEdgeSnap(int s) {
 367   resource.snap_to_edges = s;
 368
 369   const char *snap;
 370   switch (resource.snap_to_edges) {
 371   case WindowNoSnap: snap = "NoSnap"; break;
 372   case WindowResistance: snap = "Resistance"; break;
 373   case WindowSnap: default: snap = "Snap"; break;
 374   }
 375   config->setValue(screenstr + "windowToEdgeSnap", snap);
 376 }
 377
 378
 379 void BScreen::saveWindowToWindowSnap(int s) {
 380   resource.snap_to_windows = s;
 381
 382   const char *snap;
 383   switch (resource.snap_to_windows) {
 384   case WindowNoSnap: snap = "NoSnap"; break;
 385   case WindowResistance: snap = "Resistance"; break;
 386   case WindowSnap: default: snap = "Snap"; break;
 387   }
 388   config->setValue(screenstr + "windowToWindowSnap", snap);
 389 }
 390
 391
 392 void BScreen::saveResizeZones(unsigned int z) {
 393   resource.resize_zones = z;
 394   config->setValue(screenstr + "resizeZones", resource.resize_zones);
 395 }
 396
 397
 398 void BScreen::saveWindowCornerSnap(bool s) {
 399   resource.window_corner_snap = s;
 400   config->setValue(screenstr + "windowCornerSnap",
 401                    resource.window_corner_snap);
 402 }
 403
 404
 405 void BScreen::saveWorkspaces(unsigned int w) {
 406   resource.workspaces = w;
 407   config->setValue(screenstr + "workspaces", resource.workspaces);
 408 }
 409
 410
 411 void BScreen::savePlacementPolicy(int p) {
 412   resource.placement_policy = p;
 413   const char *placement;
 414   switch (resource.placement_policy) {
 415   case CascadePlacement: placement = "CascadePlacement"; break;
 416   case UnderMousePlacement: placement = "UnderMousePlacement"; break;
 417   case ClickMousePlacement: placement = "ClickMousePlacement"; break;
 418   case ColSmartPlacement: placement = "ColSmartPlacement"; break;
 419   case RowSmartPlacement: default: placement = "RowSmartPlacement"; break;
 420   }
 421   config->setValue(screenstr + "windowPlacement", placement);
 422 }
 423
 424
 425 void BScreen::saveResistanceSize(int s) {
 426   resource.resistance_size = s;
 427   config->setValue(screenstr + "resistanceSize",
 428                    resource.resistance_size);
 429 }
 430
 431
 432 void BScreen::saveSnapThreshold(int t) {
 433   resource.snap_threshold = t;
 434   config->setValue(screenstr + "edgeSnapThreshold",
 435                    resource.snap_threshold);
 436 }
 437
 438
 439 void BScreen::saveSnapOffset(int t) {
 440   resource.snap_offset = t;
 441   config->setValue(screenstr + "edgeSnapOffset",
 442                    resource.snap_offset);
 443 }
 444
 445
 446 void BScreen::saveRowPlacementDirection(int d) {
 447   resource.row_direction = d;
 448   config->setValue(screenstr + "rowPlacementDirection",
 449                    resource.row_direction == LeftRight ?
 450                    "LeftToRight" : "RightToLeft");
 451 }
 452
 453
 454 void BScreen::saveColPlacementDirection(int d) {
 455   resource.col_direction = d;
 456   config->setValue(screenstr + "colPlacementDirection",
 457                    resource.col_direction == TopBottom ?
 458                    "TopToBottom" : "BottomToTop");
 459 }
 460
 461
 462 void BScreen::saveStrftimeFormat(const std::string& format) {
 463   resource.strftime_format = format;
 464   config->setValue(screenstr + "strftimeFormat", resource.strftime_format);
 465 }
 466
 467
 468 void BScreen::saveWorkspaceNames() {
 469   string names;
 470
 471   for (unsigned int i = 0; i < workspacesList.size(); ++i) {
 472     names += workspacesList[i]->getName();
 473     if (i < workspacesList.size() - 1)
 474       names += ',';
 475   }
 476
 477   config->setValue(screenstr + "workspaceNames", names);
 478 }
 479
 480
 481 void BScreen::savePlaceIgnoreShaded(bool i) {
 482   resource.ignore_shaded = i;
 483   config->setValue(screenstr + "placementIgnoreShaded",
 484                    resource.ignore_shaded);
 485 }
 486
 487
 488 void BScreen::savePlaceIgnoreMaximized(bool i) {
 489   resource.ignore_maximized = i;
 490   config->setValue(screenstr + "placementIgnoreMaximized",
 491                    resource.ignore_maximized);
 492 }
 493
 494
 495 void BScreen::saveAllowScrollLock(bool a) {
 496   resource.allow_scroll_lock = a;
 497   config->setValue(screenstr + "disableBindingsWithScrollLock",
 498                    resource.allow_scroll_lock);
 499 }
 500
 501
 502 void BScreen::saveWorkspaceWarping(bool w) {
 503   resource.workspace_warping = w;
 504   config->setValue(screenstr + "workspaceWarping",
 505                    resource.workspace_warping);
 506 }
 507
 508
 509 void BScreen::saveRootScrollDirection(int d) {
 510   resource.root_scroll = d;
 511   const char *dir;
 512   switch (resource.root_scroll) {
 513   case NoScroll: dir = "None"; break;
 514   case ReverseScroll: dir = "Reverse"; break;
 515   case NormalScroll: default: dir = "Normal"; break;
 516   }
 517   config->setValue(screenstr + "rootScrollDirection", dir);
 518 }
 519
 520
 521 void BScreen::save_rc(void) {
 522   saveSloppyFocus(resource.sloppy_focus);
 523   saveAutoRaise(resource.auto_raise);
 524   saveImageDither(doImageDither());
 525   saveShadowFonts(resource.shadow_fonts);
 526   saveAAFonts(resource.aa_fonts);
 527   saveResizeZones(resource.resize_zones);
 528   saveOpaqueMove(resource.opaque_move);
 529   saveFullMax(resource.full_max);
 530   saveFocusNew(resource.focus_new);
 531   saveFocusLast(resource.focus_last);
 532   saveWindowToWindowSnap(resource.snap_to_windows);
 533   saveWindowToEdgeSnap(resource.snap_to_edges);
 534   saveWindowCornerSnap(resource.window_corner_snap);
 535   saveWorkspaces(resource.workspaces);
 536   savePlacementPolicy(resource.placement_policy);
 537   saveSnapThreshold(resource.snap_threshold);
 538   saveSnapOffset(resource.snap_offset);
 539   saveResistanceSize(resource.resistance_size);
 540   saveRowPlacementDirection(resource.row_direction);
 541   saveColPlacementDirection(resource.col_direction);
 542   saveStrftimeFormat(resource.strftime_format);
 543   savePlaceIgnoreShaded(resource.ignore_shaded);
 544   savePlaceIgnoreMaximized(resource.ignore_maximized);
 545   saveAllowScrollLock(resource.allow_scroll_lock);
 546   saveWorkspaceWarping(resource.workspace_warping);
 547   saveRootScrollDirection(resource.root_scroll);
 548 }
 549
 550
 551 void BScreen::load_rc(void) {
 552   std::string s;
 553   bool b;
 554
 555   if (! config->getValue(screenstr + "fullMaximization", resource.full_max))
 556     resource.full_max = false;
 557
 558   if (! config->getValue(screenstr + "focusNewWindows", resource.focus_new))
 559     resource.focus_new = false;
 560
 561   if (! config->getValue(screenstr + "focusLastWindow", resource.focus_last))
 562     resource.focus_last = false;
 563
 564   if (! config->getValue(screenstr + "workspaces", resource.workspaces))
 565     resource.workspaces = 1;
 566
 567   if (! config->getValue(screenstr + "opaqueMove", resource.opaque_move))
 568     resource.opaque_move = false;
 569
 570   if (! config->getValue(screenstr + "antialiasFonts", resource.aa_fonts))
 571     resource.aa_fonts = true;
 572
 573   if (! resource.aa_fonts ||
 574       ! config->getValue(screenstr + "dropShadowFonts", resource.shadow_fonts))
 575     resource.shadow_fonts = false;
 576
 577   if (! config->getValue(screenstr + "resizeZones", resource.resize_zones) ||
 578       (resource.resize_zones != 1 && resource.resize_zones != 2 &&
 579        resource.resize_zones != 4))
 580       resource.resize_zones = 4;
 581
 582   resource.snap_to_windows = WindowResistance;
 583   if (config->getValue(screenstr + "windowToWindowSnap", s)) {
 584     if (s == "NoSnap")
 585       resource.snap_to_windows = WindowNoSnap;
 586     else if (s == "Snap")
 587       resource.snap_to_windows = WindowSnap;
 588   }
 589
 590   resource.snap_to_edges = WindowResistance;
 591   if (config->getValue(screenstr + "windowToEdgeSnap", s)) {
 592     if (s == "NoSnap")
 593       resource.snap_to_edges = WindowNoSnap;
 594     else if (s == "Snap")
 595       resource.snap_to_edges = WindowSnap;
 596   }
 597
 598   if (! config->getValue(screenstr + "windowCornerSnap",
 599                          resource.window_corner_snap))
 600     resource.window_corner_snap = true;
 601
 602   if (! config->getValue(screenstr + "imageDither", b))
 603     b = true;
 604   image_control->setDither(b);
 605
 606   if (! config->getValue(screenstr + "edgeSnapOffset",
 607                         resource.snap_offset))
 608     resource.snap_offset = 0;
 609   if (resource.snap_offset > 50)  // sanity check, setting this huge would
 610     resource.snap_offset = 50;    // seriously suck.
 611
 612   if (! config->getValue(screenstr + "edgeSnapThreshold",
 613                         resource.snap_threshold))
 614     resource.snap_threshold = 4;
 615
 616   if (! config->getValue(screenstr + "resistanceSize",
 617                         resource.resistance_size))
 618     resource.resistance_size = 18;
 619
 620   if (config->getValue(screenstr + "rowPlacementDirection", s) &&
 621       s == "RightToLeft")
 622     resource.row_direction = RightLeft;
 623   else
 624     resource.row_direction = LeftRight;
 625
 626   if (config->getValue(screenstr + "colPlacementDirection", s) &&
 627       s == "BottomToTop")
 628     resource.col_direction = BottomTop;
 629   else
 630     resource.col_direction = TopBottom;
 631
 632   if (config->getValue(screenstr + "workspaceNames", s)) {
 633     otk::OBProperty::StringVect workspaceNames;
 634
 635     string::const_iterator it = s.begin(), end = s.end();
 636     while(1) {
 637       string::const_iterator tmp = it;     // current string.begin()
 638       it = std::find(tmp, end, ',');       // look for comma between tmp and end
 639       workspaceNames.push_back(string(tmp, it)); // s[tmp:it]
 640       if (it == end)
 641         break;
 642       ++it;
 643     }
 644
 645     xatom->set(getRootWindow(), otk::OBProperty::net_desktop_names,
 646                otk::OBProperty::utf8, workspaceNames);
 647   }
 648
 649   resource.sloppy_focus = true;
 650   resource.auto_raise = false;
 651   resource.click_raise = false;
 652   if (config->getValue(screenstr + "focusModel", s)) {
 653     if (s.find("ClickToFocus") != string::npos) {
 654       resource.sloppy_focus = false;
 655     } else {
 656       // must be sloppy
 657       if (s.find("AutoRaise") != string::npos)
 658         resource.auto_raise = true;
 659       if (s.find("ClickRaise") != string::npos)
 660         resource.click_raise = true;
 661     }
 662   }
 663
 664   if (config->getValue(screenstr + "windowPlacement", s)) {
 665     if (s == "CascadePlacement")
 666       resource.placement_policy = CascadePlacement;
 667     else if (s == "UnderMousePlacement")
 668       resource.placement_policy = UnderMousePlacement;
 669     else if (s == "ClickMousePlacement")
 670       resource.placement_policy = ClickMousePlacement;
 671     else if (s == "ColSmartPlacement")
 672       resource.placement_policy = ColSmartPlacement;
 673     else //if (s == "RowSmartPlacement")
 674       resource.placement_policy = RowSmartPlacement;
 675   } else
 676     resource.placement_policy = RowSmartPlacement;
 677
 678   if (! config->getValue(screenstr + "strftimeFormat",
 679                          resource.strftime_format))
 680     resource.strftime_format = "%I:%M %p";
 681
 682   if (! config->getValue(screenstr + "placementIgnoreShaded",
 683                          resource.ignore_shaded))
 684     resource.ignore_shaded = true;
 685
 686   if (! config->getValue(screenstr + "placementIgnoreMaximized",
 687                          resource.ignore_maximized))
 688     resource.ignore_maximized = true;
 689
 690   if (! config->getValue(screenstr + "disableBindingsWithScrollLock",
 691                        resource.allow_scroll_lock))
 692     resource.allow_scroll_lock = false;
 693
 694   if (! config->getValue(screenstr + "workspaceWarping",
 695                          resource.workspace_warping))
 696     resource.workspace_warping = false;
 697
 698   resource.root_scroll = NormalScroll;
 699   if (config->getValue(screenstr + "rootScrollDirection", s)) {
 700     if (s == "None")
 701       resource.root_scroll = NoScroll;
 702     else if (s == "Reverse")
 703       resource.root_scroll = ReverseScroll;
 704   }
 705 }
 706
 707
 708 void BScreen::changeWorkspaceCount(unsigned int new_count) {
 709   assert(new_count > 0);
 710
 711   if (new_count < workspacesList.size()) {
 712     // shrink
 713     for (unsigned int i = workspacesList.size(); i > new_count; --i)
 714       removeLastWorkspace();
 715     // removeLast already sets the current workspace to the
 716     // last available one.
 717   } else if (new_count > workspacesList.size()) {
 718     // grow
 719     for(unsigned int i = workspacesList.size(); i < new_count; ++i)
 720       addWorkspace();
 721   }
 722 }
 723
 724
 725 void BScreen::reconfigure(void) {
 726   // don't reconfigure while saving the initial rc file, it's a waste and it
 727   // breaks somethings (workspace names)
 728   if (blackbox->state() == Openbox::State_Starting) return;
 729
 730   load_rc();
 731   LoadStyle();
 732
 733   // we need to do this explicitly, because just loading this value from the rc
 734   // does nothing
 735   changeWorkspaceCount(resource.workspaces);
 736
 737   XGCValues gcv;
 738   gcv.foreground = WhitePixel(otk::OBDisplay::display,
 739                               getScreenNumber());
 740   gcv.function = GXinvert;
 741   gcv.subwindow_mode = IncludeInferiors;
 742   XChangeGC(otk::OBDisplay::display, opGC,
 743             GCForeground | GCFunction | GCSubwindowMode, &gcv);
 744
 745   const char *s = "0: 0000 x 0: 0000";
 746
 747   geom_w = resource.wstyle.font->measureString(s) + resource.bevel_width * 2;
 748   geom_h = resource.wstyle.font->height() + resource.bevel_width * 2;
 749
 750   otk::BTexture* texture = &(resource.wstyle.l_focus);
 751   geom_pixmap = texture->render(geom_w, geom_h, geom_pixmap);
 752   if (geom_pixmap == ParentRelative) {
 753     texture = &(resource.wstyle.t_focus);
 754     geom_pixmap = texture->render(geom_w, geom_h, geom_pixmap);
 755   }
 756   if (! geom_pixmap)
 757     XSetWindowBackground(otk::OBDisplay::display, geom_window,
 758                          texture->color().pixel());
 759   else
 760     XSetWindowBackgroundPixmap(otk::OBDisplay::display,
 761                                geom_window, geom_pixmap);
 762
 763   XSetWindowBorderWidth(otk::OBDisplay::display, geom_window,
 764                         resource.border_width);
 765   XSetWindowBorder(otk::OBDisplay::display, geom_window,
 766                    resource.border_color.pixel());
 767
 768   typedef std::vector<int> SubList;
 769   SubList remember_subs;
 770
 771   raiseWindows(0, 0);
 772
 773   std::for_each(workspacesList.begin(), workspacesList.end(),
 774                 std::mem_fun(&Workspace::reconfigure));
 775
 776   BlackboxWindowList::iterator iit = iconList.begin();
 777   for (; iit != iconList.end(); ++iit) {
 778     BlackboxWindow *bw = *iit;
 779     if (bw->validateClient())
 780       bw->reconfigure();
 781   }
 782
 783   otk::BImageControl::timeout(image_control);
 784 }
 785
 786
 787 void BScreen::LoadStyle(void) {
 788   Configuration style(False);
 789
 790   const char *sfile = blackbox->getStyleFilename();
 791   if (sfile != NULL) {
 792     style.setFile(sfile);
 793     if (! style.load()) {
 794       style.setFile(DEFAULTSTYLE);
 795       if (! style.load())
 796         style.create();  // hardcoded default values will be used.
 797     }
 798   }
 799
 800   // merge in the rc file
 801   style.merge(config->file(), True);
 802
 803   string s;
 804
 805   // load fonts/fontsets
 806   if (resource.wstyle.font)
 807     delete resource.wstyle.font;
 808
 809   resource.wstyle.font = readDatabaseFont("window.", style);
 810
 811   // load window config
 812   resource.wstyle.t_focus =
 813     readDatabaseTexture("window.title.focus", "white", style);
 814   resource.wstyle.t_unfocus =
 815     readDatabaseTexture("window.title.unfocus", "black", style);
 816   resource.wstyle.l_focus =
 817     readDatabaseTexture("window.label.focus", "white", style);
 818   resource.wstyle.l_unfocus =
 819     readDatabaseTexture("window.label.unfocus", "black", style);
 820   resource.wstyle.h_focus =
 821     readDatabaseTexture("window.handle.focus", "white", style);
 822   resource.wstyle.h_unfocus =
 823     readDatabaseTexture("window.handle.unfocus", "black", style);
 824   resource.wstyle.g_focus =
 825     readDatabaseTexture("window.grip.focus", "white", style);
 826   resource.wstyle.g_unfocus =
 827     readDatabaseTexture("window.grip.unfocus", "black", style);
 828   resource.wstyle.b_focus =
 829     readDatabaseTexture("window.button.focus", "white", style);
 830   resource.wstyle.b_unfocus =
 831     readDatabaseTexture("window.button.unfocus", "black", style);
 832   resource.wstyle.b_pressed =
 833     readDatabaseTexture("window.button.pressed", "black", style);
 834
 835   //if neither of these can be found, we will use the previous resource
 836   resource.wstyle.b_pressed_focus =
 837     readDatabaseTexture("window.button.pressed.focus", "black", style, true);
 838   resource.wstyle.b_pressed_unfocus =
 839     readDatabaseTexture("window.button.pressed.unfocus", "black", style, true);
 840
 841   if (resource.wstyle.close_button.mask != None)
 842     XFreePixmap(otk::OBDisplay::display, resource.wstyle.close_button.mask);
 843   if (resource.wstyle.max_button.mask != None)
 844     XFreePixmap(otk::OBDisplay::display, resource.wstyle.max_button.mask);
 845   if (resource.wstyle.icon_button.mask != None)
 846     XFreePixmap(otk::OBDisplay::display, resource.wstyle.icon_button.mask);
 847   if (resource.wstyle.stick_button.mask != None)
 848     XFreePixmap(otk::OBDisplay::display, resource.wstyle.stick_button.mask);
 849
 850   resource.wstyle.close_button.mask = resource.wstyle.max_button.mask =
 851     resource.wstyle.icon_button.mask =
 852     resource.wstyle.icon_button.mask = None;
 853
 854   readDatabaseMask("window.button.close.mask", resource.wstyle.close_button,
 855                    style);
 856   readDatabaseMask("window.button.max.mask", resource.wstyle.max_button,
 857                    style);
 858   readDatabaseMask("window.button.icon.mask", resource.wstyle.icon_button,
 859                    style);
 860   readDatabaseMask("window.button.stick.mask", resource.wstyle.stick_button,
 861                    style);
 862
 863   // we create the window.frame texture by hand because it exists only to
 864   // make the code cleaner and is not actually used for display
 865   otk::BColor color = readDatabaseColor("window.frame.focusColor", "white",
 866                                         style);
 867   resource.wstyle.f_focus = otk::BTexture("solid flat", getScreenNumber(),
 868                                           image_control);
 869   resource.wstyle.f_focus.setColor(color);
 870
 871   color = readDatabaseColor("window.frame.unfocusColor", "white", style);
 872   resource.wstyle.f_unfocus = otk::BTexture("solid flat", getScreenNumber(),
 873                                             image_control);
 874   resource.wstyle.f_unfocus.setColor(color);
 875
 876   resource.wstyle.l_text_focus =
 877     readDatabaseColor("window.label.focus.textColor", "black", style);
 878   resource.wstyle.l_text_unfocus =
 879     readDatabaseColor("window.label.unfocus.textColor", "white", style);
 880   resource.wstyle.b_pic_focus =
 881     readDatabaseColor("window.button.focus.picColor", "black", style);
 882   resource.wstyle.b_pic_unfocus =
 883     readDatabaseColor("window.button.unfocus.picColor", "white", style);
 884
 885   resource.wstyle.justify = LeftJustify;
 886   if (style.getValue("window.justify", s)) {
 887     if (s == "right" || s == "Right")
 888       resource.wstyle.justify = RightJustify;
 889     else if (s == "center" || s == "Center")
 890       resource.wstyle.justify = CenterJustify;
 891   }
 892
 893   // sanity checks
 894   if (resource.wstyle.t_focus.texture() == otk::BTexture::Parent_Relative)
 895     resource.wstyle.t_focus = resource.wstyle.f_focus;
 896   if (resource.wstyle.t_unfocus.texture() == otk::BTexture::Parent_Relative)
 897     resource.wstyle.t_unfocus = resource.wstyle.f_unfocus;
 898   if (resource.wstyle.h_focus.texture() == otk::BTexture::Parent_Relative)
 899     resource.wstyle.h_focus = resource.wstyle.f_focus;
 900   if (resource.wstyle.h_unfocus.texture() == otk::BTexture::Parent_Relative)
 901     resource.wstyle.h_unfocus = resource.wstyle.f_unfocus;
 902
 903   resource.border_color =
 904     readDatabaseColor("borderColor", "black", style);
 905
 906   // load bevel, border and handle widths
 907   if (! style.getValue("handleWidth", resource.handle_width) ||
 908       resource.handle_width > (getWidth() / 2) || resource.handle_width == 0)
 909     resource.handle_width = 6;
 910
 911   if (! style.getValue("borderWidth", resource.border_width))
 912     resource.border_width = 1;
 913
 914   if (! style.getValue("bevelWidth", resource.bevel_width) ||
 915       resource.bevel_width > (getWidth() / 2) || resource.bevel_width == 0)
 916     resource.bevel_width = 3;
 917
 918   if (! style.getValue("frameWidth", resource.frame_width) ||
 919       resource.frame_width > (getWidth() / 2))
 920     resource.frame_width = resource.bevel_width;
 921
 922   if (style.getValue("rootCommand", s))
 923     bexec(s, displayString());
 924 }
 925
 926
 927 void BScreen::addIcon(BlackboxWindow *w) {
 928   if (! w) return;
 929
 930   w->setWorkspace(BSENTINEL);
 931   w->setWindowNumber(iconList.size());
 932
 933   iconList.push_back(w);
 934 }
 935
 936
 937 void BScreen::removeIcon(BlackboxWindow *w) {
 938   if (! w) return;
 939
 940   iconList.remove(w);
 941
 942   BlackboxWindowList::iterator it = iconList.begin(),
 943     end = iconList.end();
 944   for (int i = 0; it != end; ++it)
 945     (*it)->setWindowNumber(i++);
 946 }
 947
 948
 949 BlackboxWindow *BScreen::getIcon(unsigned int index) {
 950   if (index < iconList.size()) {
 951     BlackboxWindowList::iterator it = iconList.begin();
 952     while (index-- > 0) // increment to index
 953       ++it;
 954     return *it;
 955   }
 956
 957   return (BlackboxWindow *) 0;
 958 }
 959
 960
 961 unsigned int BScreen::addWorkspace(void) {
 962   Workspace *wkspc = new Workspace(this, workspacesList.size());
 963   workspacesList.push_back(wkspc);
 964   saveWorkspaces(getWorkspaceCount());
 965   saveWorkspaceNames();
 966
 967   return workspacesList.size();
 968 }
 969
 970
 971 unsigned int BScreen::removeLastWorkspace(void) {
 972   if (workspacesList.size() == 1)
 973     return 1;
 974
 975   Workspace *wkspc = workspacesList.back();
 976
 977   if (current_workspace->getID() == wkspc->getID())
 978     changeWorkspaceID(current_workspace->getID() - 1);
 979
 980   wkspc->removeAll();
 981
 982   workspacesList.pop_back();
 983   delete wkspc;
 984
 985   saveWorkspaces(getWorkspaceCount());
 986   saveWorkspaceNames();
 987
 988   updateNetizenWorkspaceCount();
 989
 990   return workspacesList.size();
 991 }
 992
 993
 994 void BScreen::changeWorkspaceID(unsigned int id) {
 995   if (! current_workspace || id == current_workspace->getID()) return;
 996
 997   BlackboxWindow *focused = blackbox->getFocusedWindow();
 998   if (focused && focused->getScreen() == this) {
 999     assert(focused->isStuck() ||
1000            focused->getWorkspaceNumber() == current_workspace->getID());
1001
1002     current_workspace->setLastFocusedWindow(focused);
1003   } else {
1004     // if no window had focus, no need to store a last focus
1005     current_workspace->setLastFocusedWindow((BlackboxWindow *) 0);
1006   }
1007
1008   // when we switch workspaces, unfocus whatever was focused if it is going
1009   // to be unmapped
1010   if (focused && ! focused->isStuck())
1011     blackbox->setFocusedWindow((BlackboxWindow *) 0);
1012
1013   current_workspace->hideAll();
1014
1015   current_workspace = getWorkspace(id);
1016
1017   xatom->set(getRootWindow(), otk::OBProperty::net_current_desktop,
1018              otk::OBProperty::Atom_Cardinal, id);
1019
1020   current_workspace->showAll();
1021
1022   int x, y, rx, ry;
1023   Window c, r;
1024   unsigned int m;
1025   BlackboxWindow *win = (BlackboxWindow *) 0;
1026   bool f = False;
1027
1028   XSync(otk::OBDisplay::display, False);
1029
1030   // If sloppy focus and we can find the client window under the pointer,
1031   // try to focus it.
1032   if (resource.sloppy_focus &&
1033       XQueryPointer(otk::OBDisplay::display, getRootWindow(), &r, &c,
1034                     &rx, &ry, &x, &y, &m) &&
1035       c != None) {
1036     if ( (win = blackbox->searchWindow(c)) )
1037       f = win->setInputFocus();
1038   }
1039
1040   // If that fails, and we're doing focus_last, try to focus the last window.
1041   if (! f && resource.focus_last &&
1042       (win = current_workspace->getLastFocusedWindow()))
1043     f = win->setInputFocus();
1044
1045   /*
1046     if we found a focus target, then we set the focused window explicitly
1047     because it is possible to switch off this workspace before the x server
1048     generates the FocusIn event for the window. if that happens, openbox would
1049     lose track of what window was the 'LastFocused' window on the workspace.
1050
1051     if we did not find a focus target, then set the current focused window to
1052     nothing.
1053   */
1054   if (f)
1055     blackbox->setFocusedWindow(win);
1056   else
1057     blackbox->setFocusedWindow((BlackboxWindow *) 0);
1058 }
1059
1060
1061 /*
1062  * Set the _NET_CLIENT_LIST root window property.
1063  */
1064 void BScreen::updateClientList(void) {
1065   if (windowList.size() > 0) {
1066     Window *windows = new Window[windowList.size()];
1067     Window *win_it = windows;
1068     BlackboxWindowList::iterator it = windowList.begin();
1069     const BlackboxWindowList::iterator end = windowList.end();
1070     for (; it != end; ++it, ++win_it)
1071       *win_it = (*it)->getClientWindow();
1072     xatom->set(getRootWindow(), otk::OBProperty::net_client_list,
1073                otk::OBProperty::Atom_Window, windows, windowList.size());
1074     delete [] windows;
1075   } else
1076     xatom->set(getRootWindow(), otk::OBProperty::net_client_list,
1077                otk::OBProperty::Atom_Window, 0, 0);
1078
1079   updateStackingList();
1080 }
1081
1082
1083 /*
1084  * Set the _NET_CLIENT_LIST_STACKING root window property.
1085  */
1086 void BScreen::updateStackingList(void) {
1087
1088   BlackboxWindowList stack_order;
1089
1090   /*
1091    * Get the stacking order from all of the workspaces.
1092    * We start with the current workspace so that the sticky windows will be
1093    * in the right order on the current workspace.
1094    * XXX: Do we need to have sticky windows in the list once for each workspace?
1095    */
1096   getCurrentWorkspace()->appendStackOrder(stack_order);
1097   for (unsigned int i = 0; i < getWorkspaceCount(); ++i)
1098     if (i != getCurrentWorkspaceID())
1099       getWorkspace(i)->appendStackOrder(stack_order);
1100
1101   if (stack_order.size() > 0) {
1102     // set the client list atoms
1103     Window *windows = new Window[stack_order.size()];
1104     Window *win_it = windows;
1105     BlackboxWindowList::iterator it = stack_order.begin(),
1106                                  end = stack_order.end();
1107     for (; it != end; ++it, ++win_it)
1108       *win_it = (*it)->getClientWindow();
1109     xatom->set(getRootWindow(), otk::OBProperty::net_client_list_stacking,
1110                otk::OBProperty::Atom_Window, windows, stack_order.size());
1111     delete [] windows;
1112   } else
1113     xatom->set(getRootWindow(), otk::OBProperty::net_client_list_stacking,
1114                otk::OBProperty::Atom_Window, 0, 0);
1115 }
1116
1117
1118 void BScreen::addSystrayWindow(Window window) {
1119   XGrabServer(otk::OBDisplay::display);
1120
1121   XSelectInput(otk::OBDisplay::display, window, StructureNotifyMask);
1122   systrayWindowList.push_back(window);
1123   xatom->set(getRootWindow(), otk::OBProperty::kde_net_system_tray_windows,
1124              otk::OBProperty::Atom_Window,
1125              &systrayWindowList[0], systrayWindowList.size());
1126   blackbox->saveSystrayWindowSearch(window, this);
1127
1128   XUngrabServer(otk::OBDisplay::display);
1129 }
1130
1131
1132 void BScreen::removeSystrayWindow(Window window) {
1133   XGrabServer(otk::OBDisplay::display);
1134
1135   WindowList::iterator it = systrayWindowList.begin();
1136   const WindowList::iterator end = systrayWindowList.end();
1137   for (; it != end; ++it)
1138     if (*it == window) {
1139       systrayWindowList.erase(it);
1140       xatom->set(getRootWindow(),
1141                  otk::OBProperty::kde_net_system_tray_windows,
1142                  otk::OBProperty::Atom_Window,
1143                  &systrayWindowList[0], systrayWindowList.size());
1144       blackbox->removeSystrayWindowSearch(window);
1145       XSelectInput(otk::OBDisplay::display, window, NoEventMask);
1146       break;
1147     }
1148
1149   assert(it != end);    // not a systray window
1150
1151   XUngrabServer(otk::OBDisplay::display);
1152 }
1153
1154
1155 void BScreen::manageWindow(Window w) {
1156   // is the window a KDE systray window?
1157   Window systray;
1158   if (xatom->get(w, otk::OBProperty::kde_net_wm_system_tray_window_for,
1159                  otk::OBProperty::Atom_Window, &systray) &&
1160       systray != None)
1161   {
1162     addSystrayWindow(w);
1163     return;
1164   }
1165
1166   // is the window a docking app
1167   XWMHints *wmhint = XGetWMHints(otk::OBDisplay::display, w);
1168   if (wmhint && (wmhint->flags & StateHint) &&
1169       wmhint->initial_state == WithdrawnState) {
1170     //slit->addClient(w);
1171     return;
1172   }
1173
1174   new BlackboxWindow(blackbox, w, this);
1175
1176   BlackboxWindow *win = blackbox->searchWindow(w);
1177   if (! win)
1178     return;
1179
1180   if (win->isDesktop()) {
1181     desktopWindowList.push_back(win->getFrameWindow());
1182   } else { // if (win->isNormal()) {
1183     // don't list desktop windows as managed windows
1184     windowList.push_back(win);
1185     updateClientList();
1186
1187     if (win->isTopmost())
1188       specialWindowList.push_back(win->getFrameWindow());
1189   }
1190
1191   XMapRequestEvent mre;
1192   mre.window = w;
1193   if (blackbox->state() == Openbox::State_Starting &&
1194       win->isNormal())
1195     win->restoreAttributes();
1196   win->mapRequestEvent(&mre);
1197 }
1198
1199
1200 void BScreen::unmanageWindow(BlackboxWindow *w, bool remap) {
1201   // is the window a KDE systray window?
1202   Window systray;
1203   if (xatom->get(w->getClientWindow(),
1204                  otk::OBProperty::kde_net_wm_system_tray_window_for,
1205                  otk::OBProperty::Atom_Window, &systray) &&
1206       systray != None)
1207   {
1208     removeSystrayWindow(w->getClientWindow());
1209     return;
1210   }
1211
1212   w->restore(remap);
1213
1214   // Remove the modality so that its parent won't try to re-focus the window
1215   if (w->isModal()) w->setModal(False);
1216
1217   if (w->getWorkspaceNumber() != BSENTINEL &&
1218       w->getWindowNumber() != BSENTINEL) {
1219     getWorkspace(w->getWorkspaceNumber())->removeWindow(w);
1220     if (w->isStuck()) {
1221       for (unsigned int i = 0; i < getNumberOfWorkspaces(); ++i)
1222         if (i != w->getWorkspaceNumber())
1223           getWorkspace(i)->removeWindow(w, True);
1224     }
1225   } else if (w->isIconic())
1226     removeIcon(w);
1227
1228   if (w->isDesktop()) {
1229     WindowList::iterator it = desktopWindowList.begin();
1230     const WindowList::iterator end = desktopWindowList.end();
1231     for (; it != end; ++it)
1232       if (*it == w->getFrameWindow()) {
1233         desktopWindowList.erase(it);
1234         break;
1235       }
1236     assert(it != end);  // the window wasnt a desktop window?
1237   } else { // if (w->isNormal()) {
1238     // we don't list desktop windows as managed windows
1239     windowList.remove(w);
1240     updateClientList();
1241
1242     if (w->isTopmost()) {
1243       WindowList::iterator it = specialWindowList.begin();
1244       const WindowList::iterator end = specialWindowList.end();
1245       for (; it != end; ++it)
1246         if (*it == w->getFrameWindow()) {
1247           specialWindowList.erase(it);
1248           break;
1249         }
1250       assert(it != end);  // the window wasnt a special window?
1251     }
1252   }
1253
1254   if (blackbox->getFocusedWindow() == w)
1255     blackbox->setFocusedWindow((BlackboxWindow *) 0);
1256
1257   /*
1258     some managed windows can also be window group controllers.  when
1259     unmanaging such windows, we should also delete the window group.
1260   */
1261   BWindowGroup *group = blackbox->searchGroup(w->getClientWindow());
1262   delete group;
1263
1264   delete w;
1265 }
1266
1267
1268 void BScreen::updateWorkArea(void) {
1269   if (workspacesList.size() > 0) {
1270     unsigned long *dims = new unsigned long[4 * workspacesList.size()];
1271     for (unsigned int i = 0, m = workspacesList.size(); i < m; ++i) {
1272       // XXX: this could be different for each workspace
1273       const otk::Rect &area = availableArea();
1274       dims[(i * 4) + 0] = area.x();
1275       dims[(i * 4) + 1] = area.y();
1276       dims[(i * 4) + 2] = area.width();
1277       dims[(i * 4) + 3] = area.height();
1278     }
1279     xatom->set(getRootWindow(), otk::OBProperty::net_workarea,
1280                otk::OBProperty::Atom_Cardinal,
1281                dims, 4 * workspacesList.size());
1282     delete [] dims;
1283   } else
1284     xatom->set(getRootWindow(), otk::OBProperty::net_workarea,
1285                otk::OBProperty::Atom_Cardinal, 0, 0);
1286 }
1287
1288
1289 void BScreen::updateNetizenWorkspaceCount(void) {
1290   xatom->set(getRootWindow(), otk::OBProperty::net_number_of_desktops,
1291              otk::OBProperty::Atom_Cardinal, workspacesList.size());
1292
1293   updateWorkArea();
1294 }
1295
1296
1297 void BScreen::updateNetizenWindowFocus(void) {
1298   Window f = ((blackbox->getFocusedWindow()) ?
1299               blackbox->getFocusedWindow()->getClientWindow() : None);
1300
1301   xatom->set(getRootWindow(), otk::OBProperty::net_active_window,
1302              otk::OBProperty::Atom_Window, f);
1303 }
1304
1305
1306 void BScreen::raiseWindows(Window *workspace_stack, unsigned int num) {
1307   // the 13 represents the number of blackbox windows such as menus
1308   int bbwins = 15;
1309 #ifdef    XINERAMA
1310   ++bbwins;
1311 #endif // XINERAMA
1312
1313   Window *session_stack = new
1314     Window[(num + specialWindowList.size() + bbwins)];
1315   unsigned int i = 0, k = num;
1316
1317   WindowList::iterator sit, send = specialWindowList.end();
1318   for (sit = specialWindowList.begin(); sit != send; ++sit)
1319     *(session_stack + i++) = *sit;
1320
1321   while (k--)
1322     *(session_stack + i++) = *(workspace_stack + k);
1323
1324   XRestackWindows(otk::OBDisplay::display, session_stack, i);
1325
1326   delete [] session_stack;
1327
1328   updateStackingList();
1329 }
1330
1331
1332 void BScreen::lowerWindows(Window *workspace_stack, unsigned int num) {
1333   assert(num > 0);  // this would cause trouble in the XRaiseWindow call
1334
1335   Window *session_stack = new Window[(num + desktopWindowList.size())];
1336   unsigned int i = 0, k = num;
1337
1338   XLowerWindow(otk::OBDisplay::display, workspace_stack[0]);
1339
1340   while (k--)
1341     *(session_stack + i++) = *(workspace_stack + k);
1342
1343   WindowList::iterator dit = desktopWindowList.begin();
1344   const WindowList::iterator d_end = desktopWindowList.end();
1345   for (; dit != d_end; ++dit)
1346     *(session_stack + i++) = *dit;
1347
1348   XRestackWindows(otk::OBDisplay::display, session_stack, i);
1349
1350   delete [] session_stack;
1351
1352   updateStackingList();
1353 }
1354
1355
1356 void BScreen::reassociateWindow(BlackboxWindow *w, unsigned int wkspc_id,
1357                                 bool ignore_sticky) {
1358   if (! w) return;
1359
1360   if (wkspc_id == BSENTINEL)
1361     wkspc_id = current_workspace->getID();
1362
1363   if (w->getWorkspaceNumber() == wkspc_id)
1364     return;
1365
1366   if (w->isIconic()) {
1367     removeIcon(w);
1368     getWorkspace(wkspc_id)->addWindow(w);
1369     if (w->isStuck())
1370       for (unsigned int i = 0; i < getNumberOfWorkspaces(); ++i)
1371         if (i != w->getWorkspaceNumber())
1372           getWorkspace(i)->addWindow(w, True);
1373   } else if (ignore_sticky || ! w->isStuck()) {
1374     if (w->isStuck())
1375       w->stick();
1376     getWorkspace(w->getWorkspaceNumber())->removeWindow(w);
1377     getWorkspace(wkspc_id)->addWindow(w);
1378   }
1379   updateStackingList();
1380 }
1381
1382
1383 void BScreen::propagateWindowName(const BlackboxWindow *bw) {
1384   if (bw->isIconic()) {
1385   } else {
1386   }
1387 }
1388
1389
1390 void BScreen::nextFocus(void) const {
1391   BlackboxWindow *focused = blackbox->getFocusedWindow(),
1392     *next = focused;
1393
1394   if (focused &&
1395       focused->getScreen()->getScreenNumber() == getScreenNumber() &&
1396       current_workspace->getCount() > 1) {
1397     do {
1398       next = current_workspace->getNextWindowInList(next);
1399     } while (next != focused && ! next->setInputFocus());
1400
1401     if (next != focused)
1402       current_workspace->raiseWindow(next);
1403   } else if (current_workspace->getCount() > 0) {
1404     next = current_workspace->getTopWindowOnStack();
1405     next->setInputFocus();
1406     current_workspace->raiseWindow(next);
1407   }
1408 }
1409
1410
1411 void BScreen::prevFocus(void) const {
1412   BlackboxWindow *focused = blackbox->getFocusedWindow(),
1413     *next = focused;
1414
1415   if (focused) {
1416     // if window is not on this screen, ignore it
1417     if (focused->getScreen()->getScreenNumber() != getScreenNumber())
1418       focused = (BlackboxWindow*) 0;
1419   }
1420
1421   if (focused &&
1422       focused->getScreen()->getScreenNumber() == getScreenNumber() &&
1423       current_workspace->getCount() > 1) {
1424     // next is the next window to receive focus, current is a place holder
1425     do {
1426       next = current_workspace->getPrevWindowInList(next);
1427     } while (next != focused && ! next->setInputFocus());
1428
1429     if (next != focused)
1430       current_workspace->raiseWindow(next);
1431   } else if (current_workspace->getCount() > 0) {
1432     next = current_workspace->getTopWindowOnStack();
1433     next->setInputFocus();
1434     current_workspace->raiseWindow(next);
1435   }
1436 }
1437
1438
1439 void BScreen::raiseFocus(void) const {
1440   BlackboxWindow *focused = blackbox->getFocusedWindow();
1441   if (! focused)
1442     return;
1443
1444   // if on this Screen, raise it
1445   if (focused->getScreen()->getScreenNumber() == getScreenNumber()) {
1446     Workspace *workspace = getWorkspace(focused->getWorkspaceNumber());
1447     workspace->raiseWindow(focused);
1448   }
1449 }
1450
1451
1452 void BScreen::shutdown(void) {
1453   XSelectInput(otk::OBDisplay::display, getRootWindow(), NoEventMask);
1454   XSync(otk::OBDisplay::display, False);
1455
1456   while(! windowList.empty())
1457     unmanageWindow(windowList.front(), True);
1458
1459   while(! desktopWindowList.empty()) {
1460     BlackboxWindow *win = blackbox->searchWindow(desktopWindowList.front());
1461     assert(win);
1462     unmanageWindow(win, True);
1463   }
1464 }
1465
1466
1467 void BScreen::showPosition(int x, int y) {
1468   if (! geom_visible) {
1469     XMoveResizeWindow(otk::OBDisplay::display, geom_window,
1470                       (getWidth() - geom_w) / 2,
1471                       (getHeight() - geom_h) / 2, geom_w, geom_h);
1472     XMapWindow(otk::OBDisplay::display, geom_window);
1473     XRaiseWindow(otk::OBDisplay::display, geom_window);
1474
1475     geom_visible = True;
1476   }
1477
1478   char label[1024];
1479
1480   sprintf(label, "X: %4d x Y: %4d", x, y);
1481
1482   XClearWindow(otk::OBDisplay::display, geom_window);
1483
1484   resource.wstyle.font->drawString(geom_window,
1485                                    resource.bevel_width, resource.bevel_width,
1486                                    resource.wstyle.l_text_focus,
1487                                    label);
1488 }
1489
1490
1491 void BScreen::showGeometry(unsigned int gx, unsigned int gy) {
1492   if (! geom_visible) {
1493     XMoveResizeWindow(otk::OBDisplay::display, geom_window,
1494                       (getWidth() - geom_w) / 2,
1495                       (getHeight() - geom_h) / 2, geom_w, geom_h);
1496     XMapWindow(otk::OBDisplay::display, geom_window);
1497     XRaiseWindow(otk::OBDisplay::display, geom_window);
1498
1499     geom_visible = True;
1500   }
1501
1502   char label[1024];
1503
1504   sprintf(label, "W: %4d x H: %4d", gx, gy);
1505
1506   XClearWindow(otk::OBDisplay::display, geom_window);
1507
1508   resource.wstyle.font->drawString(geom_window,
1509                                    resource.bevel_width, resource.bevel_width,
1510                                    resource.wstyle.l_text_focus,
1511                                    label);
1512 }
1513
1514
1515 void BScreen::hideGeometry(void) {
1516   if (geom_visible) {
1517     XUnmapWindow(otk::OBDisplay::display, geom_window);
1518     geom_visible = False;
1519   }
1520 }
1521
1522
1523 void BScreen::addStrut(otk::Strut *strut) {
1524   strutList.push_back(strut);
1525 }
1526
1527
1528 void BScreen::removeStrut(otk::Strut *strut) {
1529   strutList.remove(strut);
1530 }
1531
1532
1533 const otk::Rect& BScreen::availableArea(void) const {
1534   if (doFullMax())
1535     return getRect(); // return the full screen
1536   return usableArea;
1537 }
1538
1539
1540 #ifdef    XINERAMA
1541 const RectList& BScreen::allAvailableAreas(void) const {
1542   assert(isXineramaActive());
1543   assert(xineramaUsableArea.size() > 0);
1544   fprintf(stderr, "1found x %d y %d w %d h %d\n",
1545           xineramaUsableArea[0].x(), xineramaUsableArea[0].y(),
1546           xineramaUsableArea[0].width(), xineramaUsableArea[0].height());
1547   return xineramaUsableArea;
1548 }
1549 #endif // XINERAMA
1550
1551
1552 void BScreen::updateAvailableArea(void) {
1553   otk::Rect old_area = usableArea;
1554   usableArea = getRect(); // reset to full screen
1555
1556 #ifdef    XINERAMA
1557   // reset to the full areas
1558   if (isXineramaActive())
1559     xineramaUsableArea = getXineramaAreas();
1560 #endif // XINERAMA
1561
1562   /* these values represent offsets from the screen edge
1563    * we look for the biggest offset on each edge and then apply them
1564    * all at once
1565    * do not be confused by the similarity to the names of Rect's members
1566    */
1567   unsigned int current_left = 0, current_right = 0, current_top = 0,
1568     current_bottom = 0;
1569
1570   StrutList::const_iterator it = strutList.begin(), end = strutList.end();
1571
1572   for(; it != end; ++it) {
1573     otk::Strut *strut = *it;
1574     if (strut->left > current_left)
1575       current_left = strut->left;
1576     if (strut->top > current_top)
1577       current_top = strut->top;
1578     if (strut->right > current_right)
1579       current_right = strut->right;
1580     if (strut->bottom > current_bottom)
1581       current_bottom = strut->bottom;
1582   }
1583
1584   usableArea.setPos(current_left, current_top);
1585   usableArea.setSize(usableArea.width() - (current_left + current_right),
1586                      usableArea.height() - (current_top + current_bottom));
1587
1588 #ifdef    XINERAMA
1589   if (isXineramaActive()) {
1590     // keep each of the ximerama-defined areas inside the strut
1591     RectList::iterator xit, xend = xineramaUsableArea.end();
1592     for (xit = xineramaUsableArea.begin(); xit != xend; ++xit) {
1593       if (xit->x() < usableArea.x()) {
1594         xit->setX(usableArea.x());
1595         xit->setWidth(xit->width() - usableArea.x());
1596       }
1597       if (xit->y() < usableArea.y()) {
1598         xit->setY(usableArea.y());
1599         xit->setHeight(xit->height() - usableArea.y());
1600       }
1601       if (xit->x() + xit->width() > usableArea.width())
1602         xit->setWidth(usableArea.width() - xit->x());
1603       if (xit->y() + xit->height() > usableArea.height())
1604         xit->setHeight(usableArea.height() - xit->y());
1605     }
1606   }
1607 #endif // XINERAMA
1608
1609   if (old_area != usableArea) {
1610     BlackboxWindowList::iterator it = windowList.begin(),
1611       end = windowList.end();
1612     for (; it != end; ++it)
1613       if ((*it)->isMaximized()) (*it)->remaximize();
1614   }
1615
1616   updateWorkArea();
1617 }
1618
1619
1620 Workspace* BScreen::getWorkspace(unsigned int index) const {
1621   assert(index < workspacesList.size());
1622   return workspacesList[index];
1623 }
1624
1625
1626 void BScreen::buttonPressEvent(const XButtonEvent *xbutton) {
1627   if (xbutton->button == 1) {
1628     if (! isRootColormapInstalled())
1629       image_control->installRootColormap();
1630
1631   // mouse wheel up
1632   } else if ((xbutton->button == 4 && resource.root_scroll == NormalScroll) ||
1633              (xbutton->button == 5 && resource.root_scroll == ReverseScroll)) {
1634     if (getCurrentWorkspaceID() >= getWorkspaceCount() - 1)
1635       changeWorkspaceID(0);
1636     else
1637       changeWorkspaceID(getCurrentWorkspaceID() + 1);
1638   // mouse wheel down
1639   } else if ((xbutton->button == 5 && resource.root_scroll == NormalScroll) ||
1640              (xbutton->button == 4 && resource.root_scroll == ReverseScroll)) {
1641     if (getCurrentWorkspaceID() == 0)
1642       changeWorkspaceID(getWorkspaceCount() - 1);
1643     else
1644       changeWorkspaceID(getCurrentWorkspaceID() - 1);
1645   }
1646 }
1647
1648
1649 void BScreen::propertyNotifyEvent(const XPropertyEvent *pe) {
1650   if (pe->atom == xatom->atom(otk::OBProperty::net_desktop_names)) {
1651     // _NET_WM_DESKTOP_NAMES
1652     WorkspaceList::iterator it = workspacesList.begin();
1653     const WorkspaceList::iterator end = workspacesList.end();
1654     for (; it != end; ++it) {
1655       (*it)->readName(); // re-read its name from the window property
1656       //workspacemenu->changeWorkspaceLabel((*it)->getID(), (*it)->getName());
1657     }
1658     //workspacemenu->update();
1659     saveWorkspaceNames();
1660   }
1661 }
1662
1663
1664 void BScreen::toggleFocusModel(FocusModel model) {
1665   std::for_each(windowList.begin(), windowList.end(),
1666                 std::mem_fun(&BlackboxWindow::ungrabButtons));
1667
1668   if (model == SloppyFocus) {
1669     saveSloppyFocus(True);
1670   } else {
1671     // we're cheating here to save writing the config file 3 times
1672     resource.auto_raise = False;
1673     resource.click_raise = False;
1674     saveSloppyFocus(False);
1675   }
1676
1677   std::for_each(windowList.begin(), windowList.end(),
1678                 std::mem_fun(&BlackboxWindow::grabButtons));
1679 }
1680
1681 void BScreen::readDatabaseMask(const string &rname, PixmapMask &pixmapMask,
1682                                const Configuration &style) {
1683   string s;
1684   int hx, hy; //ignored
1685   int ret = BitmapOpenFailed; //default to failure.
1686
1687   if (style.getValue(rname, s))
1688   {
1689     if (s[0] != '/' && s[0] != '~')
1690     {
1691       std::string xbmFile = std::string("~/.openbox/buttons/") + s;
1692       ret = XReadBitmapFile(otk::OBDisplay::display, getRootWindow(),
1693                             expandTilde(xbmFile).c_str(), &pixmapMask.w,
1694                             &pixmapMask.h, &pixmapMask.mask, &hx, &hy);
1695     } else
1696       ret = XReadBitmapFile(otk::OBDisplay::display, getRootWindow(),
1697                             expandTilde(s).c_str(), &pixmapMask.w,
1698                             &pixmapMask.h, &pixmapMask.mask, &hx, &hy);
1699
1700     if (ret == BitmapSuccess)
1701       return;
1702   }
1703
1704   pixmapMask.mask = None;
1705   pixmapMask.w = pixmapMask.h = 0;
1706 }
1707
1708 otk::BTexture BScreen::readDatabaseTexture(const string &rname,
1709                                            const string &default_color,
1710                                            const Configuration &style,
1711                                            bool allowNoTexture) {
1712   otk::BTexture texture;
1713   string s;
1714
1715   if (style.getValue(rname, s))
1716     texture = otk::BTexture(s);
1717   else if (allowNoTexture) //no default
1718     texture.setTexture(otk::BTexture::NoTexture);
1719   else
1720     texture.setTexture(otk::BTexture::Solid | otk::BTexture::Flat);
1721
1722   // associate this texture with this screen
1723   texture.setScreen(getScreenNumber());
1724   texture.setImageControl(image_control);
1725
1726   if (texture.texture() != otk::BTexture::NoTexture) {
1727     texture.setColor(readDatabaseColor(rname + ".color", default_color,
1728                                        style));
1729     texture.setColorTo(readDatabaseColor(rname + ".colorTo", default_color,
1730                                          style));
1731     texture.setBorderColor(readDatabaseColor(rname + ".borderColor",
1732                                              default_color, style));
1733   }
1734
1735   return texture;
1736 }
1737
1738
1739 otk::BColor BScreen::readDatabaseColor(const string &rname,
1740                                        const string &default_color,
1741                                        const Configuration &style) {
1742   otk::BColor color;
1743   string s;
1744   if (style.getValue(rname, s))
1745     color = otk::BColor(s, getScreenNumber());
1746   else
1747     color = otk::BColor(default_color, getScreenNumber());
1748   return color;
1749 }
1750
1751
1752 otk::BFont *BScreen::readDatabaseFont(const string &rbasename,
1753                                       const Configuration &style) {
1754   string fontname;
1755
1756   string s;
1757
1758   int i;
1759   if (style.getValue(rbasename + "xft.font", s) &&
1760       style.getValue(rbasename + "xft.size", i)) {
1761     string family = s;
1762     bool bold = False;
1763     bool italic = False;
1764     bool dropShadow = False;
1765
1766     if (style.getValue(rbasename + "xft.flags", s)) {
1767       if (s.find("bold") != string::npos)
1768         bold = True;
1769       if (s.find("italic") != string::npos)
1770         italic = True;
1771       if (s.find("shadow") != string::npos)
1772         dropShadow = True;
1773     }
1774
1775     unsigned char offset = 1;
1776     if (style.getValue(rbasename + "xft.shadow.offset", s)) {
1777       offset = atoi(s.c_str()); //doesn't detect errors
1778       if (offset > CHAR_MAX)
1779         offset = 1;
1780     }
1781
1782     unsigned char tint = 0x40;
1783     if (style.getValue(rbasename + "xft.shadow.tint", s)) {
1784       tint = atoi(s.c_str());
1785     }
1786
1787
1788     otk::BFont *b = new otk::BFont(getScreenNumber(), family, i, bold, italic,
1789                                    dropShadow && resource.shadow_fonts,
1790                                    offset, tint, resource.aa_fonts);
1791     if (b->valid())
1792       return b;
1793     delete b;
1794   }
1795
1796   exit(2);  // can't continue without a font
1797 }
1798
1799 }