X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fscreen.cc;h=e97c05b295236b7e2bde13a0e1e4b8275ec6ed55;hb=bc88d310fea71823fb2c61d071ff499579bffaba;hp=18105f2a847a05faf1bec34bcfa6d649b6c45e7d;hpb=4dd8520e929b76f95926ffc746b733a7e416f080;p=chaz%2Fopenbox

diff --git a/src/screen.cc b/src/screen.cc
index 18105f2a..e97c05b2 100644
--- a/src/screen.cc
+++ b/src/screen.cc
@@ -9,6 +9,10 @@ extern "C" {
 #  include <stdio.h>
 #endif // HAVE_STDIO_H
 
+#ifdef    HAVE_STRING_H
+#  include <string.h>
+#endif // HAVE_STRING_H
+
 #ifdef    HAVE_UNISTD_H
 #  include <sys/types.h>
 #  include <unistd.h>
@@ -27,6 +31,7 @@ extern "C" {
 #include "otk/display.hh"
 
 #include <vector>
+#include <algorithm>
 
 static bool running;
 static int anotherWMRunning(Display *display, XErrorEvent *) {
@@ -41,8 +46,8 @@ namespace ob {
 
 
 OBScreen::OBScreen(int screen)
-  : _number(screen),
-    _root(screen)
+  : OBWidget(OBWidget::Type_Root),
+    _number(screen)
 {
   assert(screen >= 0); assert(screen < ScreenCount(otk::OBDisplay::display));
   _info = otk::OBDisplay::screenInfo(screen);
@@ -91,20 +96,32 @@ OBScreen::OBScreen(int screen)
   _style.load(sconfig);
 
   // set up notification of netwm support
-  setSupportedAtoms();
+  changeSupportedAtoms();
 
-  // Set the netwm atoms for geomtery and viewport
+  // Set the netwm properties for geometry
   unsigned long geometry[] = { _info->width(),
                                _info->height() };
   Openbox::instance->property()->set(_info->rootWindow(),
                                      otk::OBProperty::net_desktop_geometry,
                                      otk::OBProperty::Atom_Cardinal,
                                      geometry, 2);
-  unsigned long viewport[] = { 0, 0 };
+
+  // Set the net_desktop_names property
+  std::vector<std::string> names;
+  python_get_stringlist("desktop_names", &names);
   Openbox::instance->property()->set(_info->rootWindow(),
-                                     otk::OBProperty::net_desktop_viewport,
-                                     otk::OBProperty::Atom_Cardinal,
-                                     viewport, 2);
+                                     otk::OBProperty::net_desktop_names,
+                                     otk::OBProperty::utf8,
+                                     names);
+  // the above set() will cause the updateDesktopNames to fire right away so
+  // we have a list of desktop names
+
+  if (!python_get_long("number_of_desktops", &_num_desktops))
+    _num_desktops = 4;
+  changeNumDesktops(_num_desktops); // set the hint
+
+  _desktop = 0;
+  changeDesktop(0); // set the hint
 
   // create the window which gets focus when no clients get it
   XSetWindowAttributes attr;
@@ -116,8 +133,15 @@ OBScreen::OBScreen(int screen)
   
   // these may be further updated if any pre-existing windows are found in
   // the manageExising() function
-  setClientList();     // initialize the client lists, which will be empty
+  changeClientList();  // initialize the client lists, which will be empty
   calcArea();          // initialize the available working area
+
+  // register this class as the event handler for the root window
+  Openbox::instance->registerHandler(_info->rootWindow(), this);
+
+  // call the python Startup callbacks
+  EventData data(_number, 0, EventShutdown, 0);
+  Openbox::instance->bindings()->fireEvent(&data);
 }
 
 
@@ -131,6 +155,10 @@ OBScreen::~OBScreen()
   while (!clients.empty())
     unmanageWindow(clients.front());
 
+  // call the python Shutdown callbacks
+  EventData data(_number, 0, EventShutdown, 0);
+  Openbox::instance->bindings()->fireEvent(&data);
+
   XDestroyWindow(otk::OBDisplay::display, _focuswindow);
   XDestroyWindow(otk::OBDisplay::display, _supportwindow);
 
@@ -186,17 +214,19 @@ void OBScreen::manageExisting()
 }
 
 
-//! Adds a window's strut to the screen's list of reserved spaces
-void OBScreen::addStrut(otk::Strut *strut)
+void OBScreen::updateStrut()
 {
-  _struts.push_back(strut);
-}
-
-
-//! Removes a window's strut from the screen's list of reserved spaces
-void OBScreen::removeStrut(otk::Strut *strut)
-{
-  _struts.remove(strut);
+  _strut.left = _strut.right = _strut.top = _strut.bottom = 0;
+
+  OBClient::List::iterator it, end = clients.end();
+  for (it = clients.begin(); it != end; ++it) {
+    const otk::Strut &s = (*it)->strut();
+    _strut.left = std::max(_strut.left, s.left);
+    _strut.right = std::max(_strut.right, s.right);
+    _strut.top = std::max(_strut.top, s.top);
+    _strut.bottom = std::max(_strut.bottom, s.bottom);
+  }
+  calcArea();
 }
 
 
@@ -212,31 +242,9 @@ void OBScreen::calcArea()
 #endif // XINERAMA
 */
   
-  /* these values represent offsets from the screen edge
-   * we look for the biggest offset on each edge and then apply them
-   * all at once
-   * do not be confused by the similarity to the names of Rect's members
-   */
-  unsigned int current_left = 0, current_right = 0, current_top = 0,
-    current_bottom = 0;
-
-  StrutList::const_iterator it = _struts.begin(), end = _struts.end();
-
-  for(; it != end; ++it) {
-    otk::Strut *strut = *it;
-    if (strut->left > current_left)
-      current_left = strut->left;
-    if (strut->top > current_top)
-      current_top = strut->top;
-    if (strut->right > current_right)
-      current_right = strut->right;
-    if (strut->bottom > current_bottom)
-      current_bottom = strut->bottom;
-  }
-
-  _area.setRect(current_left, current_top,
-                _info->width() - (current_left + current_right),
-                _info->height() - (current_top + current_bottom));
+  _area.setRect(_strut.left, _strut.top,
+                _info->width() - (_strut.left + _strut.right),
+                _info->height() - (_strut.top + _strut.bottom));
 
 /*
 #ifdef    XINERAMA
@@ -264,17 +272,16 @@ void OBScreen::calcArea()
   if (old_area != _area)
     // XXX: re-maximize windows
 
-  setWorkArea();
+  changeWorkArea();
 }
 
 
-void OBScreen::setSupportedAtoms()
+void OBScreen::changeSupportedAtoms()
 {
   // create the netwm support window
   _supportwindow = XCreateSimpleWindow(otk::OBDisplay::display,
                                        _info->rootWindow(),
                                        0, 0, 1, 1, 0, 0, 0);
-  assert(_supportwindow != None);
 
   // set supporting window
   Openbox::instance->property()->set(_info->rootWindow(),
@@ -294,19 +301,15 @@ void OBScreen::setSupportedAtoms()
 
   
   Atom supported[] = {
-/*
       otk::OBProperty::net_current_desktop,
       otk::OBProperty::net_number_of_desktops,
-*/
       otk::OBProperty::net_desktop_geometry,
       otk::OBProperty::net_desktop_viewport,
       otk::OBProperty::net_active_window,
       otk::OBProperty::net_workarea,
       otk::OBProperty::net_client_list,
       otk::OBProperty::net_client_list_stacking,
-/*
       otk::OBProperty::net_desktop_names,
-*/
       otk::OBProperty::net_close_window,
       otk::OBProperty::net_wm_name,
       otk::OBProperty::net_wm_visible_name,
@@ -315,9 +318,7 @@ void OBScreen::setSupportedAtoms()
 /*
       otk::OBProperty::net_wm_desktop,
 */
-/*
       otk::OBProperty::net_wm_strut,
-*/
       otk::OBProperty::net_wm_window_type,
       otk::OBProperty::net_wm_window_type_desktop,
       otk::OBProperty::net_wm_window_type_dock,
@@ -361,7 +362,8 @@ void OBScreen::setSupportedAtoms()
 
   // convert to the atom values
   for (int i = 0; i < num_supported; ++i)
-    supported[i] = Openbox::instance->property()->atom(supported[i]);
+    supported[i] =
+      Openbox::instance->property()->atom((otk::OBProperty::Atoms)supported[i]);
   
   Openbox::instance->property()->set(_info->rootWindow(),
                                      otk::OBProperty::net_supported,
@@ -370,7 +372,7 @@ void OBScreen::setSupportedAtoms()
 }
 
 
-void OBScreen::setClientList()
+void OBScreen::changeClientList()
 {
   Window *windows;
   unsigned int size = clients.size();
@@ -381,8 +383,8 @@ void OBScreen::setClientList()
     
     windows = new Window[size];
     win_it = windows;
-    ClientList::const_iterator it = clients.begin();
-    const ClientList::const_iterator end = clients.end();
+    OBClient::List::const_iterator it = clients.begin();
+    const OBClient::List::const_iterator end = clients.end();
     for (; it != end; ++it, ++win_it)
       *win_it = (*it)->window();
   } else
@@ -396,11 +398,11 @@ void OBScreen::setClientList()
   if (size)
     delete [] windows;
 
-  setStackingList();
+  changeStackingList();
 }
 
 
-void OBScreen::setStackingList()
+void OBScreen::changeStackingList()
 {
   Window *windows;
   unsigned int size = _stacking.size();
@@ -414,8 +416,8 @@ void OBScreen::setStackingList()
     
     windows = new Window[size];
     win_it = windows;
-    ClientList::const_iterator it = _stacking.begin();
-    const ClientList::const_iterator end = _stacking.end();
+    OBClient::List::const_iterator it = _stacking.begin();
+    const OBClient::List::const_iterator end = _stacking.end();
     for (; it != end; ++it, ++win_it)
       *win_it = (*it)->window();
   } else
@@ -431,32 +433,20 @@ void OBScreen::setStackingList()
 }
 
 
