X-Git-Url: https://git.brokenzipper.com/gitweb?a=blobdiff_plain;f=util%2Fepist%2Fscreen.cc;h=7845e55f9489f8b11c2fa36cefe478584f74252b;hb=eca8fd764eeb631733cae2b171ca0787fca788d7;hp=7ac5780b1c59f4ce62543e029fee4e6496d7608f;hpb=d856db568a5933555191a35778dfa9cf0f619f8f;p=chaz%2Fopenbox diff --git a/util/epist/screen.cc b/util/epist/screen.cc index 7ac5780b..7845e55f 100644 --- a/util/epist/screen.cc +++ b/util/epist/screen.cc @@ -1,4 +1,4 @@ -// -*- mode: C++; indent-tabs-mode: nil; -*- +// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*- // screen.cc for Epistrophy - a key handler for NETWM/EWMH window managers. // Copyright (c) 2002 - 2002 Ben Jansens // @@ -20,6 +20,17 @@ // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. +/* A few comments about stacked cycling: + * When stacked cycling is turned on, the focused window is always at the top + * (front) of the list (_clients), EXCEPT for when we are in cycling mode. + * (_cycling is true) If we were to add the focused window to the top of the + * stack while we were cycling, we would end in a deadlock between 2 windows. + * When the modifiers are released, the window that has focus (but it's not + * at the top of the stack, since we are cycling) is placed at the top of the + * stack and raised. + * Hooray and Bummy. - Marius + */ + #ifdef HAVE_CONFIG_H # include "../../config.h" #endif // HAVE_CONFIG_H @@ -33,6 +44,8 @@ extern "C" { # include # include #endif // HAVE_UNISTD_H + +#include } #include @@ -48,18 +61,22 @@ using std::string; #include "../../src/XAtom.hh" #include "screen.hh" #include "epist.hh" - +#include "config.hh" screen::screen(epist *epist, int number) - : _clients(epist->clientsList()), - _active(epist->activeWindow()) { + : _clients(epist->clientsList()), _active(epist->activeWindow()), + _config(epist->getConfig()), _grabbed(true), _cycling(false), + _stacked_cycling(false) +{ _epist = epist; _xatom = _epist->xatom(); _last_active = _clients.end(); _number = number; _info = _epist->getScreenInfo(_number); _root = _info->getRootWindow(); - + + _config->getValue(Config::stackedCycling, _stacked_cycling); + // find a window manager supporting NETWM, waiting for it to load if we must int count = 20; // try for 20 seconds _managed = false; @@ -121,11 +138,11 @@ void screen::processEvent(const XEvent &e) { // root window if (e.xproperty.atom == _xatom->getAtom(XAtom::net_number_of_desktops)) updateNumDesktops(); - if (e.xproperty.atom == _xatom->getAtom(XAtom::net_current_desktop)) + else if (e.xproperty.atom == _xatom->getAtom(XAtom::net_current_desktop)) updateActiveDesktop(); - if (e.xproperty.atom == _xatom->getAtom(XAtom::net_active_window)) + else if (e.xproperty.atom == _xatom->getAtom(XAtom::net_active_window)) updateActiveWindow(); - if (e.xproperty.atom == _xatom->getAtom(XAtom::net_client_list)) { + else if (e.xproperty.atom == _xatom->getAtom(XAtom::net_client_list)) { // catch any window unmaps first XEvent ev; if (XCheckTypedWindowEvent(_epist->getXDisplay(), e.xany.window, @@ -141,6 +158,13 @@ void screen::processEvent(const XEvent &e) { case KeyPress: handleKeypress(e); break; + + case KeyRelease: + handleKeyrelease(e); + break; + + default: + break; } } @@ -151,8 +175,9 @@ void screen::handleKeypress(const XEvent &e) { // Mask out the lock modifiers. We want our keys to always work // This should be made an option unsigned int state = e.xkey.state & ~(LockMask|scrolllockMask|numlockMask); - const Action *it = _epist->getKeyTree().getAction(e, state, this); - + keytree &ktree = _epist->getKeyTree(); + const Action *it = ktree.getAction(e, state, this); + if (!it) return; @@ -175,46 +200,46 @@ void screen::handleKeypress(const XEvent &e) { case Action::nextWindow: - cycleWindow(true, it->number() != 0 ? it->number(): 1); + cycleWindow(state, true, it->number() != 0 ? it->number(): 1); return; case Action::prevWindow: - cycleWindow(false, it->number() != 0 ? it->number(): 1); + cycleWindow(state, false, it->number() != 0 ? it->number(): 1); return; case Action::nextWindowOnAllWorkspaces: - cycleWindow(true, it->number() != 0 ? it->number(): 1, false, true); + cycleWindow(state, true, it->number() != 0 ? it->number(): 1, false, true); return; case Action::prevWindowOnAllWorkspaces: - cycleWindow(false, it->number() != 0 ? it->number(): 1, false, true); + cycleWindow(state, false, it->number() != 0 ? it->number(): 1, false, true); return; case Action::nextWindowOnAllScreens: - cycleWindow(true, it->number() != 0 ? it->number(): 1, true); + cycleWindow(state, true, it->number() != 0 ? it->number(): 1, true); return; case Action::prevWindowOnAllScreens: - cycleWindow(false, it->number() != 0 ? it->number(): 1, true); + cycleWindow(state, false, it->number() != 0 ? it->number(): 1, true); return; case Action::nextWindowOfClass: - cycleWindow(true, it->number() != 0 ? it->number(): 1, + cycleWindow(state, true, it->number() != 0 ? it->number(): 1, false, false, true, it->string()); return; case Action::prevWindowOfClass: - cycleWindow(false, it->number() != 0 ? it->number(): 1, + cycleWindow(state, false, it->number() != 0 ? it->number(): 1, false, false, true, it->string()); return; case Action::nextWindowOfClassOnAllWorkspaces: - cycleWindow(true, it->number() != 0 ? it->number(): 1, + cycleWindow(state, true, it->number() != 0 ? it->number(): 1, false, true, true, it->string()); return; case Action::prevWindowOfClassOnAllWorkspaces: - cycleWindow(false, it->number() != 0 ? it->number(): 1, + cycleWindow(state, false, it->number() != 0 ? it->number(): 1, false, true, true, it->string()); return; @@ -222,10 +247,47 @@ void screen::handleKeypress(const XEvent &e) { changeWorkspace(it->number()); return; + case Action::upWorkspace: + changeWorkspaceVert(-1); + return; + + case Action::downWorkspace: + changeWorkspaceVert(1); + return; + + case Action::leftWorkspace: + changeWorkspaceHorz(-1); + return; + + case Action::rightWorkspace: + changeWorkspaceHorz(1); + return; + case Action::execute: execCommand(it->string()); return; + case Action::showRootMenu: + _xatom->sendClientMessage(rootWindow(), XAtom::openbox_show_root_menu, + None); + return; + + case Action::showWorkspaceMenu: + _xatom->sendClientMessage(rootWindow(), XAtom::openbox_show_workspace_menu, + None); + return; + + case Action::toggleGrabs: { + if (_grabbed) { + ktree.ungrabDefaults(this); + _grabbed = false; + } else { + ktree.grabDefaults(this); + _grabbed = true; + } + return; + } + default: break; } @@ -255,7 +317,7 @@ void screen::handleKeypress(const XEvent &e) { window->sendTo(it->number()); return; - case Action::toggleomnipresent: + case Action::toggleOmnipresent: if (window->desktop() == 0xffffffff) window->sendTo(_active_desktop); else @@ -263,19 +325,23 @@ void screen::handleKeypress(const XEvent &e) { return; case Action::moveWindowUp: - window->move(window->x(), window->y() - it->number()); + window->move(window->x(), window->y() - + (it->number() != 0 ? it->number(): 1)); return; case Action::moveWindowDown: - window->move(window->x(), window->y() + it->number()); + window->move(window->x(), window->y() + + (it->number() != 0 ? it->number(): 1)); return; case Action::moveWindowLeft: - window->move(window->x() - it->number(), window->y()); + window->move(window->x() - (it->number() != 0 ? it->number(): 1), + window->y()); return; case Action::moveWindowRight: - window->move(window->x() + it->number(), window->y()); + window->move(window->x() + (it->number() != 0 ? it->number(): 1), + window->y()); return; case Action::resizeWindowWidth: @@ -286,7 +352,7 @@ void screen::handleKeypress(const XEvent &e) { window->resizeRel(0, it->number()); return; - case Action::toggleshade: + case Action::toggleShade: window->shade(! window->shaded()); return; @@ -301,6 +367,10 @@ void screen::handleKeypress(const XEvent &e) { case Action::toggleMaximizeFull: window->toggleMaximize(XWindow::Max_Full); return; + + case Action::toggleDecorations: + window->decorate(! window->decorated()); + return; default: assert(false); // unhandled action type! @@ -309,6 +379,26 @@ void screen::handleKeypress(const XEvent &e) { } } + +void screen::handleKeyrelease(const XEvent &) { + // the only keyrelease event we care about (for now) is when we do stacked + // cycling and the modifier is released + if (_stacked_cycling && _cycling && nothingIsPressed()) { + XWindow *w = *_active; + + // all modifiers have been released. ungrab the keyboard, move the + // focused window to the top of the Z-order and raise it + ungrabModifiers(); + + _clients.remove(w); + _clients.push_front(w); + w->raise(); + + _cycling = false; + } +} + + // do we want to add this window to our list? bool screen::doAddWindow(Window window) const { assert(_managed); @@ -443,7 +533,17 @@ void screen::updateActiveWindow() { break; } } + _active = it; + + /* if we're not cycling and a window gets focus, add it to the top of the + * cycle stack. + */ + if (_stacked_cycling && !_cycling) { + _clients.remove(*_active); + _clients.push_front(*_active); + } + if (it != end) _last_active = it; @@ -471,10 +571,13 @@ void screen::execCommand(const string &cmd) const { } -void screen::cycleWindow(const bool forward, const int increment, - const bool allscreens, const bool alldesktops, - const bool sameclass, const string &cn) const { +void screen::cycleWindow(unsigned int state, const bool forward, + const int increment, const bool allscreens, + const bool alldesktops, const bool sameclass, + const string &cn) +{ assert(_managed); + assert(increment > 0); if (_clients.empty()) return; @@ -486,7 +589,7 @@ void screen::cycleWindow(const bool forward, const int increment, begin = _clients.begin(), end = _clients.end(); - const XWindow *t; + XWindow *t = 0; for (int x = 0; x < increment; ++x) { while (1) { @@ -527,12 +630,30 @@ void screen::cycleWindow(const bool forward, const int increment, } // phew. we found the window, so focus it. - t->focus(); + if (_stacked_cycling && state) { + if (!_cycling) { + // grab modifiers so we can intercept KeyReleases from them + grabModifiers(); + _cycling = true; + } + + // if the window is on another desktop, we can't use XSetInputFocus, since + // it doesn't imply a workspace change. + if (t->desktop() == _active_desktop || t->desktop() == 0xffffffff) + t->focus(false); // focus, but don't raise + else + t->focus(); // change workspace and focus + } + else { + t->focus(); + } } -void screen::cycleWorkspace(const bool forward, const int increment, const bool loop) const { +void screen::cycleWorkspace(const bool forward, const int increment, + const bool loop) const { assert(_managed); + assert(increment > 0); unsigned int destination = _active_desktop; @@ -561,6 +682,71 @@ void screen::changeWorkspace(const int num) const { _xatom->sendClientMessage(_root, XAtom::net_current_desktop, _root, num); } +void screen::changeWorkspaceVert(const int num) const { + assert(_managed); + int width = 0; + int num_desktops = (signed)_num_desktops; + int active_desktop = (signed)_active_desktop; + int wnum = 0; + + _config->getValue(Config::workspaceColumns, width); + + if (width > num_desktops || width <= 0) + return; + + // a cookie to the person that makes this pretty + if (num < 0) { + wnum = active_desktop - width; + if (wnum < 0) { + wnum = num_desktops/width * width + active_desktop; + if (wnum >= num_desktops) + wnum = num_desktops - 1; + } + } + else { + wnum = active_desktop + width; + if (wnum >= num_desktops) { + wnum = (active_desktop + width) % num_desktops - 1; + if (wnum < 0) + wnum = 0; + } + } + changeWorkspace(wnum); +} + +void screen::changeWorkspaceHorz(const int num) const { + assert(_managed); + int width = 0; + int num_desktops = (signed)_num_desktops; + int active_desktop = (signed)_active_desktop; + int wnum = 0; + + _config->getValue(Config::workspaceColumns, width); + + if (width > num_desktops || width <= 0) + return; + + if (num < 0) { + if (active_desktop % width != 0) + changeWorkspace(active_desktop - 1); + else { + wnum = active_desktop + width - 1; + if (wnum >= num_desktops) + wnum = num_desktops - 1; + } + } + else { + if (active_desktop % width != width - 1) { + wnum = active_desktop + 1; + if (wnum >= num_desktops) + wnum = num_desktops / width * width; + } + else + wnum = active_desktop - width + 1; + } + changeWorkspace(wnum); +} + void screen::grabKey(const KeyCode keyCode, const int modifierMask) const { Display *display = _epist->getXDisplay(); @@ -612,3 +798,32 @@ void screen::ungrabKey(const KeyCode keyCode, const int modifierMask) const { XUngrabKey(display, keyCode, modifierMask|numlockMask|LockMask| scrolllockMask, _root); } + + +void screen::grabModifiers() const { + Display *display = _epist->getXDisplay(); + + XGrabKeyboard(display, rootWindow(), True, GrabModeAsync, + GrabModeAsync, CurrentTime); +} + + +void screen::ungrabModifiers() const { + Display *display = _epist->getXDisplay(); + + XUngrabKeyboard(display, CurrentTime); +} + + +bool screen::nothingIsPressed(void) const +{ + char keys[32]; + XQueryKeymap(_epist->getXDisplay(), keys); + + for (int i = 0; i < 32; ++i) { + if (keys[i] != 0) + return false; + } + + return true; +}