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