X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=util%2Fepist%2Fscreen.cc;h=a7098a77d6706f2dd186f6269b0e3c5f491cd918;hb=572acce581f4b8799db661ed7ab0007de0393a09;hp=c4f0520be54e9e34f90f1ebb14f62ec6ca13441b;hpb=d8967bd534ff10a234fed17059fb92d985be9176;p=chaz%2Fopenbox diff --git a/util/epist/screen.cc b/util/epist/screen.cc index c4f0520b..a7098a77 100644 --- a/util/epist/screen.cc +++ b/util/epist/screen.cc @@ -1,5 +1,5 @@ -// -*- mode: C++; indent-tabs-mode: nil; -*- -// screen.cc for Epistophy - a key handler for NETWM/EWMH window managers. +// -*- 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 // // Permission is hereby granted, free of charge, to any person obtaining a @@ -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; @@ -166,61 +191,103 @@ void screen::handleKeypress(const XEvent &e) { return; case Action::nextWorkspace: - cycleWorkspace(true); + cycleWorkspace(true, it->number() != 0 ? it->number(): 1); return; case Action::prevWorkspace: - cycleWorkspace(false); + cycleWorkspace(false, it->number() != 0 ? it->number(): 1); return; case Action::nextWindow: - cycleWindow(true); + + cycleWindow(state, true, it->number() != 0 ? it->number(): 1); return; case Action::prevWindow: - cycleWindow(false); + cycleWindow(state, false, it->number() != 0 ? it->number(): 1); return; case Action::nextWindowOnAllWorkspaces: - cycleWindow(true, false, true); + cycleWindow(state, true, it->number() != 0 ? it->number(): 1, false, true); return; case Action::prevWindowOnAllWorkspaces: - cycleWindow(false, false, true); + cycleWindow(state, false, it->number() != 0 ? it->number(): 1, false, true); return; case Action::nextWindowOnAllScreens: - cycleWindow(true, true); + cycleWindow(state, true, it->number() != 0 ? it->number(): 1, true); return; case Action::prevWindowOnAllScreens: - cycleWindow(false, true); + cycleWindow(state, false, it->number() != 0 ? it->number(): 1, true); return; case Action::nextWindowOfClass: - cycleWindow(true, false, false, true, it->string()); + cycleWindow(state, true, it->number() != 0 ? it->number(): 1, + false, false, true, it->string()); return; case Action::prevWindowOfClass: - cycleWindow(false, false, false, true, it->string()); + cycleWindow(state, false, it->number() != 0 ? it->number(): 1, + false, false, true, it->string()); return; case Action::nextWindowOfClassOnAllWorkspaces: - cycleWindow(true, false, true, true, it->string()); + cycleWindow(state, true, it->number() != 0 ? it->number(): 1, + false, true, true, it->string()); return; case Action::prevWindowOfClassOnAllWorkspaces: - cycleWindow(false, false, true, true, it->string()); + cycleWindow(state, false, it->number() != 0 ? it->number(): 1, + false, true, true, it->string()); return; case Action::changeWorkspace: 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; } @@ -250,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 @@ -258,30 +325,34 @@ 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: - window->resize(it->number(), 0); + window->resizeRel(it->number(), 0); return; case Action::resizeWindowHeight: - window->resize(0, it->number()); + window->resizeRel(0, it->number()); return; - case Action::toggleshade: + case Action::toggleShade: window->shade(! window->shaded()); return; @@ -296,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! @@ -304,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); @@ -438,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; @@ -466,13 +571,16 @@ void screen::execCommand(const string &cmd) const { } -void screen::cycleWindow(const bool forward, const bool allscreens, +void screen::cycleWindow(unsigned int state, const bool forward, + const int increment, const bool allscreens, const bool alldesktops, const bool sameclass, - const string &cn) const { + const string &cn) +{ assert(_managed); + assert(increment > 0); if (_clients.empty()) return; - + string classname(cn); if (sameclass && classname.empty() && _active != _clients.end()) classname = (*_active)->appClass(); @@ -480,60 +588,87 @@ void screen::cycleWindow(const bool forward, const bool allscreens, WindowList::const_iterator target = _active, begin = _clients.begin(), end = _clients.end(); - - while (1) { - if (forward) { - if (target == end) { - target = begin; + + XWindow *t = 0; + + for (int x = 0; x < increment; ++x) { + while (1) { + if (forward) { + if (target == end) { + target = begin; + } else { + ++target; + } } else { - ++target; + if (target == begin) + target = end; + --target; } - } else { - if (target == begin) - target = end; - --target; - } - // must be no window to focus - if (target == _active) - return; + // must be no window to focus + if (target == _active) + return; - // start back at the beginning of the loop - if (target == end) - continue; + // start back at the beginning of the loop + if (target == end) + continue; + + // determine if this window is invalid for cycling to + t = *target; + if (t->iconic()) continue; + if (! allscreens && t->getScreen() != this) continue; + if (! alldesktops && ! (t->desktop() == _active_desktop || + t->desktop() == 0xffffffff)) continue; + if (sameclass && ! classname.empty() && + t->appClass() != classname) continue; + if (! t->canFocus()) continue; + + // found a good window so break out of the while, and perhaps continue + // with the for loop + break; + } + } + + // phew. we found the window, so focus it. + if (_stacked_cycling && state) { + if (!_cycling) { + // grab modifiers so we can intercept KeyReleases from them + grabModifiers(); + _cycling = true; + } - // determine if this window is invalid for cycling to - const XWindow *t = *target; - if (t->iconic()) continue; - if (! allscreens && t->getScreen() != this) continue; - if (! alldesktops && ! (t->desktop() == _active_desktop || - t->desktop() == 0xffffffff)) continue; - if (sameclass && ! classname.empty() && - t->appClass() != classname) continue; - if (! t->canFocus()) continue; - - // found a good window! + // 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->focus(false); // focus, but don't raise + else + t->focus(); // change workspace and focus + } + else { t->focus(); - return; } } -void screen::cycleWorkspace(const bool forward, 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; - if (forward) { - if (destination < _num_desktops - 1) - ++destination; - else if (loop) - destination = 0; - } else { - if (destination > 0) - --destination; - else if (loop) - destination = _num_desktops - 1; + for (int x = 0; x < increment; ++x) { + if (forward) { + if (destination < _num_desktops - 1) + ++destination; + else if (loop) + destination = 0; + } else { + if (destination > 0) + --destination; + else if (loop) + destination = _num_desktops - 1; + } } if (destination != _active_desktop) @@ -547,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(); @@ -598,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; +}