-void OBScreen::setWorkArea() {
-  unsigned long area[] = { _area.x(), _area.y(),
-                           _area.width(), _area.height() };
+void OBScreen::changeWorkArea() {
+  unsigned long *dims = new unsigned long[4 * _num_desktops];
+  for (long i = 0; i < _num_desktops; ++i) {
+    // XXX: this could be different for each workspace
+    dims[(i * 4) + 0] = _area.x();
+    dims[(i * 4) + 1] = _area.y();
+    dims[(i * 4) + 2] = _area.width();
+    dims[(i * 4) + 3] = _area.height();
+  }
   Openbox::instance->property()->set(_info->rootWindow(),
                                      otk::OBProperty::net_workarea,
                                      otk::OBProperty::Atom_Cardinal,
-                                     area, 4);
-  /*
-  if (workspacesList.size() > 0) {
-    unsigned long *dims = new unsigned long[4 * workspacesList.size()];
-    for (unsigned int i = 0, m = workspacesList.size(); i < m; ++i) {
-      // XXX: this could be different for each workspace
-      const otk::Rect &area = availableArea();
-      dims[(i * 4) + 0] = area.x();
-      dims[(i * 4) + 1] = area.y();
-      dims[(i * 4) + 2] = area.width();
-      dims[(i * 4) + 3] = area.height();
-    }
-    xatom->set(getRootWindow(), otk::OBProperty::net_workarea,
-               otk::OBProperty::Atom_Cardinal,
-               dims, 4 * workspacesList.size());
-    delete [] dims;
-  } else
-    xatom->set(getRootWindow(), otk::OBProperty::net_workarea,
-               otk::OBProperty::Atom_Cardinal, 0, 0);
-  */
+                                     dims, 4 * _num_desktops);
+  delete [] dims;
 }
 
 
