#include "client.hh"
#include "openbox.hh"
#include "frame.hh"
+#include "bindings.hh"
+#include "python.hh"
#include "otk/display.hh"
+#include <vector>
+#include <algorithm>
+
static bool running;
static int anotherWMRunning(Display *display, XErrorEvent *) {
printf(_("Another window manager already running on display %s.\n"),
namespace ob {
-OBScreen::OBScreen(int screen, const otk::Configuration &config)
+OBScreen::OBScreen(int screen)
: _number(screen),
_root(screen)
{
::running = false;
XErrorHandler old = XSetErrorHandler(::anotherWMRunning);
- XSelectInput(otk::OBDisplay::display, _info->getRootWindow(),
+ XSelectInput(otk::OBDisplay::display, _info->rootWindow(),
OBScreen::event_mask);
XSync(otk::OBDisplay::display, false);
XSetErrorHandler(old);
if (! _managed) return; // was unable to manage the screen
printf(_("Managing screen %d: visual 0x%lx, depth %d\n"),
- _number, XVisualIDFromVisual(_info->getVisual()), _info->getDepth());
+ _number, XVisualIDFromVisual(_info->visual()), _info->depth());
- Openbox::instance->property()->set(_info->getRootWindow(),
+ Openbox::instance->property()->set(_info->rootWindow(),
otk::OBProperty::openbox_pid,
otk::OBProperty::Atom_Cardinal,
(unsigned long) getpid());
// set the mouse cursor for the root window (the default cursor)
- XDefineCursor(otk::OBDisplay::display, _info->getRootWindow(),
+ XDefineCursor(otk::OBDisplay::display, _info->rootWindow(),
Openbox::instance->cursors().session);
// initialize the shit that is used for all drawing on the screen
// initialize the screen's style
_style.setImageControl(_image_control);
- _style.load(config);
+ std::string stylepath;
+ python_get_string("theme", &stylepath);
+ otk::Configuration sconfig(false);
+ sconfig.setFile(otk::expandTilde(stylepath));
+ if (!sconfig.load()) {
+ sconfig.setFile(otk::expandTilde(DEFAULTSTYLE));
+ if (!sconfig.load()) {
+ printf(_("Unable to load default style: %s. Aborting.\n"), DEFAULTSTYLE);
+ ::exit(1);
+ }
+ }
+ _style.load(sconfig);
-
- // Set the netwm atoms for geomtery and viewport
- unsigned long geometry[] = { _info->getWidth(),
- _info->getHeight() };
- Openbox::instance->property()->set(_info->getRootWindow(),
+ // set up notification of netwm support
+ setSupportedAtoms();
+
+ // Set the netwm properties for geometry and viewport
+ 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 };
- Openbox::instance->property()->set(_info->getRootWindow(),
+ Openbox::instance->property()->set(_info->rootWindow(),
otk::OBProperty::net_desktop_viewport,
otk::OBProperty::Atom_Cardinal,
viewport, 2);
+ // Set the net_desktop_names property
+ std::vector<std::string> names;
+ python_get_stringlist("desktop_names", &names);
+ _root.setDesktopNames(names);
+
+ // create the window which gets focus when no clients get it
+ XSetWindowAttributes attr;
+ attr.override_redirect = true;
+ _focuswindow = XCreateWindow(otk::OBDisplay::display, _info->rootWindow(),
+ -100, -100, 1, 1, 0, 0, InputOnly,
+ _info->visual(), CWOverrideRedirect, &attr);
+ XMapWindow(otk::OBDisplay::display, _focuswindow);
+
// 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
{
if (! _managed) return;
+ XSelectInput(otk::OBDisplay::display, _info->rootWindow(), NoEventMask);
+
// unmanage all windows
- while (!_clients.empty())
- unmanageWindow(_clients.front());
+ while (!clients.empty())
+ unmanageWindow(clients.front());
+
+ XDestroyWindow(otk::OBDisplay::display, _focuswindow);
+ XDestroyWindow(otk::OBDisplay::display, _supportwindow);
delete _image_control;
}
{
unsigned int i, j, nchild;
Window r, p, *children;
- XQueryTree(otk::OBDisplay::display, _info->getRootWindow(), &r, &p,
+ XQueryTree(otk::OBDisplay::display, _info->rootWindow(), &r, &p,
&children, &nchild);
// preen the window list of all icon windows... for better dockapp support
}
-//! 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();
}
#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->getWidth() - (current_left + current_right),
- _info->getHeight() - (current_top + current_bottom));
+ _area.setRect(_strut.left, _strut.top,
+ _info->width() - (_strut.left + _strut.right),
+ _info->height() - (_strut.top + _strut.bottom));
/*
#ifdef XINERAMA
}
+void OBScreen::setSupportedAtoms()
+{
+ // 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(),
+ otk::OBProperty::net_supporting_wm_check,
+ otk::OBProperty::Atom_Window,
+ _supportwindow);
+
+ //set properties on the supporting window
+ Openbox::instance->property()->set(_supportwindow,
+ otk::OBProperty::net_wm_name,
+ otk::OBProperty::utf8,
+ "Openbox");
+ Openbox::instance->property()->set(_supportwindow,
+ otk::OBProperty::net_supporting_wm_check,
+ otk::OBProperty::Atom_Window,
+ _supportwindow);
+
+
+ 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,
+ otk::OBProperty::net_wm_icon_name,
+ otk::OBProperty::net_wm_visible_icon_name,
+/*
+ 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,
+ otk::OBProperty::net_wm_window_type_toolbar,
+ otk::OBProperty::net_wm_window_type_menu,
+ otk::OBProperty::net_wm_window_type_utility,
+ otk::OBProperty::net_wm_window_type_splash,
+ otk::OBProperty::net_wm_window_type_dialog,
+ otk::OBProperty::net_wm_window_type_normal,
+/*
+ otk::OBProperty::net_wm_moveresize,
+ otk::OBProperty::net_wm_moveresize_size_topleft,
+ otk::OBProperty::net_wm_moveresize_size_topright,
+ otk::OBProperty::net_wm_moveresize_size_bottomleft,
+ otk::OBProperty::net_wm_moveresize_size_bottomright,
+ otk::OBProperty::net_wm_moveresize_move,
+*/
+/*
+ otk::OBProperty::net_wm_allowed_actions,
+ otk::OBProperty::net_wm_action_move,
+ otk::OBProperty::net_wm_action_resize,
+ otk::OBProperty::net_wm_action_shade,
+ otk::OBProperty::net_wm_action_maximize_horz,
+ otk::OBProperty::net_wm_action_maximize_vert,
+ otk::OBProperty::net_wm_action_change_desktop,
+ otk::OBProperty::net_wm_action_close,
+*/
+ otk::OBProperty::net_wm_state,
+ otk::OBProperty::net_wm_state_modal,
+ otk::OBProperty::net_wm_state_maximized_vert,
+ otk::OBProperty::net_wm_state_maximized_horz,
+ otk::OBProperty::net_wm_state_shaded,
+ otk::OBProperty::net_wm_state_skip_taskbar,
+ otk::OBProperty::net_wm_state_skip_pager,
+ otk::OBProperty::net_wm_state_hidden,
+ otk::OBProperty::net_wm_state_fullscreen,
+ otk::OBProperty::net_wm_state_above,
+ otk::OBProperty::net_wm_state_below,
+ };
+ const int num_supported = sizeof(supported)/sizeof(Atom);
+
+ // convert to the atom values
+ for (int i = 0; i < num_supported; ++i)
+ supported[i] =
+ Openbox::instance->property()->atom((otk::OBProperty::Atoms)supported[i]);
+
+ Openbox::instance->property()->set(_info->rootWindow(),
+ otk::OBProperty::net_supported,
+ otk::OBProperty::Atom_Atom,
+ supported, num_supported);
+}
+
+
void OBScreen::setClientList()
{
Window *windows;
+ unsigned int size = clients.size();
// create an array of the window ids
- if (_clients.size() > 0) {
+ if (size > 0) {
Window *win_it;
- windows = new Window[_clients.size()];
+ 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
windows = (Window*) 0;
- Openbox::instance->property()->set(_info->getRootWindow(),
+ Openbox::instance->property()->set(_info->rootWindow(),
otk::OBProperty::net_client_list,
otk::OBProperty::Atom_Window,
- windows, _clients.size());
+ windows, size);
- if (_clients.size())
+ if (size)
delete [] windows;
setStackingList();
void OBScreen::setStackingList()
{
- // The below comment is wrong now hopefully :> but ill keep it here for
- // reference anyways
- /*
- Get the stacking order from all of the workspaces.
- We start with the current workspace so that the sticky windows will be
- in the right order on the current workspace.
- */
- /*
- Openbox::instance->property()->set(_info->getRootWindow(),
+ Window *windows;
+ unsigned int size = _stacking.size();
+
+ assert(size == clients.size()); // just making sure.. :)
+
+
+ // create an array of the window ids
+ if (size > 0) {
+ Window *win_it;
+
+ windows = new Window[size];
+ win_it = windows;
+ 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
+ windows = (Window*) 0;
+
+ Openbox::instance->property()->set(_info->rootWindow(),
otk::OBProperty::net_client_list_stacking,
otk::OBProperty::Atom_Window,
- _stacking, _stacking.size());
- */
+ windows, size);
+
+ if (size)
+ delete [] windows;
}
void OBScreen::setWorkArea() {
unsigned long area[] = { _area.x(), _area.y(),
_area.width(), _area.height() };
- Openbox::instance->property()->set(_info->getRootWindow(),
+ Openbox::instance->property()->set(_info->rootWindow(),
otk::OBProperty::net_workarea,
otk::OBProperty::Atom_Cardinal,
area, 4);
}
-void OBScreen::loadStyle(const otk::Configuration &config)
-{
- _style.load(config);
-
- // XXX: make stuff redraw!
-}
-
-
void OBScreen::manageWindow(Window window)
{
OBClient *client = 0;
// choose the events we want to receive on the CLIENT window
attrib_set.event_mask = OBClient::event_mask;
- attrib_set.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask |
- ButtonMotionMask;
+ attrib_set.do_not_propagate_mask = OBClient::no_propagate_mask;
XChangeWindowAttributes(otk::OBDisplay::display, window,
CWEventMask|CWDontPropagate, &attrib_set);
client->frame = new OBFrame(client, &_style);
// add to the wm's map
- Openbox::instance->addClient(client->frame->getWindow(), client);
+ Openbox::instance->addClient(client->frame->window(), client);
Openbox::instance->addClient(client->frame->plate(), client);
Openbox::instance->addClient(client->frame->titlebar(), client);
Openbox::instance->addClient(client->frame->label(), client);
// XXX: if on the current desktop..
client->frame->show();
- // XXX: handle any requested states such as shaded/maximized
+ // XXX: handle any requested states such as maximized
otk::OBDisplay::ungrab();
// add to the screen's list
- _clients.push_back(client);
+ clients.push_back(client);
+ // this puts into the stacking order, then raises it
+ _stacking.push_back(client);
+ restack(true, client);
// update the root properties
setClientList();
+
+ Openbox::instance->bindings()->grabButtons(true, client);
+
+ // XXX: make this optional or more intelligent
+ if (client->normal())
+ client->focus();
+
+ // call the python NEWWINDOW binding
+ EventData *data = new_event_data(window, EventNewWindow, 0);
+ Openbox::instance->bindings()->fireEvent(data);
+ Py_DECREF((PyObject*)data);
}
{
OBFrame *frame = client->frame;
- // XXX: pass around focus if this window was focused
+ // call the python CLOSEWINDOW binding
+ EventData *data = new_event_data(client->window(), EventCloseWindow, 0);
+ Openbox::instance->bindings()->fireEvent(data);
+ Py_DECREF((PyObject*)data);
+
+ Openbox::instance->bindings()->grabButtons(false, client);
+
+ // 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;
+ OBClient::List::iterator it, end = _stacking.end();
+ for (it = _stacking.begin(); it != end; ++it)
+ if ((*it)->normal() && (*it)->focus()) {
+ newfocus = *it;
+ break;
+ }
+ if (!newfocus)
+ client->unfocus();
+ }
// remove from the wm's map
Openbox::instance->removeClient(client->window());
- Openbox::instance->removeClient(frame->getWindow());
+ Openbox::instance->removeClient(frame->window());
Openbox::instance->removeClient(frame->plate());
Openbox::instance->removeClient(frame->titlebar());
Openbox::instance->removeClient(frame->label());
client->frame = 0;
// remove from the screen's list
- _clients.remove(client);
+ clients.remove(client);
delete client;
// update the root properties
setClientList();
}
+void OBScreen::restack(bool raise, OBClient *client)
+{
+ const int layer = client->layer();
+ std::vector<Window> wins;
+
+ _stacking.remove(client);
+
+ // the stacking list is from highest to lowest
+
+ 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))
+ break;
+ wins.push_back((*it)->frame->window());
+ }
+ // insert our client
+ wins.push_back(client->frame->window());
+ _stacking.insert(it, client);
+ // insert the remaining below this window
+ for (; it != end; ++it)
+ wins.push_back((*it)->frame->window());
+
+ XRestackWindows(otk::OBDisplay::display, &wins[0], wins.size());
+ setStackingList();
+}
+
}