X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fscreen.cc;h=a2514276d8cdb805081849e297cf835ba9f80282;hb=4ef15148365c223b8e810611a10dc27dc5fba355;hp=307404ffce87aa48629f585a7b271100367f8880;hpb=c7b22b4f9cee63d860ad4f6617cd5210299b9d8b;p=chaz%2Fopenbox diff --git a/src/screen.cc b/src/screen.cc index 307404ff..a2514276 100644 --- a/src/screen.cc +++ b/src/screen.cc @@ -1,14 +1,8 @@ // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*- -#ifdef HAVE_CONFIG_H -# include "../config.h" -#endif +#include "config.h" extern "C" { -#ifdef HAVE_STDIO_H -# include -#endif // HAVE_STDIO_H - #ifdef HAVE_UNISTD_H # include # include @@ -25,9 +19,12 @@ extern "C" { #include "bindings.hh" #include "python.hh" #include "otk/display.hh" +#include "otk/property.hh" #include #include +#include +#include static bool running; static int anotherWMRunning(Display *display, XErrorEvent *) { @@ -41,47 +38,40 @@ static int anotherWMRunning(Display *display, XErrorEvent *) { namespace ob { -OBScreen::OBScreen(int screen) - : _number(screen), - _root(screen) +Screen::Screen(int screen) + : _number(screen) { - assert(screen >= 0); assert(screen < ScreenCount(otk::OBDisplay::display)); - _info = otk::OBDisplay::screenInfo(screen); + assert(screen >= 0); assert(screen < ScreenCount(**otk::display)); + _info = otk::display->screenInfo(screen); ::running = false; XErrorHandler old = XSetErrorHandler(::anotherWMRunning); - XSelectInput(otk::OBDisplay::display, _info->rootWindow(), - OBScreen::event_mask); - XSync(otk::OBDisplay::display, false); + XSelectInput(**otk::display, _info->rootWindow(), + Screen::event_mask); + XSync(**otk::display, false); XSetErrorHandler(old); _managed = !::running; if (! _managed) return; // was unable to manage the screen +#ifdef DEBUG printf(_("Managing screen %d: visual 0x%lx, depth %d\n"), _number, XVisualIDFromVisual(_info->visual()), _info->depth()); +#endif - Openbox::instance->property()->set(_info->rootWindow(), - otk::OBProperty::openbox_pid, - otk::OBProperty::Atom_Cardinal, - (unsigned long) getpid()); + otk::Property::set(_info->rootWindow(), otk::Property::atoms.openbox_pid, + otk::Property::atoms.cardinal, (unsigned long) getpid()); // set the mouse cursor for the root window (the default cursor) - XDefineCursor(otk::OBDisplay::display, _info->rootWindow(), - Openbox::instance->cursors().session); - - // initialize the shit that is used for all drawing on the screen - _image_control = new otk::BImageControl(Openbox::instance->timerManager(), - _info, true); - _image_control->installRootColormap(); - _root_cmap_installed = True; - - // initialize the screen's style - _style.setImageControl(_image_control); - std::string stylepath; - python_get_string("theme", &stylepath); + XDefineCursor(**otk::display, _info->rootWindow(), + openbox->cursors().session); + + // XXX: initialize the screen's style + /* + otk::ustring stylepath; + python_get_string("THEME", &stylepath); otk::Configuration sconfig(false); - sconfig.setFile(otk::expandTilde(stylepath)); + sconfig.setFile(otk::expandTilde(stylepath.c_str())); if (!sconfig.load()) { sconfig.setFile(otk::expandTilde(DEFAULTSTYLE)); if (!sconfig.load()) { @@ -90,72 +80,89 @@ OBScreen::OBScreen(int screen) } } _style.load(sconfig); + */ + otk::display->renderControl(_number)-> + drawRoot(*otk::RenderStyle::style(_number)->rootColor()); // 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->rootWindow(), - otk::OBProperty::net_desktop_viewport, - otk::OBProperty::Atom_Cardinal, - viewport, 2); + changeSupportedAtoms(); + + // Set the netwm properties for geometry + unsigned long geometry[] = { _info->size().width(), + _info->size().height() }; + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_desktop_geometry, + otk::Property::atoms.cardinal, geometry, 2); // Set the net_desktop_names property - std::vector names; - python_get_stringlist("desktop_names", &names); - _root.setDesktopNames(names); + std::vector names; + python_get_stringlist("DESKTOP_NAMES", &names); + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_desktop_names, + otk::Property::utf8, names); + // the above set() will cause the updateDesktopNames to fire right away so + // we have a list of desktop names + + _desktop = 0; + if (!python_get_long("NUMBER_OF_DESKTOPS", (long*)&_num_desktops)) + _num_desktops = 1; + changeNumDesktops(_num_desktops); // set the hint + + changeDesktop(0); // set the hint + // create the window which gets focus when no clients get it XSetWindowAttributes attr; attr.override_redirect = true; - _focuswindow = XCreateWindow(otk::OBDisplay::display, _info->rootWindow(), + _focuswindow = XCreateWindow(**otk::display, _info->rootWindow(), -100, -100, 1, 1, 0, 0, InputOnly, _info->visual(), CWOverrideRedirect, &attr); - XMapWindow(otk::OBDisplay::display, _focuswindow); + XMapRaised(**otk::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 - calcArea(); // initialize the available working area + changeClientList(); // initialize the client lists, which will be empty + + // register this class as the event handler for the root window + openbox->registerHandler(_info->rootWindow(), this); + + // call the python Startup callbacks + EventData data(_number, 0, EventAction::Startup, 0); + openbox->bindings()->fireEvent(&data); } -OBScreen::~OBScreen() +Screen::~Screen() { if (! _managed) return; - XSelectInput(otk::OBDisplay::display, _info->rootWindow(), NoEventMask); + XSelectInput(**otk::display, _info->rootWindow(), NoEventMask); // unmanage all windows while (!clients.empty()) unmanageWindow(clients.front()); - XDestroyWindow(otk::OBDisplay::display, _focuswindow); - XDestroyWindow(otk::OBDisplay::display, _supportwindow); + // call the python Shutdown callbacks + EventData data(_number, 0, EventAction::Shutdown, 0); + openbox->bindings()->fireEvent(&data); - delete _image_control; + XDestroyWindow(**otk::display, _focuswindow); + XDestroyWindow(**otk::display, _supportwindow); } -void OBScreen::manageExisting() +void Screen::manageExisting() { unsigned int i, j, nchild; Window r, p, *children; - XQueryTree(otk::OBDisplay::display, _info->rootWindow(), &r, &p, + XQueryTree(**otk::display, _info->rootWindow(), &r, &p, &children, &nchild); // preen the window list of all icon windows... for better dockapp support for (i = 0; i < nchild; i++) { if (children[i] == None) continue; - XWMHints *wmhints = XGetWMHints(otk::OBDisplay::display, + XWMHints *wmhints = XGetWMHints(**otk::display, children[i]); if (wmhints) { @@ -179,7 +186,7 @@ void OBScreen::manageExisting() continue; XWindowAttributes attrib; - if (XGetWindowAttributes(otk::OBDisplay::display, children[i], &attrib)) { + if (XGetWindowAttributes(**otk::display, children[i], &attrib)) { if (attrib.override_redirect) continue; if (attrib.map_state != IsUnmapped) { @@ -192,26 +199,48 @@ void OBScreen::manageExisting() } -void OBScreen::updateStrut() +void Screen::updateStruts() { - _strut.left = _strut.right = _strut.top = _strut.bottom = 0; + struct ApplyStrut { + void operator()(otk::Strut &self, const otk::Strut &other) { + self.left = std::max(self.left, other.left); + self.right = std::max(self.right, other.right); + self.top = std::max(self.top, other.top); + self.bottom = std::max(self.bottom, other.bottom); + } + } apply; + + StrutList::iterator sit, send = _struts.end(); + // reset them all + for (sit = _struts.begin(); sit != send; ++sit) + sit->left = sit->right = sit->top = sit->bottom = 0; - OBClient::List::iterator it, end = clients.end(); + ClientList::const_iterator it, end = clients.end(); for (it = clients.begin(); it != end; ++it) { + if ((*it)->iconic()) continue; // these dont count in the strut + + unsigned int desk = (*it)->desktop(); 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); + + if (desk == 0xffffffff) + for (unsigned int i = 0, e = _struts.size(); i < e; ++i) + apply(_struts[i], s); + else if (desk < _struts.size()) + apply(_struts[desk], s); + else + assert(false); // invalid desktop otherwise.. + // apply to the 'all desktops' strut + apply(_struts.back(), s); } - calcArea(); + changeWorkArea(); } -void OBScreen::calcArea() +void Screen::changeWorkArea() { - otk::Rect old_area = _area; - + unsigned long *dims = new unsigned long[4 * _num_desktops]; + for (unsigned int i = 0; i < _num_desktops + 1; ++i) { + otk::Rect old_area = _area[i]; /* #ifdef XINERAMA // reset to the full areas @@ -220,10 +249,12 @@ void OBScreen::calcArea() #endif // XINERAMA */ - _area.setRect(_strut.left, _strut.top, - _info->width() - (_strut.left + _strut.right), - _info->height() - (_strut.top + _strut.bottom)); - + _area[i] = otk::Rect(_struts[i].left, _struts[i].top, + _info->size().width() - (_struts[i].left + + _struts[i].right), + _info->size().height() - (_struts[i].top + + _struts[i].bottom)); + /* #ifdef XINERAMA if (isXineramaActive()) { @@ -246,114 +277,122 @@ void OBScreen::calcArea() } #endif // XINERAMA */ - - if (old_area != _area) - // XXX: re-maximize windows + if (old_area != _area[i]) { + // the area has changed, adjust all the maximized windows + ClientList::iterator it, end = clients.end(); + for (it = clients.begin(); it != end; ++it) + if (i < _num_desktops) { + if ((*it)->desktop() == i) + (*it)->remaximize(); + } else { + // the 'all desktops' size + if ((*it)->desktop() == 0xffffffff) + (*it)->remaximize(); + } + } - setWorkArea(); + // don't set these for the 'all desktops' area + if (i < _num_desktops) { + dims[(i * 4) + 0] = _area[i].x(); + dims[(i * 4) + 1] = _area[i].y(); + dims[(i * 4) + 2] = _area[i].width(); + dims[(i * 4) + 3] = _area[i].height(); + } + } + otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_workarea, + otk::Property::atoms.cardinal, dims, 4 * _num_desktops); + delete [] dims; } -void OBScreen::setSupportedAtoms() +void Screen::changeSupportedAtoms() { // create the netwm support window - _supportwindow = XCreateSimpleWindow(otk::OBDisplay::display, + _supportwindow = XCreateSimpleWindow(**otk::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); + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_supporting_wm_check, + otk::Property::atoms.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); + otk::Property::set(_supportwindow, otk::Property::atoms.net_wm_name, + otk::Property::utf8, "Openbox"); + otk::Property::set(_supportwindow, + otk::Property::atoms.net_supporting_wm_check, + otk::Property::atoms.window, _supportwindow); Atom supported[] = { + otk::Property::atoms.net_current_desktop, + otk::Property::atoms.net_number_of_desktops, + otk::Property::atoms.net_desktop_geometry, + otk::Property::atoms.net_desktop_viewport, + otk::Property::atoms.net_active_window, + otk::Property::atoms.net_workarea, + otk::Property::atoms.net_client_list, + otk::Property::atoms.net_client_list_stacking, + otk::Property::atoms.net_desktop_names, + otk::Property::atoms.net_close_window, + otk::Property::atoms.net_wm_name, + otk::Property::atoms.net_wm_visible_name, + otk::Property::atoms.net_wm_icon_name, + otk::Property::atoms.net_wm_visible_icon_name, /* - otk::OBProperty::net_current_desktop, - otk::OBProperty::net_number_of_desktops, + otk::Property::atoms.net_wm_desktop, */ - 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::Property::atoms.net_wm_strut, + otk::Property::atoms.net_wm_window_type, + otk::Property::atoms.net_wm_window_type_desktop, + otk::Property::atoms.net_wm_window_type_dock, + otk::Property::atoms.net_wm_window_type_toolbar, + otk::Property::atoms.net_wm_window_type_menu, + otk::Property::atoms.net_wm_window_type_utility, + otk::Property::atoms.net_wm_window_type_splash, + otk::Property::atoms.net_wm_window_type_dialog, + otk::Property::atoms.net_wm_window_type_normal, /* - otk::OBProperty::net_wm_desktop, + otk::Property::atoms.net_wm_moveresize, + otk::Property::atoms.net_wm_moveresize_size_topleft, + otk::Property::atoms.net_wm_moveresize_size_topright, + otk::Property::atoms.net_wm_moveresize_size_bottomleft, + otk::Property::atoms.net_wm_moveresize_size_bottomright, + otk::Property::atoms.net_wm_moveresize_move, */ - 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, - }; + otk::Property::atoms.net_wm_allowed_actions, + otk::Property::atoms.net_wm_action_move, + otk::Property::atoms.net_wm_action_resize, + otk::Property::atoms.net_wm_action_minimize, + otk::Property::atoms.net_wm_action_shade, +/* otk::Property::atoms.net_wm_action_stick,*/ + otk::Property::atoms.net_wm_action_maximize_horz, + otk::Property::atoms.net_wm_action_maximize_vert, + otk::Property::atoms.net_wm_action_fullscreen, + otk::Property::atoms.net_wm_action_change_desktop, + otk::Property::atoms.net_wm_action_close, + + otk::Property::atoms.net_wm_state, + otk::Property::atoms.net_wm_state_modal, + otk::Property::atoms.net_wm_state_maximized_vert, + otk::Property::atoms.net_wm_state_maximized_horz, + otk::Property::atoms.net_wm_state_shaded, + otk::Property::atoms.net_wm_state_skip_taskbar, + otk::Property::atoms.net_wm_state_skip_pager, + otk::Property::atoms.net_wm_state_hidden, + otk::Property::atoms.net_wm_state_fullscreen, + otk::Property::atoms.net_wm_state_above, + otk::Property::atoms.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); + otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_supported, + otk::Property::atoms.atom, supported, num_supported); } -void OBScreen::setClientList() +void Screen::changeClientList() { Window *windows; unsigned int size = clients.size(); @@ -364,26 +403,24 @@ void OBScreen::setClientList() windows = new Window[size]; win_it = windows; - OBClient::List::const_iterator it = clients.begin(); - const OBClient::List::const_iterator end = clients.end(); + ClientList::const_iterator it = clients.begin(); + const ClientList::const_iterator end = clients.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, - otk::OBProperty::Atom_Window, - windows, size); + otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_client_list, + otk::Property::atoms.window, windows, size); if (size) delete [] windows; - setStackingList(); + changeStackingList(); } -void OBScreen::setStackingList() +void Screen::changeStackingList() { Window *windows; unsigned int size = _stacking.size(); @@ -391,235 +428,446 @@ void OBScreen::setStackingList() assert(size == clients.size()); // just making sure.. :) - // create an array of the window ids + // create an array of the window ids (from bottom to top, reverse order!) 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(); + ClientList::const_reverse_iterator it = _stacking.rbegin(); + const ClientList::const_reverse_iterator end = _stacking.rend(); 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, - windows, size); + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_client_list_stacking, + otk::Property::atoms.window, 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->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); - */ -} - - -void OBScreen::manageWindow(Window window) +void Screen::manageWindow(Window window) { - OBClient *client = 0; + Client *client = 0; XWMHints *wmhint; XSetWindowAttributes attrib_set; + XEvent e; + XWindowAttributes attrib; + + otk::display->grab(); + // check if it has already been unmapped by the time we started mapping + // the grab does a sync so we don't have to here + if (XCheckTypedWindowEvent(**otk::display, window, DestroyNotify, &e) || + XCheckTypedWindowEvent(**otk::display, window, UnmapNotify, &e)) { + XPutBackEvent(**otk::display, &e); + + otk::display->ungrab(); + return; // don't manage it + } + + if (!XGetWindowAttributes(**otk::display, window, &attrib) || + attrib.override_redirect) { + otk::display->ungrab(); + return; // don't manage it + } + // is the window a docking app - if ((wmhint = XGetWMHints(otk::OBDisplay::display, window))) { + if ((wmhint = XGetWMHints(**otk::display, window))) { if ((wmhint->flags & StateHint) && wmhint->initial_state == WithdrawnState) { //slit->addClient(w); // XXX: make dock apps work! + + otk::display->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; - XChangeWindowAttributes(otk::OBDisplay::display, window, + attrib_set.event_mask = Client::event_mask; + attrib_set.do_not_propagate_mask = Client::no_propagate_mask; + XChangeWindowAttributes(**otk::display, window, CWEventMask|CWDontPropagate, &attrib_set); - // create the OBClient class, which gets all of the hints on the window - client = new OBClient(_number, window); + // create the Client class, which gets all of the hints on the window + client = new Client(_number, window); // register for events - Openbox::instance->registerHandler(window, client); + openbox->registerHandler(window, client); // add to the wm's map - Openbox::instance->addClient(window, client); + openbox->addClient(window, client); // we dont want a border on the client client->toggleClientBorder(false); // specify that if we exit, the window should not be destroyed and should be // reparented back to root automatically - XChangeSaveSet(otk::OBDisplay::display, window, SetModeInsert); - - if (!client->positionRequested()) { - // XXX: position the window intelligenty - } + XChangeSaveSet(**otk::display, window, SetModeInsert); // create the decoration frame for the client window - client->frame = new OBFrame(client, &_style); + client->frame = new Frame(client); + // register the plate for events (map req's) + // this involves removing itself from the handler list first, since it is + // auto added to the list, being a widget. we won't get any events on the + // plate except for events for the client (SubstructureRedirectMask) + openbox->clearHandler(client->frame->plate()); + openbox->registerHandler(client->frame->plate(), client); // add to the wm's map - 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); - Openbox::instance->addClient(client->frame->button_max(), client); - Openbox::instance->addClient(client->frame->button_iconify(), client); - Openbox::instance->addClient(client->frame->button_stick(), client); - Openbox::instance->addClient(client->frame->button_close(), client); - Openbox::instance->addClient(client->frame->handle(), client); - 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(); - - // XXX: handle any requested states such as maximized - - otk::OBDisplay::ungrab(); + Window *w = client->frame->allWindows(); + for (unsigned int i = 0; w[i]; ++i) + openbox->addClient(w[i], client); + delete [] w; + + // reparent the client to the frame + client->frame->grabClient(); + + if (openbox->state() != Openbox::State_Starting) { + // position the window intelligenty .. hopefully :) + // call the python PLACEWINDOW binding + EventData data(_number, client, EventAction::PlaceWindow, 0); + openbox->bindings()->fireEvent(&data); + } + + EventData ddata(_number, client, EventAction::DisplayingWindow, 0); + openbox->bindings()->fireEvent(&ddata); + + client->showhide(); + + client->applyStartupState(); + + otk::display->ungrab(); // add to the screen's list clients.push_back(client); + // once the client is in the list, update our strut to include the new + // client's (it is good that this happens after window placement!) + updateStruts(); // this puts into the stacking order, then raises it _stacking.push_back(client); - restack(true, client); + raiseWindow(client); // update the root properties - setClientList(); + changeClientList(); - Openbox::instance->bindings()->grabButtons(true, client); + openbox->bindings()->grabButtons(true, client); - // XXX: make this optional or more intelligent - if (client->normal()) - client->focus(); + EventData ndata(_number, client, EventAction::NewWindow, 0); + openbox->bindings()->fireEvent(&ndata); - // call the python NEWWINDOW binding - EventData *data = new_event_data(window, EventNewWindow, 0); - Openbox::instance->bindings()->fireEvent(data); - Py_DECREF((PyObject*)data); +#ifdef DEBUG + printf("Managed window 0x%lx frame 0x%lx\n", + window, client->frame->window()); +#endif } -void OBScreen::unmanageWindow(OBClient *client) +void Screen::unmanageWindow(Client *client) { - OBFrame *frame = client->frame; + Frame *frame = client->frame; // 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); + EventData data(_number, client, EventAction::CloseWindow, 0); + openbox->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; - 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(); - } + openbox->bindings()->grabButtons(false, client); // remove from the wm's map - Openbox::instance->removeClient(client->window()); - Openbox::instance->removeClient(frame->window()); - Openbox::instance->removeClient(frame->plate()); - Openbox::instance->removeClient(frame->titlebar()); - Openbox::instance->removeClient(frame->label()); - Openbox::instance->removeClient(frame->button_max()); - Openbox::instance->removeClient(frame->button_iconify()); - Openbox::instance->removeClient(frame->button_stick()); - Openbox::instance->removeClient(frame->button_close()); - Openbox::instance->removeClient(frame->handle()); - Openbox::instance->removeClient(frame->grip_left()); - Openbox::instance->removeClient(frame->grip_right()); + openbox->removeClient(client->window()); + Window *w = frame->allWindows(); + for (unsigned int i = 0; w[i]; ++i) + openbox->addClient(w[i], client); + delete [] w; // unregister for handling events - Openbox::instance->clearHandler(client->window()); + openbox->clearHandler(client->window()); // remove the window from our save set - XChangeSaveSet(otk::OBDisplay::display, client->window(), SetModeDelete); + XChangeSaveSet(**otk::display, client->window(), SetModeDelete); // we dont want events no more - XSelectInput(otk::OBDisplay::display, client->window(), NoEventMask); + XSelectInput(**otk::display, client->window(), NoEventMask); frame->hide(); // give the client its border back client->toggleClientBorder(true); + // reparent the window out of the frame + frame->releaseClient(); + +#ifdef DEBUG + Window framewin = client->frame->window(); +#endif delete client->frame; client->frame = 0; + // remove from the stacking order + _stacking.remove(client); + // remove from the screen's list clients.remove(client); + + // once the client is out of the list, update our strut to remove it's + // influence + updateStruts(); + + // unset modal before dropping our focus + client->_modal = false; + + // unfocus the client (calls the focus callbacks) + client->unfocus(); + +#ifdef DEBUG + printf("Unmanaged window 0x%lx frame 0x%lx\n", client->window(), framewin); +#endif + delete client; // update the root properties - setClientList(); + changeClientList(); } -void OBScreen::restack(bool raise, OBClient *client) +void Screen::lowerWindow(Client *client) { - const int layer = client->layer(); - std::vector wins; + Window wins[2]; // only ever restack 2 windows. + + assert(!_stacking.empty()); // this would be bad + + ClientList::iterator it = --_stacking.end(); + const ClientList::iterator end = _stacking.begin(); + + if (client->modal() && client->transientFor()) { + // don't let a modal window lower below its transient_for + it = std::find(_stacking.begin(), _stacking.end(), client->transientFor()); + assert(it != _stacking.end()); + + wins[0] = (it == _stacking.begin() ? _focuswindow : + ((*(--ClientList::const_iterator(it)))->frame->window())); + wins[1] = client->frame->window(); + if (wins[0] == wins[1]) return; // already right above the window + _stacking.remove(client); + _stacking.insert(it, client); + } else { + for (; it != end && (*it)->layer() < client->layer(); --it); + if (*it == client) return; // already the bottom, return + + wins[0] = (*it)->frame->window(); + wins[1] = client->frame->window(); + + _stacking.remove(client); + _stacking.insert(++it, client); + } + + XRestackWindows(**otk::display, wins, 2); + changeStackingList(); +} + +void Screen::raiseWindow(Client *client) +{ + Window wins[2]; // only ever restack 2 windows. + + assert(!_stacking.empty()); // this would be bad + + Client *m = client->findModalChild(); + // if we have a modal child, raise it instead, we'll go along tho later + if (m) raiseWindow(m); + + // remove the client before looking so we can't run into ourselves _stacking.remove(client); + + ClientList::iterator it = _stacking.begin(); + const ClientList::iterator end = _stacking.end(); // the stacking list is from highest to lowest +// for (;it != end, ++it) { +// if ((*it)->layer() <= client->layer() && m != *it) break; +// } + for (; it != end && ((*it)->layer() > client->layer() || m == *it); ++it); + + /* + if our new position is the top, we want to stack under the _focuswindow + otherwise, we want to stack under the previous window in the stack. + */ + wins[0] = (it == _stacking.begin() ? _focuswindow : + ((*(--ClientList::const_iterator(it)))->frame->window())); + wins[1] = client->frame->window(); + + _stacking.insert(it, client); + + XRestackWindows(**otk::display, wins, 2); + + changeStackingList(); +} + +void Screen::changeDesktop(unsigned int desktop) +{ + if (desktop >= _num_desktops) return; + + printf("Moving to desktop %u\n", desktop); + + unsigned int old = _desktop; + + _desktop = desktop; + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_current_desktop, + otk::Property::atoms.cardinal, _desktop); + + if (old == _desktop) return; + + ClientList::iterator it, end = clients.end(); + for (it = clients.begin(); it != end; ++it) + (*it)->showhide(); + + // force the callbacks to fire + if (!openbox->focusedClient()) + openbox->setFocusedClient(0); +} + +void Screen::changeNumDesktops(unsigned int num) +{ + assert(num > 0); + + if (!(num > 0)) return; + + // move windows on desktops that will no longer exist! + ClientList::iterator it, end = clients.end(); + for (it = clients.begin(); it != end; ++it) { + unsigned int d = (*it)->desktop(); + if (d >= num && d != 0xffffffff) { + XEvent ce; + ce.xclient.type = ClientMessage; + ce.xclient.message_type = otk::Property::atoms.net_wm_desktop; + ce.xclient.display = **otk::display; + ce.xclient.window = (*it)->window(); + ce.xclient.format = 32; + ce.xclient.data.l[0] = num - 1; + XSendEvent(**otk::display, _info->rootWindow(), False, + SubstructureNotifyMask | SubstructureRedirectMask, &ce); + } + } + + _num_desktops = num; + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_number_of_desktops, + otk::Property::atoms.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); + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_desktop_viewport, + otk::Property::atoms.cardinal, + viewport, _num_desktops * 2); + delete [] viewport; + + // change our struts/area to match + _area.resize(_num_desktops + 1); + _struts.resize(_num_desktops + 1); + updateStruts(); + + // change our desktop if we're on one that no longer exists! + if (_desktop >= _num_desktops) + changeDesktop(_num_desktops - 1); +} + + +void Screen::updateDesktopNames() +{ + unsigned long num = (unsigned) -1; - 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)) + if (!otk::Property::get(_info->rootWindow(), + otk::Property::atoms.net_desktop_names, + otk::Property::utf8, &num, &_desktop_names)) + _desktop_names.clear(); + while (_desktop_names.size() < _num_desktops) + _desktop_names.push_back("Unnamed"); +} + + +void Screen::setDesktopName(unsigned int i, const otk::ustring &name) +{ + if (i >= _num_desktops) return; + + otk::Property::StringVect newnames = _desktop_names; + newnames[i] = name; + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_desktop_names, + otk::Property::utf8, newnames); +} + + +const otk::Rect& Screen::area(unsigned int desktop) const { + assert(desktop < _num_desktops || desktop == 0xffffffff); + if (desktop < _num_desktops) + return _area[desktop]; + else + return _area[_num_desktops]; +} + +void Screen::installColormap(bool install) const +{ + if (install) + XInstallColormap(**otk::display, _info->colormap()); + else + XUninstallColormap(**otk::display, _info->colormap()); +} + + +void Screen::propertyHandler(const XPropertyEvent &e) +{ + otk::EventHandler::propertyHandler(e); + + // compress changes to a single property into a single change + XEvent ce; + while (XCheckTypedWindowEvent(**otk::display, _info->rootWindow(), + 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::display, &ce); 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(); + if (e.atom == otk::Property::atoms.net_desktop_names) + updateDesktopNames(); +} + + +void Screen::clientMessageHandler(const XClientMessageEvent &e) +{ + otk::EventHandler::clientMessageHandler(e); + + if (e.format != 32) return; + + if (e.message_type == otk::Property::atoms.net_current_desktop) { + changeDesktop(e.data.l[0]); + } else if (e.message_type == otk::Property::atoms.net_number_of_desktops) { + changeNumDesktops(e.data.l[0]); + } +} + + +void Screen::mapRequestHandler(const XMapRequestEvent &e) +{ + otk::EventHandler::mapRequestHandler(e); + +#ifdef DEBUG + printf("MapRequest for 0x%lx\n", e.window); +#endif // DEBUG + + Client *c = openbox->findClient(e.window); + if (c) { +#ifdef DEBUG + printf("DEBUG: MAP REQUEST CAUGHT IN SCREEN. IGNORED.\n"); +#endif + } else + manageWindow(e.window); } }