X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Fscreen.cc;h=b0c071a9a73fee17bc36f45bc1ea717c739a5fe1;hb=668b2866c29c12695393a15a713a38187ac17e4c;hp=2ccc35f062656acf2c8d1f20752446b7fa3d63a8;hpb=77ab46d1e35d48e73c201e6de88b26f48bb06425;p=chaz%2Fopenbox diff --git a/src/screen.cc b/src/screen.cc index 2ccc35f0..b0c071a9 100644 --- a/src/screen.cc +++ b/src/screen.cc @@ -29,6 +29,7 @@ extern "C" { #include "bindings.hh" #include "python.hh" #include "otk/display.hh" +#include "otk/property.hh" #include #include @@ -47,16 +48,17 @@ namespace ob { Screen::Screen(int screen) : WidgetBase(WidgetBase::Type_Root), - _number(screen) + _number(screen), + _style(screen, "") { - assert(screen >= 0); assert(screen < ScreenCount(otk::Display::display)); - _info = otk::Display::screenInfo(screen); + assert(screen >= 0); assert(screen < ScreenCount(**otk::display)); + _info = otk::display->screenInfo(screen); ::running = false; XErrorHandler old = XSetErrorHandler(::anotherWMRunning); - XSelectInput(otk::Display::display, _info->rootWindow(), + XSelectInput(**otk::display, _info->rootWindow(), Screen::event_mask); - XSync(otk::Display::display, false); + XSync(**otk::display, false); XSetErrorHandler(old); _managed = !::running; @@ -65,27 +67,19 @@ Screen::Screen(int screen) printf(_("Managing screen %d: visual 0x%lx, depth %d\n"), _number, XVisualIDFromVisual(_info->visual()), _info->depth()); - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::openbox_pid, - otk::Property::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::Display::display, _info->rootWindow(), - Openbox::instance->cursors().session); - - // initialize the shit that is used for all drawing on the screen - _image_control = new otk::ImageControl(Openbox::instance->timerManager(), - _info, true); - _image_control->installRootColormap(); - _root_cmap_installed = True; - - // initialize the screen's style - _style.setImageControl(_image_control); - std::string 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()) { @@ -94,6 +88,8 @@ Screen::Screen(int screen) } } _style.load(sconfig); + */ + otk::display->renderControl(_number)->drawRoot(*_style.rootColor()); // set up notification of netwm support changeSupportedAtoms(); @@ -101,23 +97,21 @@ Screen::Screen(int screen) // Set the netwm properties for geometry unsigned long geometry[] = { _info->width(), _info->height() }; - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_desktop_geometry, - otk::Property::Atom_Cardinal, - geometry, 2); + 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; + std::vector names; python_get_stringlist("desktop_names", &names); - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_desktop_names, - otk::Property::utf8, - 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 if (!python_get_long("number_of_desktops", &_num_desktops)) - _num_desktops = 4; + _num_desktops = 1; changeNumDesktops(_num_desktops); // set the hint _desktop = 0; @@ -126,10 +120,10 @@ Screen::Screen(int screen) // create the window which gets focus when no clients get it XSetWindowAttributes attr; attr.override_redirect = true; - _focuswindow = XCreateWindow(otk::Display::display, _info->rootWindow(), + _focuswindow = XCreateWindow(**otk::display, _info->rootWindow(), -100, -100, 1, 1, 0, 0, InputOnly, _info->visual(), CWOverrideRedirect, &attr); - XMapWindow(otk::Display::display, _focuswindow); + XMapRaised(**otk::display, _focuswindow); // these may be further updated if any pre-existing windows are found in // the manageExising() function @@ -137,11 +131,11 @@ Screen::Screen(int screen) calcArea(); // initialize the available working area // register this class as the event handler for the root window - Openbox::instance->registerHandler(_info->rootWindow(), this); + openbox->registerHandler(_info->rootWindow(), this); // call the python Startup callbacks - EventData data(_number, 0, EventShutdown, 0); - Openbox::instance->bindings()->fireEvent(&data); + EventData data(_number, 0, EventAction::Shutdown, 0); + openbox->bindings()->fireEvent(&data); } @@ -149,20 +143,18 @@ Screen::~Screen() { if (! _managed) return; - XSelectInput(otk::Display::display, _info->rootWindow(), NoEventMask); + XSelectInput(**otk::display, _info->rootWindow(), NoEventMask); // unmanage all windows while (!clients.empty()) unmanageWindow(clients.front()); // call the python Shutdown callbacks - EventData data(_number, 0, EventShutdown, 0); - Openbox::instance->bindings()->fireEvent(&data); - - XDestroyWindow(otk::Display::display, _focuswindow); - XDestroyWindow(otk::Display::display, _supportwindow); + EventData data(_number, 0, EventAction::Shutdown, 0); + openbox->bindings()->fireEvent(&data); - delete _image_control; + XDestroyWindow(**otk::display, _focuswindow); + XDestroyWindow(**otk::display, _supportwindow); } @@ -170,14 +162,14 @@ void Screen::manageExisting() { unsigned int i, j, nchild; Window r, p, *children; - XQueryTree(otk::Display::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::Display::display, + XWMHints *wmhints = XGetWMHints(**otk::display, children[i]); if (wmhints) { @@ -201,7 +193,7 @@ void Screen::manageExisting() continue; XWindowAttributes attrib; - if (XGetWindowAttributes(otk::Display::display, children[i], &attrib)) { + if (XGetWindowAttributes(**otk::display, children[i], &attrib)) { if (attrib.override_redirect) continue; if (attrib.map_state != IsUnmapped) { @@ -232,7 +224,7 @@ void Screen::updateStrut() void Screen::calcArea() { - otk::Rect old_area = _area; +// otk::Rect old_area = _area; /* #ifdef XINERAMA @@ -269,7 +261,7 @@ void Screen::calcArea() #endif // XINERAMA */ - if (old_area != _area) + //if (old_area != _area) // XXX: re-maximize windows changeWorkArea(); @@ -279,96 +271,87 @@ void Screen::calcArea() void Screen::changeSupportedAtoms() { // create the netwm support window - _supportwindow = XCreateSimpleWindow(otk::Display::display, + _supportwindow = XCreateSimpleWindow(**otk::display, _info->rootWindow(), 0, 0, 1, 1, 0, 0, 0); // set supporting window - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_supporting_wm_check, - otk::Property::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::Property::net_wm_name, - otk::Property::utf8, - "Openbox"); - Openbox::instance->property()->set(_supportwindow, - otk::Property::net_supporting_wm_check, - otk::Property::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::net_current_desktop, - otk::Property::net_number_of_desktops, - otk::Property::net_desktop_geometry, - otk::Property::net_desktop_viewport, - otk::Property::net_active_window, - otk::Property::net_workarea, - otk::Property::net_client_list, - otk::Property::net_client_list_stacking, - otk::Property::net_desktop_names, - otk::Property::net_close_window, - otk::Property::net_wm_name, - otk::Property::net_wm_visible_name, - otk::Property::net_wm_icon_name, - otk::Property::net_wm_visible_icon_name, + 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::Property::net_wm_desktop, + otk::Property::atoms.net_wm_desktop, */ - otk::Property::net_wm_strut, - otk::Property::net_wm_window_type, - otk::Property::net_wm_window_type_desktop, - otk::Property::net_wm_window_type_dock, - otk::Property::net_wm_window_type_toolbar, - otk::Property::net_wm_window_type_menu, - otk::Property::net_wm_window_type_utility, - otk::Property::net_wm_window_type_splash, - otk::Property::net_wm_window_type_dialog, - otk::Property::net_wm_window_type_normal, + 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::Property::net_wm_moveresize, - otk::Property::net_wm_moveresize_size_topleft, - otk::Property::net_wm_moveresize_size_topright, - otk::Property::net_wm_moveresize_size_bottomleft, - otk::Property::net_wm_moveresize_size_bottomright, - otk::Property::net_wm_moveresize_move, + 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::Property::net_wm_allowed_actions, - otk::Property::net_wm_action_move, - otk::Property::net_wm_action_resize, - otk::Property::net_wm_action_shade, - otk::Property::net_wm_action_maximize_horz, - otk::Property::net_wm_action_maximize_vert, - otk::Property::net_wm_action_change_desktop, - otk::Property::net_wm_action_close, -*/ - otk::Property::net_wm_state, - otk::Property::net_wm_state_modal, - otk::Property::net_wm_state_maximized_vert, - otk::Property::net_wm_state_maximized_horz, - otk::Property::net_wm_state_shaded, - otk::Property::net_wm_state_skip_taskbar, - otk::Property::net_wm_state_skip_pager, - otk::Property::net_wm_state_hidden, - otk::Property::net_wm_state_fullscreen, - otk::Property::net_wm_state_above, - otk::Property::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::Property::Atoms)supported[i]); - - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_supported, - otk::Property::Atom_Atom, - supported, num_supported); + otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_supported, + otk::Property::atoms.atom, supported, num_supported); } @@ -390,10 +373,8 @@ void Screen::changeClientList() } else windows = (Window*) 0; - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_client_list, - otk::Property::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; @@ -410,23 +391,22 @@ void Screen::changeStackingList() 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; - Client::List::const_iterator it = _stacking.begin(); - const Client::List::const_iterator end = _stacking.end(); + Client::List::const_reverse_iterator it = _stacking.rbegin(); + const Client::List::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::Property::net_client_list_stacking, - otk::Property::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; @@ -442,10 +422,8 @@ void Screen::changeWorkArea() { dims[(i * 4) + 2] = _area.width(); dims[(i * 4) + 3] = _area.height(); } - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_workarea, - otk::Property::Atom_Cardinal, - dims, 4 * _num_desktops); + otk::Property::set(_info->rootWindow(), otk::Property::atoms.net_workarea, + otk::Property::atoms.cardinal, dims, 4 * _num_desktops); delete [] dims; } @@ -456,14 +434,14 @@ void Screen::manageWindow(Window window) XWMHints *wmhint; XSetWindowAttributes attrib_set; - otk::Display::grab(); + otk::display->grab(); // is the window a docking app - if ((wmhint = XGetWMHints(otk::Display::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(); + otk::display->ungrab(); XFree(wmhint); return; @@ -474,76 +452,83 @@ void Screen::manageWindow(Window window) // choose the events we want to receive on the CLIENT window attrib_set.event_mask = Client::event_mask; attrib_set.do_not_propagate_mask = Client::no_propagate_mask; - XChangeWindowAttributes(otk::Display::display, window, + XChangeWindowAttributes(**otk::display, window, CWEventMask|CWDontPropagate, &attrib_set); // 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::Display::display, window, SetModeInsert); - - 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); - } + XChangeSaveSet(**otk::display, window, SetModeInsert); // create the decoration frame for the client window client->frame = new Frame(client, &_style); + // 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); + openbox->addClient(client->frame->window(), client); + openbox->addClient(client->frame->plate(), client); + openbox->addClient(client->frame->titlebar(), client); + openbox->addClient(client->frame->label(), client); + openbox->addClient(client->frame->button_max(), client); + openbox->addClient(client->frame->button_iconify(), client); + openbox->addClient(client->frame->button_alldesk(), client); + openbox->addClient(client->frame->button_close(), client); + openbox->addClient(client->frame->handle(), client); + openbox->addClient(client->frame->grip_left(), client); + openbox->addClient(client->frame->grip_right(), client); // reparent the client to the frame client->frame->grabClient(); + if (!(openbox->state() == Openbox::State_Starting || + client->positionRequested())) { + // position the window intelligenty .. hopefully :) + // call the python PLACEWINDOW binding + EventData data(_number, client, EventAction::PlaceWindow, 0); + openbox->bindings()->fireEvent(&data); + } + // 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 maximized - otk::Display::ungrab(); + client->applyStartupState(); + + otk::display->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); + raiseWindow(client); // update the root properties changeClientList(); - Openbox::instance->bindings()->grabButtons(true, client); + openbox->bindings()->grabButtons(true, client); // call the python NEWWINDOW binding - EventData data(_number, client, EventNewWindow, 0); - Openbox::instance->bindings()->fireEvent(&data); + EventData data(_number, client, EventAction::NewWindow, 0); + openbox->bindings()->fireEvent(&data); #ifdef DEBUG - printf("Managed window 0x%lx\n", window); + printf("Managed window 0x%lx frame 0x%lx\n", + window, client->frame->window()); #endif } @@ -553,32 +538,32 @@ void Screen::unmanageWindow(Client *client) Frame *frame = client->frame; // call the python CLOSEWINDOW binding - EventData data(_number, client, EventCloseWindow, 0); - Openbox::instance->bindings()->fireEvent(&data); + EventData data(_number, client, EventAction::CloseWindow, 0); + openbox->bindings()->fireEvent(&data); - Openbox::instance->bindings()->grabButtons(false, client); + 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()); + openbox->removeClient(frame->window()); + openbox->removeClient(frame->plate()); + openbox->removeClient(frame->titlebar()); + openbox->removeClient(frame->label()); + openbox->removeClient(frame->button_max()); + openbox->removeClient(frame->button_iconify()); + openbox->removeClient(frame->button_alldesk()); + openbox->removeClient(frame->button_close()); + openbox->removeClient(frame->handle()); + openbox->removeClient(frame->grip_left()); + openbox->removeClient(frame->grip_right()); // unregister for handling events - Openbox::instance->clearHandler(client->window()); + openbox->clearHandler(client->window()); // remove the window from our save set - XChangeSaveSet(otk::Display::display, client->window(), SetModeDelete); + XChangeSaveSet(**otk::display, client->window(), SetModeDelete); // we dont want events no more - XSelectInput(otk::Display::display, client->window(), NoEventMask); + XSelectInput(**otk::display, client->window(), NoEventMask); frame->hide(); @@ -588,6 +573,9 @@ void Screen::unmanageWindow(Client *client) // reparent the window out of the frame frame->releaseClient(); +#ifdef DEBUG + Window framewin = client->frame->window(); +#endif delete client->frame; client->frame = 0; @@ -601,7 +589,7 @@ void Screen::unmanageWindow(Client *client) client->unfocus(); #ifdef DEBUG - printf("Unmanaged window 0x%lx\n", client->window()); + printf("Unmanaged window 0x%lx frame 0x%lx\n", client->window(), framewin); #endif delete client; @@ -610,37 +598,59 @@ void Screen::unmanageWindow(Client *client) changeClientList(); } -void Screen::restack(bool raise, Client *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 + + Client::List::iterator it = --_stacking.end(); + const Client::List::iterator end = _stacking.begin(); + + 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); - // the stacking list is from highest to lowest + 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 + + // remove the client before looking so we can't run into ourselves + _stacking.remove(client); - Client::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()); + Client::List::iterator it = _stacking.begin(); + const Client::List::iterator end = _stacking.end(); + + // the stacking list is from highest to lowest + for (; it != end && (*it)->layer() > client->layer(); ++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 : + ((*(--Client::List::const_iterator(it)))->frame->window())); + wins[1] = 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::Display::display, &wins[0], wins.size()); + XRestackWindows(**otk::display, wins, 2); changeStackingList(); } void Screen::changeDesktop(long desktop) { - assert(desktop >= 0 && desktop < _num_desktops); - if (!(desktop >= 0 && desktop < _num_desktops)) return; printf("Moving to desktop %ld\n", desktop); @@ -648,10 +658,9 @@ void Screen::changeDesktop(long desktop) long old = _desktop; _desktop = desktop; - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_current_desktop, - otk::Property::Atom_Cardinal, - _desktop); + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_current_desktop, + otk::Property::atoms.cardinal, _desktop); if (old == _desktop) return; @@ -665,8 +674,8 @@ void Screen::changeDesktop(long desktop) } // force the callbacks to fire - if (!Openbox::instance->focusedClient()) - Openbox::instance->setFocusedClient(0); + if (!openbox->focusedClient()) + openbox->setFocusedClient(0); } void Screen::changeNumDesktops(long num) @@ -678,18 +687,17 @@ void Screen::changeNumDesktops(long num) // XXX: move windows on desktops that will no longer exist! _num_desktops = num; - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_number_of_desktops, - otk::Property::Atom_Cardinal, - _num_desktops); + 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); - Openbox::instance->property()->set(_info->rootWindow(), - otk::Property::net_desktop_viewport, - otk::Property::Atom_Cardinal, - viewport, _num_desktops * 2); + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_desktop_viewport, + otk::Property::atoms.cardinal, + viewport, _num_desktops * 2); delete [] viewport; // update the work area hint @@ -699,31 +707,28 @@ void Screen::changeNumDesktops(long num) void Screen::updateDesktopNames() { - const otk::Property *property = Openbox::instance->property(); - unsigned long num = (unsigned) -1; - if (!property->get(_info->rootWindow(), - otk::Property::net_desktop_names, - otk::Property::utf8, &num, &_desktop_names)) + if (!otk::Property::get(_info->rootWindow(), + otk::Property::atoms.net_desktop_names, + otk::Property::utf8, &num, &_desktop_names)) _desktop_names.clear(); while ((long)_desktop_names.size() < _num_desktops) _desktop_names.push_back("Unnamed"); } -void Screen::setDesktopName(long i, const std::string &name) +void Screen::setDesktopName(long i, const otk::ustring &name) { assert(i >= 0); if (i >= _num_desktops) return; - const otk::Property *property = Openbox::instance->property(); - otk::Property::StringVect newnames = _desktop_names; newnames[i] = name; - property->set(_info->rootWindow(), otk::Property::net_desktop_names, - otk::Property::utf8, newnames); + otk::Property::set(_info->rootWindow(), + otk::Property::atoms.net_desktop_names, + otk::Property::utf8, newnames); } @@ -731,20 +736,18 @@ void Screen::propertyHandler(const XPropertyEvent &e) { otk::EventHandler::propertyHandler(e); - const otk::Property *property = Openbox::instance->property(); - // compress changes to a single property into a single change XEvent ce; - while (XCheckTypedEvent(otk::Display::display, e.type, &ce)) { + while (XCheckTypedEvent(**otk::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::Display::display, &ce); + XPutBackEvent(**otk::display, &ce); break; } } - if (e.atom == property->atom(otk::Property::net_desktop_names)) + if (e.atom == otk::Property::atoms.net_desktop_names) updateDesktopNames(); } @@ -755,12 +758,9 @@ void Screen::clientMessageHandler(const XClientMessageEvent &e) if (e.format != 32) return; - const otk::Property *property = Openbox::instance->property(); - - if (e.message_type == property->atom(otk::Property::net_current_desktop)) { + if (e.message_type == otk::Property::atoms.net_current_desktop) { changeDesktop(e.data.l[0]); - } else if (e.message_type == - property->atom(otk::Property::net_number_of_desktops)) { + } else if (e.message_type == otk::Property::atoms.net_number_of_desktops) { changeNumDesktops(e.data.l[0]); } // XXX: so many client messages to handle here! ..or not.. they go to clients @@ -775,31 +775,13 @@ void Screen::mapRequestHandler(const XMapRequestEvent &e) 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. - */ - Client *c = Openbox::instance->findClient(e.window); - + Client *c = openbox->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::Property::net_active_window); - ce.xclient.display = otk::Display::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::Display::display, _info->rootWindow(), false, - SubstructureRedirectMask | SubstructureNotifyMask, - &ce); +#ifdef DEBUG + printf("DEBUG: MAP REQUEST CAUGHT IN SCREEN. IGNORED.\n"); +#endif } else manageWindow(e.window); } + }