X-Git-Url: https://git.brokenzipper.com/gitweb?a=blobdiff_plain;f=util%2Fepist%2Fscreen.cc;h=25f16193e95e1fe6b522fe1b5bbdcf4b58cd287a;hb=eb19a6b69e89c6adae1b99705b0a26edc344c87a;hp=d767c268136460746db411b83b4bee3e6fc14040;hpb=75b6a5a378966efc09c355109ab42467ddc6d845;p=chaz%2Fopenbox diff --git a/util/epist/screen.cc b/util/epist/screen.cc index d767c268..25f16193 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 @@ -44,22 +57,28 @@ using std::hex; using std::dec; using std::string; -#include "../../src/BaseDisplay.hh" -#include "../../src/XAtom.hh" +#include "../../src/basedisplay.hh" +#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), _stacked_raise(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); + if (_stacked_cycling) + _config->getValue(Config::stackedCyclingRaise, _stacked_raise); + // find a window manager supporting NETWM, waiting for it to load if we must int count = 20; // try for 20 seconds _managed = false; @@ -121,18 +140,20 @@ 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, DestroyNotify, &ev) || XCheckTypedWindowEvent(_epist->getXDisplay(), e.xany.window, UnmapNotify, &ev)) { - processEvent(ev); + + XWindow *win = _epist->findWindow(e.xany.window); + if (win) win->processEvent(ev); } updateClientList(); @@ -141,6 +162,13 @@ void screen::processEvent(const XEvent &e) { case KeyPress: handleKeypress(e); break; + + case KeyRelease: + handleKeyrelease(e); + break; + + default: + break; } } @@ -151,8 +179,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 +204,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 +251,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 +321,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 +329,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 +356,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 +371,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 +383,30 @@ 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()) { + // all modifiers have been released. ungrab the keyboard, move the + // focused window to the top of the Z-order and raise it + ungrabModifiers(); + + if (_active != _clients.end()) { + XWindow *w = *_active; + bool e = _last_active == _active; + _clients.remove(w); + _clients.push_front(w); + _active = _clients.begin(); + if (e) _last_active = _active; + w->raise(); + } + + _cycling = false; + } +} + + // do we want to add this window to our list? bool screen::doAddWindow(Window window) const { assert(_managed); @@ -371,14 +469,14 @@ void screen::updateClientList() { const WindowList::iterator end = _clients.end(); unsigned long i; - // insert new clients after the active window for (i = 0; i < num; ++i) { for (it = _clients.begin(); it != end; ++it) if (**it == rootclients[i]) break; if (it == end) { // didn't already exist if (doAddWindow(rootclients[i])) { - // cout << "Added window: 0x" << hex << rootclients[i] << dec << endl; +// cout << "Added window: 0x" << hex << rootclients[i] << dec << endl; + // insert new clients after the active window _clients.insert(insert_point, new XWindow(_epist, this, rootclients[i])); } @@ -421,7 +519,9 @@ const XWindow *screen::lastActiveWindow() const { WindowList::const_iterator it, end = _clients.end(); for (it = _clients.begin(); it != end; ++it) if ((*it)->getScreen() == this && ! (*it)->iconic() && - ((*it)->desktop() == 0xffffffff || (*it)->desktop() == _active_desktop)) + (*it)->canFocus() && + ((*it)->desktop() == 0xffffffff || + (*it)->desktop() == _active_desktop)) return *it; // no windows on this screen @@ -443,9 +543,22 @@ void screen::updateActiveWindow() { break; } } + _active = it; - if (it != end) - _last_active = it; + + if (_active != end) { + /* if we're not cycling and a window gets focus, add it to the top of the + * cycle stack. + */ + if (_stacked_cycling && !_cycling) { + XWindow *win = *_active; + _clients.remove(win); + _clients.push_front(win); + _active = _clients.begin(); + + _last_active = _active; + } + } /* cout << "Active window is now: "; if (_active == _clients.end()) cout << "None\n"; @@ -457,6 +570,12 @@ void screen::updateActiveWindow() { void screen::execCommand(const string &cmd) const { pid_t pid; if ((pid = fork()) == 0) { + // disconnect the child from epist's session and the tty + if (setsid() == -1) { + cout << "warning: could not start a new process group\n"; + perror("setsid"); + } + // make the command run on the correct screen if (putenv(const_cast(_info->displayString().c_str()))) { cout << "warning: couldn't set environment variable 'DISPLAY'\n"; @@ -471,10 +590,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 +608,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) { @@ -499,8 +621,7 @@ void screen::cycleWindow(const bool forward, const int increment, } else { if (target == begin) target = end; - for (int x = 0; x < increment; ++x) - --target; + --target; } // must be no window to focus @@ -528,12 +649,31 @@ 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 (_stacked_raise || (t->desktop() != _active_desktop && + t->desktop() != 0xffffffff)) + t->focus(); // raise + else + t->focus(false); // don't raise + } + 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; @@ -562,6 +702,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(); @@ -613,3 +818,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; +}