@@ -466,19 +456,21 @@ void OBScreen::manageWindow(Window window)
   XWMHints *wmhint;
   XSetWindowAttributes attrib_set;
 
+  otk::OBDisplay::grab();
+
   // is the window a docking app
   if ((wmhint = XGetWMHints(otk::OBDisplay::display, window))) {
     if ((wmhint->flags & StateHint) &&
         wmhint->initial_state == WithdrawnState) {
       //slit->addClient(w); // XXX: make dock apps work!
+      otk::OBDisplay::ungrab();
+
       XFree(wmhint);
       return;
     }
     XFree(wmhint);
   }
 
-  otk::OBDisplay::grab();
-
   // choose the events we want to receive on the CLIENT window
   attrib_set.event_mask = OBClient::event_mask;
   attrib_set.do_not_propagate_mask = OBClient::no_propagate_mask;
@@ -499,8 +491,12 @@ void OBScreen::manageWindow(Window window)
   // reparented back to root automatically
   XChangeSaveSet(otk::OBDisplay::display, window, SetModeInsert);
 
-  if (!client->positionRequested()) {
-    // XXX: position the window intelligenty
+  if (!(Openbox::instance->state() == Openbox::State_Starting ||
+        client->positionRequested())) {
+    // position the window intelligenty .. hopefully :)
+    // call the python PLACEWINDOW binding
+    EventData data(_number, client, EventPlaceWindow, 0);
+    Openbox::instance->bindings()->fireEvent(&data);
   }
 
   // create the decoration frame for the client window
@@ -519,10 +515,16 @@ void OBScreen::manageWindow(Window window)
   Openbox::instance->addClient(client->frame->grip_left(), client);
   Openbox::instance->addClient(client->frame->grip_right(), client);
 
-  // XXX: if on the current desktop..
-  client->frame->show();
+  // reparent the client to the frame
+  client->frame->grabClient();
+
+  // if on the current desktop.. (or all desktops)
+  if (client->desktop() == _desktop ||
+      client->desktop() == (signed)0xffffffff) {
+    client->frame->show();
+  }
  
-  // XXX: handle any requested states such as shaded/maximized
+  // XXX: handle any requested states such as maximized
 
   otk::OBDisplay::ungrab();
 
@@ -532,9 +534,17 @@ void OBScreen::manageWindow(Window window)
   _stacking.push_back(client);
   restack(true, client);
   // update the root properties
-  setClientList();
+  changeClientList();
 
   Openbox::instance->bindings()->grabButtons(true, client);
+
+  // call the python NEWWINDOW binding
+  EventData data(_number, client, EventNewWindow, 0);
+  Openbox::instance->bindings()->fireEvent(&data);
+
+#ifdef DEBUG
+  printf("Managed window 0x%lx\n", window);
+#endif
 }
 
 
