X-Git-Url: https://git.brokenzipper.com/gitweb?a=blobdiff_plain;f=src%2Fscreen.cc;h=fcbe2ea6a4991dae3115e0b7f97ae9af84fa77bf;hb=8d5bd298540b98eb10072c5ee281c64f221ce9a6;hp=845014a9968756b990316ed5a910bda54ed0056f;hpb=c220fbc95308dfe5dd014c333afe86b65d0ded05;p=chaz%2Fopenbox diff --git a/src/screen.cc b/src/screen.cc index 845014a9..fcbe2ea6 100644 --- a/src/screen.cc +++ b/src/screen.cc @@ -9,6 +9,11 @@ extern "C" { # include #endif // HAVE_STDIO_H +#ifdef HAVE_UNISTD_H +# include +# include +#endif // HAVE_UNISTD_H + #include "gettext.h" #define _(str) gettext(str) } @@ -16,8 +21,13 @@ extern "C" { #include "screen.hh" #include "client.hh" #include "openbox.hh" +#include "frame.hh" +#include "bindings.hh" +#include "python.hh" #include "otk/display.hh" +#include + static bool running; static int anotherWMRunning(Display *display, XErrorEvent *) { printf(_("Another window manager already running on display %s.\n"), @@ -31,14 +41,15 @@ namespace ob { OBScreen::OBScreen(int screen) - : _number(screen) + : _number(screen), + _root(screen) { assert(screen >= 0); assert(screen < ScreenCount(otk::OBDisplay::display)); _info = otk::OBDisplay::screenInfo(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); @@ -47,46 +58,71 @@ OBScreen::OBScreen(int screen) 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()); -#ifdef HAVE_GETPID - Openbox::instance->property()->set(_info->getRootWindow(), + Openbox::instance->property()->set(_info->rootWindow(), otk::OBProperty::openbox_pid, otk::OBProperty::Atom_Cardinal, (unsigned long) getpid()); -#endif // HAVE_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 _image_control = new otk::BImageControl(Openbox::instance->timerManager(), _info, true); _image_control->installRootColormap(); _root_cmap_installed = True; - - // Set the netwm atoms for geomtery and viewport - unsigned long geometry[] = { _size.x(), - _size.y() }; - Openbox::instance->property()->set(_info->getRootWindow(), + // initialize the screen's style + _style.setImageControl(_image_control); + 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 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 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 calcArea(); // initialize the available working area - - manageExisting(); - - // XXX: "change to" the first workspace to initialize stuff } @@ -94,6 +130,15 @@ OBScreen::~OBScreen() { if (! _managed) return; + XSelectInput(otk::OBDisplay::display, _info->rootWindow(), NoEventMask); + + // unmanage all windows + while (!clients.empty()) + unmanageWindow(clients.front()); + + XDestroyWindow(otk::OBDisplay::display, _focuswindow); + XDestroyWindow(otk::OBDisplay::display, _supportwindow); + delete _image_control; } @@ -102,7 +147,7 @@ void OBScreen::manageExisting() { 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 @@ -137,7 +182,7 @@ void OBScreen::manageExisting() if (attrib.override_redirect) continue; if (attrib.map_state != IsUnmapped) { - // XXX: manageWindow(children[i]); + manageWindow(children[i]); } } } @@ -195,8 +240,8 @@ void OBScreen::calcArea() } _area.setRect(current_left, current_top, - _info->getWidth() - (current_left + current_right), - _info->getHeight() - (current_top + current_bottom)); + _info->width() - (current_left + current_right), + _info->height() - (current_top + current_bottom)); /* #ifdef XINERAMA @@ -228,29 +273,131 @@ void OBScreen::calcArea() } +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(); + 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->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(); @@ -259,26 +406,39 @@ void OBScreen::setClientList() 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; + ClientList::const_iterator it = _stacking.begin(); + const ClientList::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); @@ -304,4 +464,165 @@ void OBScreen::setWorkArea() { } +void OBScreen::manageWindow(Window window) +{ + OBClient *client = 0; + XWMHints *wmhint; + XSetWindowAttributes attrib_set; + + // 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! + 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, + CWEventMask|CWDontPropagate, &attrib_set); + + // create the OBClient class, which gets all of the hints on the window + client = new OBClient(_number, window); + // register for events + Openbox::instance->registerHandler(window, client); + // add to the wm's map + Openbox::instance->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 + } + + // create the decoration frame for the client window + client->frame = new OBFrame(client, &_style); + + // 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 shaded/maximized + + otk::OBDisplay::ungrab(); + + // add to the screen's list + 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); +} + + +void OBScreen::unmanageWindow(OBClient *client) +{ + OBFrame *frame = client->frame; + + 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; + if (!_stacking.empty()) + newfocus = _stacking.front(); + if (! (newfocus && newfocus->focus())) + client->unfocus(); + } + + // 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()); + // unregister for handling events + Openbox::instance->clearHandler(client->window()); + + // remove the window from our save set + XChangeSaveSet(otk::OBDisplay::display, client->window(), SetModeDelete); + + // we dont want events no more + XSelectInput(otk::OBDisplay::display, client->window(), NoEventMask); + + frame->hide(); + + // give the client its border back + client->toggleClientBorder(true); + + delete client->frame; + client->frame = 0; + + // remove from the screen's list + clients.remove(client); + delete client; + + // update the root properties + setClientList(); +} + +void OBScreen::restack(bool raise, OBClient *client) +{ + const int layer = client->layer(); + std::vector wins; + + _stacking.remove(client); + + // the stacking list is from highest to lowest + + ClientList::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(); +} + }