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
   6
   7 extern "C" {
   8 #ifdef    HAVE_STDIO_H
   9 #  include <stdio.h>
  10 #endif // HAVE_STDIO_H
  11
  12 #ifdef    HAVE_UNISTD_H
  13 #  include <sys/types.h>
  14 #  include <unistd.h>
  15 #endif // HAVE_UNISTD_H
  16
  17 #include "gettext.h"
  18 #define _(str) gettext(str)
  19 }
  20
  21 #include "screen.hh"
  22 #include "client.hh"
  23 #include "openbox.hh"
  24 #include "frame.hh"
  25 #include "bindings.hh"
  26 #include "python.hh"
  27 #include "otk/display.hh"
  28
  29 #include <vector>
  30
  31 static bool running;
  32 static int anotherWMRunning(Display *display, XErrorEvent *) {
  33   printf(_("Another window manager already running on display %s.\n"),
  34          DisplayString(display));
  35   running = true;
  36   return -1;
  37 }
  38
  39
  40 namespace ob {
  41
  42
  43 OBScreen::OBScreen(int screen)
  44   : _number(screen),
  45     _root(screen)
  46 {
  47   assert(screen >= 0); assert(screen < ScreenCount(otk::OBDisplay::display));
  48   _info = otk::OBDisplay::screenInfo(screen);
  49
  50   ::running = false;
  51   XErrorHandler old = XSetErrorHandler(::anotherWMRunning);
  52   XSelectInput(otk::OBDisplay::display, _info->rootWindow(),
  53                OBScreen::event_mask);
  54   XSync(otk::OBDisplay::display, false);
  55   XSetErrorHandler(old);
  56
  57   _managed = !::running;
  58   if (! _managed) return; // was unable to manage the screen
  59
  60   printf(_("Managing screen %d: visual 0x%lx, depth %d\n"),
  61          _number, XVisualIDFromVisual(_info->visual()), _info->depth());
  62
  63   Openbox::instance->property()->set(_info->rootWindow(),
  64                                      otk::OBProperty::openbox_pid,
  65                                      otk::OBProperty::Atom_Cardinal,
  66                                      (unsigned long) getpid());
  67
  68   // set the mouse cursor for the root window (the default cursor)
  69   XDefineCursor(otk::OBDisplay::display, _info->rootWindow(),
  70                 Openbox::instance->cursors().session);
  71
  72   // initialize the shit that is used for all drawing on the screen
  73   _image_control = new otk::BImageControl(Openbox::instance->timerManager(),
  74                                           _info, true);
  75   _image_control->installRootColormap();
  76   _root_cmap_installed = True;
  77
  78   // initialize the screen's style
  79   _style.setImageControl(_image_control);
  80   std::string stylepath;
  81   python_get_string("theme", &stylepath);
  82   otk::Configuration sconfig(false);
  83   sconfig.setFile(otk::expandTilde(stylepath));
  84   if (!sconfig.load()) {
  85     sconfig.setFile(otk::expandTilde(DEFAULTSTYLE));
  86     if (!sconfig.load()) {
  87       printf(_("Unable to load default style: %s. Aborting.\n"), DEFAULTSTYLE);
  88       ::exit(1);
  89     }
  90   }
  91   _style.load(sconfig);
  92
  93   // Set the netwm atoms for geomtery and viewport
  94   unsigned long geometry[] = { _info->width(),
  95                                _info->height() };
  96   Openbox::instance->property()->set(_info->rootWindow(),
  97                                      otk::OBProperty::net_desktop_geometry,
  98                                      otk::OBProperty::Atom_Cardinal,
  99                                      geometry, 2);
 100   unsigned long viewport[] = { 0, 0 };
 101   Openbox::instance->property()->set(_info->rootWindow(),
 102                                      otk::OBProperty::net_desktop_viewport,
 103                                      otk::OBProperty::Atom_Cardinal,
 104                                      viewport, 2);
 105
 106   // create the window which gets focus when no clients get it
 107   XSetWindowAttributes attr;
 108   attr.override_redirect = true;
 109   _focuswindow = XCreateWindow(otk::OBDisplay::display, _info->rootWindow(),
 110                                -100, -100, 1, 1, 0, 0, InputOnly,
 111                                _info->visual(), CWOverrideRedirect, &attr);
 112   XMapWindow(otk::OBDisplay::display, _focuswindow);
 113
 114   // these may be further updated if any pre-existing windows are found in
 115   // the manageExising() function
 116   setClientList();     // initialize the client lists, which will be empty
 117   calcArea();          // initialize the available working area
 118 }
 119
 120
 121 OBScreen::~OBScreen()
 122 {
 123   if (! _managed) return;
 124
 125   XSelectInput(otk::OBDisplay::display, _info->rootWindow(), NoEventMask);
 126
 127   // unmanage all windows
 128   while (!clients.empty())
 129     unmanageWindow(clients.front());
 130
 131   XDestroyWindow(otk::OBDisplay::display, _focuswindow);
 132
 133   delete _image_control;
 134 }
 135
 136
 137 void OBScreen::manageExisting()
 138 {
 139   unsigned int i, j, nchild;
 140   Window r, p, *children;
 141   XQueryTree(otk::OBDisplay::display, _info->rootWindow(), &r, &p,
 142              &children, &nchild);
 143
 144   // preen the window list of all icon windows... for better dockapp support
 145   for (i = 0; i < nchild; i++) {
 146     if (children[i] == None) continue;
 147
 148     XWMHints *wmhints = XGetWMHints(otk::OBDisplay::display,
 149                                     children[i]);
 150
 151     if (wmhints) {
 152       if ((wmhints->flags & IconWindowHint) &&
 153           (wmhints->icon_window != children[i])) {
 154         for (j = 0; j < nchild; j++) {
 155           if (children[j] == wmhints->icon_window) {
 156             children[j] = None;
 157             break;
 158           }
 159         }
 160       }
 161
 162       XFree(wmhints);
 163     }
 164   }
 165
 166   // manage shown windows
 167   for (i = 0; i < nchild; ++i) {
 168     if (children[i] == None)
 169       continue;
 170
 171     XWindowAttributes attrib;
 172     if (XGetWindowAttributes(otk::OBDisplay::display, children[i], &attrib)) {
 173       if (attrib.override_redirect) continue;
 174
 175       if (attrib.map_state != IsUnmapped) {
 176         manageWindow(children[i]);
 177       }
 178     }
 179   }
 180
 181   XFree(children);
 182 }
 183
 184
 185 //! Adds a window's strut to the screen's list of reserved spaces
 186 void OBScreen::addStrut(otk::Strut *strut)
 187 {
 188   _struts.push_back(strut);
 189 }
 190
 191
 192 //! Removes a window's strut from the screen's list of reserved spaces
 193 void OBScreen::removeStrut(otk::Strut *strut)
 194 {
 195   _struts.remove(strut);
 196 }
 197
 198
 199 void OBScreen::calcArea()
 200 {
 201   otk::Rect old_area = _area;
 202
 203 /*
 204 #ifdef    XINERAMA
 205   // reset to the full areas
 206   if (isXineramaActive())
 207     xineramaUsableArea = getXineramaAreas();
 208 #endif // XINERAMA
 209 */
 210
 211   /* these values represent offsets from the screen edge
 212    * we look for the biggest offset on each edge and then apply them
 213    * all at once
 214    * do not be confused by the similarity to the names of Rect's members
 215    */
 216   unsigned int current_left = 0, current_right = 0, current_top = 0,
 217     current_bottom = 0;
 218
 219   StrutList::const_iterator it = _struts.begin(), end = _struts.end();
 220
 221   for(; it != end; ++it) {
 222     otk::Strut *strut = *it;
 223     if (strut->left > current_left)
 224       current_left = strut->left;
 225     if (strut->top > current_top)
 226       current_top = strut->top;
 227     if (strut->right > current_right)
 228       current_right = strut->right;
 229     if (strut->bottom > current_bottom)
 230       current_bottom = strut->bottom;
 231   }
 232
 233   _area.setRect(current_left, current_top,
 234                 _info->width() - (current_left + current_right),
 235                 _info->height() - (current_top + current_bottom));
 236
 237 /*
 238 #ifdef    XINERAMA
 239   if (isXineramaActive()) {
 240     // keep each of the ximerama-defined areas inside the strut
 241     RectList::iterator xit, xend = xineramaUsableArea.end();
 242     for (xit = xineramaUsableArea.begin(); xit != xend; ++xit) {
 243       if (xit->x() < usableArea.x()) {
 244         xit->setX(usableArea.x());
 245         xit->setWidth(xit->width() - usableArea.x());
 246       }
 247       if (xit->y() < usableArea.y()) {
 248         xit->setY(usableArea.y());
 249         xit->setHeight(xit->height() - usableArea.y());
 250       }
 251       if (xit->x() + xit->width() > usableArea.width())
 252         xit->setWidth(usableArea.width() - xit->x());
 253       if (xit->y() + xit->height() > usableArea.height())
 254         xit->setHeight(usableArea.height() - xit->y());
 255     }
 256   }
 257 #endif // XINERAMA
 258 */
 259
 260   if (old_area != _area)
 261     // XXX: re-maximize windows
 262
 263   setWorkArea();
 264 }
 265
 266
 267 void OBScreen::setClientList()
 268 {
 269   Window *windows;
 270
 271   // create an array of the window ids
 272   if (clients.size() > 0) {
 273     Window *win_it;
 274
 275     windows = new Window[clients.size()];
 276     win_it = windows;
 277     ClientList::const_iterator it = clients.begin();
 278     const ClientList::const_iterator end = clients.end();
 279     for (; it != end; ++it, ++win_it)
 280       *win_it = (*it)->window();
 281   } else
 282     windows = (Window*) 0;
 283
 284   Openbox::instance->property()->set(_info->rootWindow(),
 285                                      otk::OBProperty::net_client_list,
 286                                      otk::OBProperty::Atom_Window,
 287                                      windows, clients.size());
 288
 289   if (clients.size())
 290     delete [] windows;
 291
 292   setStackingList();
 293 }
 294
 295
 296 void OBScreen::setStackingList()
 297 {
 298   // The below comment is wrong now hopefully :> but ill keep it here for
 299   // reference anyways
 300   /*
 301     Get the stacking order from all of the workspaces.
 302     We start with the current workspace so that the sticky windows will be
 303     in the right order on the current workspace.
 304   */
 305   /*
 306   Openbox::instance->property()->set(_info->getRootWindow(),
 307                                      otk::OBProperty::net_client_list_stacking,
 308                                      otk::OBProperty::Atom_Window,
 309                                      _stacking, _stacking.size());
 310   */
 311 }
 312
 313
 314 void OBScreen::setWorkArea() {
 315   unsigned long area[] = { _area.x(), _area.y(),
 316                            _area.width(), _area.height() };
 317   Openbox::instance->property()->set(_info->rootWindow(),
 318                                      otk::OBProperty::net_workarea,
 319                                      otk::OBProperty::Atom_Cardinal,
 320                                      area, 4);
 321   /*
 322   if (workspacesList.size() > 0) {
 323     unsigned long *dims = new unsigned long[4 * workspacesList.size()];
 324     for (unsigned int i = 0, m = workspacesList.size(); i < m; ++i) {
 325       // XXX: this could be different for each workspace
 326       const otk::Rect &area = availableArea();
 327       dims[(i * 4) + 0] = area.x();
 328       dims[(i * 4) + 1] = area.y();
 329       dims[(i * 4) + 2] = area.width();
 330       dims[(i * 4) + 3] = area.height();
 331     }
 332     xatom->set(getRootWindow(), otk::OBProperty::net_workarea,
 333                otk::OBProperty::Atom_Cardinal,
 334                dims, 4 * workspacesList.size());
 335     delete [] dims;
 336   } else
 337     xatom->set(getRootWindow(), otk::OBProperty::net_workarea,
 338                otk::OBProperty::Atom_Cardinal, 0, 0);
 339   */
 340 }
 341
 342
 343 void OBScreen::manageWindow(Window window)
 344 {
 345   OBClient *client = 0;
 346   XWMHints *wmhint;
 347   XSetWindowAttributes attrib_set;
 348
 349   // is the window a docking app
 350   if ((wmhint = XGetWMHints(otk::OBDisplay::display, window))) {
 351     if ((wmhint->flags & StateHint) &&
 352         wmhint->initial_state == WithdrawnState) {
 353       //slit->addClient(w); // XXX: make dock apps work!
 354       XFree(wmhint);
 355       return;
 356     }
 357     XFree(wmhint);
 358   }
 359
 360   otk::OBDisplay::grab();
 361
 362   // choose the events we want to receive on the CLIENT window
 363   attrib_set.event_mask = OBClient::event_mask;
 364   attrib_set.do_not_propagate_mask = OBClient::no_propagate_mask;
 365   XChangeWindowAttributes(otk::OBDisplay::display, window,
 366                           CWEventMask|CWDontPropagate, &attrib_set);
 367
 368   // create the OBClient class, which gets all of the hints on the window
 369   client = new OBClient(_number, window);
 370   // register for events
 371   Openbox::instance->registerHandler(window, client);
 372   // add to the wm's map
 373   Openbox::instance->addClient(window, client);
 374
 375   // we dont want a border on the client
 376   client->toggleClientBorder(false);
 377
 378   // specify that if we exit, the window should not be destroyed and should be
 379   // reparented back to root automatically
 380   XChangeSaveSet(otk::OBDisplay::display, window, SetModeInsert);
 381
 382   if (!client->positionRequested()) {
 383     // XXX: position the window intelligenty
 384   }
 385
 386   // create the decoration frame for the client window
 387   client->frame = new OBFrame(client, &_style);
 388
 389   // add to the wm's map
 390   Openbox::instance->addClient(client->frame->window(), client);
 391   Openbox::instance->addClient(client->frame->plate(), client);
 392   Openbox::instance->addClient(client->frame->titlebar(), client);
 393   Openbox::instance->addClient(client->frame->label(), client);
 394   Openbox::instance->addClient(client->frame->button_max(), client);
 395   Openbox::instance->addClient(client->frame->button_iconify(), client);
 396   Openbox::instance->addClient(client->frame->button_stick(), client);
 397   Openbox::instance->addClient(client->frame->button_close(), client);
 398   Openbox::instance->addClient(client->frame->handle(), client);
 399   Openbox::instance->addClient(client->frame->grip_left(), client);
 400   Openbox::instance->addClient(client->frame->grip_right(), client);
 401
 402   // XXX: if on the current desktop..
 403   client->frame->show();
 404
 405   // XXX: handle any requested states such as shaded/maximized
 406
 407   otk::OBDisplay::ungrab();
 408
 409   // add to the screen's list
 410   clients.push_back(client);
 411   // this puts into the stacking order, then raises it
 412   _stacking.push_back(client);
 413   restack(true, client);
 414   // update the root properties
 415   setClientList();
 416
 417   Openbox::instance->bindings()->grabButtons(true, client);
 418 }
 419
 420
 421 void OBScreen::unmanageWindow(OBClient *client)
 422 {
 423   OBFrame *frame = client->frame;
 424
 425   Openbox::instance->bindings()->grabButtons(false, client);
 426
 427   // remove from the stacking order
 428   _stacking.remove(client);
 429
 430   // pass around focus if this window was focused XXX do this better!
 431   if (Openbox::instance->focusedClient() == client) {
 432     OBClient *newfocus = 0;
 433     if (!_stacking.empty())
 434       newfocus = _stacking.front();
 435     if (! (newfocus && newfocus->focus()))
 436       client->unfocus();
 437   }
 438
 439   // remove from the wm's map
 440   Openbox::instance->removeClient(client->window());
 441   Openbox::instance->removeClient(frame->window());
 442   Openbox::instance->removeClient(frame->plate());
 443   Openbox::instance->removeClient(frame->titlebar());
 444   Openbox::instance->removeClient(frame->label());
 445   Openbox::instance->removeClient(frame->button_max());
 446   Openbox::instance->removeClient(frame->button_iconify());
 447   Openbox::instance->removeClient(frame->button_stick());
 448   Openbox::instance->removeClient(frame->button_close());
 449   Openbox::instance->removeClient(frame->handle());
 450   Openbox::instance->removeClient(frame->grip_left());
 451   Openbox::instance->removeClient(frame->grip_right());
 452   // unregister for handling events
 453   Openbox::instance->clearHandler(client->window());
 454
 455   // remove the window from our save set
 456   XChangeSaveSet(otk::OBDisplay::display, client->window(), SetModeDelete);
 457
 458   // we dont want events no more
 459   XSelectInput(otk::OBDisplay::display, client->window(), NoEventMask);
 460
 461   frame->hide();
 462
 463   // give the client its border back
 464   client->toggleClientBorder(true);
 465
 466   delete client->frame;
 467   client->frame = 0;
 468
 469   // remove from the screen's list
 470   clients.remove(client);
 471   delete client;
 472
 473   // update the root properties
 474   setClientList();
 475 }
 476
 477 void OBScreen::restack(bool raise, OBClient *client)
 478 {
 479   const int layer = client->layer();
 480   std::vector<Window> wins;
 481
 482   _stacking.remove(client);
 483
 484   // the stacking list is from highest to lowest
 485
 486   ClientList::iterator it = _stacking.begin(), end = _stacking.end();
 487   // insert the windows above this window
 488   for (; it != end; ++it) {
 489     if ((*it)->layer() < layer || (raise && (*it)->layer() == layer))
 490       break;
 491     wins.push_back((*it)->frame->window());
 492   }
 493   // insert our client
 494   wins.push_back(client->frame->window());
 495   _stacking.insert(it, client);
 496   // insert the remaining below this window
 497   for (; it != end; ++it)
 498     wins.push_back((*it)->frame->window());
 499
 500   XRestackWindows(otk::OBDisplay::display, &wins[0], wins.size());
 501 }
 502
 503 }