@@ -542,19 +552,11 @@ void OBScreen::unmanageWindow(OBClient *client)
 {
   OBFrame *frame = client->frame;
 
-  Openbox::instance->bindings()->grabButtons(false, client);
+  // call the python CLOSEWINDOW binding 
+  EventData data(_number, client, EventCloseWindow, 0);
+  Openbox::instance->bindings()->fireEvent(&data);
 
-  // remove from the stacking order
-  _stacking.remove(client);
-  
-  // pass around focus if this window was focused XXX do this better!
-  if (Openbox::instance->focusedClient() == client) {
-    OBClient *newfocus = 0;
-    if (!_stacking.empty())
-      newfocus = _stacking.front();
-    if (! (newfocus && newfocus->focus()))
-      client->unfocus();
-  }
+  Openbox::instance->bindings()->grabButtons(false, client);
 
   // remove from the wm's map
   Openbox::instance->removeClient(client->window());
@@ -583,15 +585,29 @@ void OBScreen::unmanageWindow(OBClient *client)
   // give the client its border back
   client->toggleClientBorder(true);
 
+  // reparent the window out of the frame
+  frame->releaseClient();
+
   delete client->frame;
   client->frame = 0;
 
+  // remove from the stacking order
+  _stacking.remove(client);
+
   // remove from the screen's list
   clients.remove(client);
+
+  // unfocus the client (calls the focus callbacks)
+  client->unfocus();
+
+#ifdef DEBUG
+  printf("Unmanaged window 0x%lx\n", client->window());
+#endif
+  
   delete client;
 
   // update the root properties
-  setClientList();
+  changeClientList();
 }
 
 void OBScreen::restack(bool raise, OBClient *client)
@@ -603,7 +619,7 @@ void OBScreen::restack(bool raise, OBClient *client)
 
   // the stacking list is from highest to lowest
   
-  ClientList::iterator it = _stacking.begin(), end = _stacking.end();
+  OBClient::List::iterator it = _stacking.begin(), end = _stacking.end();
   // insert the windows above this window
   for (; it != end; ++it) {
     if ((*it)->layer() < layer || (raise && (*it)->layer() == layer))
@@ -618,7 +634,172 @@ void OBScreen::restack(bool raise, OBClient *client)
     wins.push_back((*it)->frame->window());
 
   XRestackWindows(otk::OBDisplay::display, &wins[0], wins.size());
-  setStackingList();
+  changeStackingList();
+}
+
+void OBScreen::changeDesktop(long desktop)
+{
+  assert(desktop >= 0 && desktop < _num_desktops);
+
+  if (!(desktop >= 0 && desktop < _num_desktops)) return;
+
+  printf("Moving to desktop %ld\n", desktop);
+  
+  long old = _desktop;
+  
+  _desktop = desktop;
+  Openbox::instance->property()->set(_info->rootWindow(),
+                                     otk::OBProperty::net_current_desktop,
+                                     otk::OBProperty::Atom_Cardinal,
+                                     _desktop);
+
+  if (old == _desktop) return;
+
+  OBClient::List::iterator it, end = clients.end();
+  for (it = clients.begin(); it != end; ++it) {
+    if ((*it)->desktop() == old) {
+      (*it)->frame->hide();
+    } else if ((*it)->desktop() == _desktop) {
+      (*it)->frame->show();
+    }
+  }
+
+  // force the callbacks to fire
+  if (!Openbox::instance->focusedClient())
+    Openbox::instance->setFocusedClient(0);
+}
+
+void OBScreen::changeNumDesktops(long num)
+{
+  assert(num > 0);
+  
+  if (!(num > 0)) return;
+
+  // XXX: move windows on desktops that will no longer exist!
+  
+  _num_desktops = num;
+  Openbox::instance->property()->set(_info->rootWindow(),
+                                     otk::OBProperty::net_number_of_desktops,
+                                     otk::OBProperty::Atom_Cardinal,
+                                     _num_desktops);
+
+  // set the viewport hint
+  unsigned long *viewport = new unsigned long[_num_desktops * 2];
+  memset(viewport, 0, sizeof(unsigned long) * _num_desktops * 2);
+  Openbox::instance->property()->set(_info->rootWindow(),
+                                     otk::OBProperty::net_desktop_viewport,
+                                     otk::OBProperty::Atom_Cardinal,
+                                     viewport, _num_desktops * 2);
+  delete [] viewport;
+
+  // update the work area hint
+  changeWorkArea();
 }
 
+
+void OBScreen::updateDesktopNames()
+{
+  const otk::OBProperty *property = Openbox::instance->property();
+
+  unsigned long num = (unsigned) -1;
+  
+  if (!property->get(_info->rootWindow(),
+                     otk::OBProperty::net_desktop_names,
+                     otk::OBProperty::utf8, &num, &_desktop_names))
+    _desktop_names.clear();
+  while ((long)_desktop_names.size() < _num_desktops)
+    _desktop_names.push_back("Unnamed");
+}
+
+
+void OBScreen::setDesktopName(long i, const std::string &name)
+{
+  assert(i >= 0);
+
+  if (i >= _num_desktops) return;
+
+  const otk::OBProperty *property = Openbox::instance->property();
+  
+  otk::OBProperty::StringVect newnames = _desktop_names;
+  newnames[i] = name;
+  property->set(_info->rootWindow(), otk::OBProperty::net_desktop_names,
+                otk::OBProperty::utf8, newnames);
+}
+
+
+void OBScreen::propertyHandler(const XPropertyEvent &e)
+{
+  otk::OtkEventHandler::propertyHandler(e);
+
+  const otk::OBProperty *property = Openbox::instance->property();
+
+  // compress changes to a single property into a single change
+  XEvent ce;
+  while (XCheckTypedEvent(otk::OBDisplay::display, e.type, &ce)) {
+    // XXX: it would be nice to compress ALL changes to a property, not just
+    //      changes in a row without other props between.
+    if (ce.xproperty.atom != e.atom) {
+      XPutBackEvent(otk::OBDisplay::display, &ce);
+      break;
+    }
+  }
+
+  if (e.atom == property->atom(otk::OBProperty::net_desktop_names)) 
+    updateDesktopNames();
+}
+
+
+void OBScreen::clientMessageHandler(const XClientMessageEvent &e)
+{
+  otk::OtkEventHandler::clientMessageHandler(e);
+
+  if (e.format != 32) return;
+
+  const otk::OBProperty *property = Openbox::instance->property();
+
+  if (e.message_type == property->atom(otk::OBProperty::net_current_desktop)) {
+    changeDesktop(e.data.l[0]);
+  } else if (e.message_type ==
+             property->atom(otk::OBProperty::net_number_of_desktops)) {
+    changeNumDesktops(e.data.l[0]);
+  }
+  // XXX: so many client messages to handle here! ..or not.. they go to clients
+}
+
+
+void OBScreen::mapRequestHandler(const XMapRequestEvent &e)
+{
+  otk::OtkEventHandler::mapRequestHandler(e);
+
+#ifdef    DEBUG
+  printf("MapRequest for 0x%lx\n", e.window);
+#endif // DEBUG
+
+  /*
+    MapRequest events come here even after the window exists instead of going
+    right to the client window, because of how they are sent and their struct
+    layout.
+  */
+  OBClient *c = Openbox::instance->findClient(e.window);
+
+  if (c) {
+    // send a net_active_window message
+    XEvent ce;
+    ce.xclient.type = ClientMessage;
+    ce.xclient.message_type =
+      Openbox::instance->property()->atom(otk::OBProperty::net_active_window);
+    ce.xclient.display = otk::OBDisplay::display;
+    ce.xclient.window = c->window();
+    ce.xclient.format = 32;
+    ce.xclient.data.l[0] = 0l;
+    ce.xclient.data.l[1] = 0l;
+    ce.xclient.data.l[2] = 0l;
+    ce.xclient.data.l[3] = 0l;
+    ce.xclient.data.l[4] = 0l;
+    XSendEvent(otk::OBDisplay::display, _info->rootWindow(), false,
+               SubstructureRedirectMask | SubstructureNotifyMask,
+               &ce);
+  } else
+    manageWindow(e.window);
+}
 }