fluxbox/src/Keys.cc

616 lines
16 KiB
C++
Raw Normal View History

2002-01-08 21:45:49 +00:00
// Keys.cc for Fluxbox - an X11 Window manager
// Copyright (c) 2001-2002 Henrik Kinnunen (fluxgen@linuxmail.org)
2001-12-11 20:47:02 +00:00
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
2002-02-26 22:19:51 +00:00
//$Id: Keys.cc,v 1.12 2002/02/26 22:19:43 fluxgen Exp $
2001-12-11 20:47:02 +00:00
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "Keys.hh"
#include "StringUtil.hh"
2001-12-11 20:47:02 +00:00
#ifdef HAVE_STDIO_H
# include <stdio.h>
2002-02-21 00:39:08 +00:00
#endif // HAVE_STDIO_H
2001-12-11 20:47:02 +00:00
#ifdef HAVE_CTYPE_H
# include <ctype.h>
2002-02-21 00:39:08 +00:00
#endif // HAVE_CTYPE_H
2001-12-11 20:47:02 +00:00
#ifdef STDC_HEADERS
# include <stdlib.h>
# include <string.h>
# include <errno.h>
2002-02-21 00:39:08 +00:00
#endif // STDC_HEADERS
2001-12-11 20:47:02 +00:00
#if HAVE_STRINGS_H
# include <strings.h>
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
2002-02-21 00:39:08 +00:00
#endif // HAVE_SYS_TYPES_H
2001-12-11 20:47:02 +00:00
#ifdef HAVE_SYS_WAIT_H
# include <sys/wait.h>
2002-02-21 00:39:08 +00:00
#endif // HAVE_SYS_WAIT_H
2001-12-11 20:47:02 +00:00
#ifdef HAVE_UNISTD_H
# include <unistd.h>
2002-02-21 00:39:08 +00:00
#endif // HAVE_UNISTD_H
2001-12-11 20:47:02 +00:00
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
2002-02-21 00:39:08 +00:00
#endif // HAVE_SYS_STAT_H
2001-12-11 20:47:02 +00:00
#include <X11/Xlib.h>
#include <X11/Xproto.h>
#include <X11/keysym.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <cassert>
2002-01-08 12:13:25 +00:00
#include <memory>
2001-12-11 20:47:02 +00:00
using namespace std;
Keys::t_actionstr Keys::m_actionlist[] = {
{"Minimize", ICONIFY},
{"Raise", RAISE},
{"Lower", LOWER},
{"Close", CLOSE},
{"AbortKeychain", ABORTKEYCHAIN},
2002-02-20 23:10:48 +00:00
{"Workspace", WORKSPACE},
{"Workspace1", WORKSPACE1},
{"Workspace2", WORKSPACE2},
{"Workspace3", WORKSPACE3},
{"Workspace4", WORKSPACE4},
{"Workspace5", WORKSPACE5},
{"Workspace6", WORKSPACE6},
{"Workspace7", WORKSPACE7},
{"Workspace8", WORKSPACE8},
{"Workspace9", WORKSPACE9},
{"Workspace10", WORKSPACE10},
{"Workspace11", WORKSPACE11},
{"Workspace12", WORKSPACE12},
2002-02-26 22:19:51 +00:00
{"SendToWorkspace", SENDTOWORKSPACE},
{"NextWorkspace", NEXTWORKSPACE},
{"PrevWorkspace", PREVWORKSPACE},
{"LeftWorkspace", LEFTWORKSPACE},
{"RightWorkspace", RIGHTWORKSPACE},
{"KillWindow", KILLWINDOW},
{"NextWindow", NEXTWINDOW},
{"PrevWindow", PREVWINDOW},
{"NextTab", NEXTTAB},
{"PrevTab", PREVTAB},
{"ShadeWindow", SHADE},
{"MaximizeWindow", MAXIMIZE},
{"StickWindow", STICK},
{"ExecCommand", EXECUTE},
{"MaximizeVertical", VERTMAX},
{"MaximizeHorizontal", HORIZMAX},
{"NudgeRight", NUDGERIGHT},
{"NudgeLeft", NUDGELEFT},
{"NudgeUp", NUDGEUP},
{"NudgeDown", NUDGEDOWN},
{"BigNudgeRight", BIGNUDGERIGHT},
{"BigNudgeLeft", BIGNUDGELEFT},
{"BigNudgeUp", BIGNUDGEUP},
{"BigNudgeDown", BIGNUDGEDOWN},
{"HorizontalIncrement", HORIZINC},
{"VerticalIncrement", VERTINC},
{"HorizontalDecrement", HORIZDEC},
{"VerticalDecrement", VERTDEC},
{"ToggleDecor", TOGGLEDECOR},
{0, LASTKEYGRAB}
};
2001-12-11 20:47:02 +00:00
Keys::Keys(Display *display, char *filename):
m_abortkey(0),
m_display(display)
{
assert(display);
if (filename)
load(filename);
2001-12-11 20:47:02 +00:00
}
2002-01-08 21:45:49 +00:00
Keys::~Keys() {
ungrabKeys();
2002-01-08 21:45:49 +00:00
deleteTree();
2001-12-11 20:47:02 +00:00
}
2001-12-11 20:47:02 +00:00
//--------- deleteTree -----------
// Destroys the keytree and m_abortkey
//--------------------------------
void Keys::deleteTree() {
while (!m_keylist.empty()) {
if (m_keylist.back())
delete m_keylist.back();
m_keylist.pop_back();
}
if (m_abortkey) {
delete m_abortkey;
m_abortkey=0;
}
}
//-------- ungrabKeys ---------
// Ungrabs the keys
//-----------------------------
void Keys::ungrabKeys() {
for (int screen=0; screen<ScreenCount(m_display); screen++) {
XUngrabKey(m_display, AnyKey, AnyModifier,
RootWindow(m_display, screen));
}
}
2001-12-11 20:47:02 +00:00
//-------------- load ----------------
// Load and grab keys
// Returns true on success else false
// TODO: error checking
2001-12-11 20:47:02 +00:00
//------------------------------------
bool Keys::load(char *filename) {
if (!filename)
return false;
//ungrab all keys
ungrabKeys();
2002-01-08 21:45:49 +00:00
//free memory of previous grabs
deleteTree();
XSync(m_display, False);
2001-12-11 20:47:02 +00:00
//open the file
ifstream infile(filename);
if (!infile)
return false;
auto_ptr<char> linebuffer(new char[1024]);
int line=0;//current line, so we can tell the user where the fault is
2001-12-11 20:47:02 +00:00
while (!infile.eof()) {
infile.getline(linebuffer.get(), 1024);
2001-12-11 20:47:02 +00:00
line++;
vector<string> val;
//Parse arguments
StringUtil::stringtok(val, linebuffer.get());
//must have at least 1 argument
if (val.size()<=0)
continue;
if (val[0][0]=='#') //the line is commented
continue;
2001-12-11 20:47:02 +00:00
unsigned int key=0, mod=0;
char keyarg=0;
t_key *current_key=0, *last_key=0;
for (unsigned int argc=0; argc<val.size(); argc++) {
2001-12-11 20:47:02 +00:00
if (val[argc][0]!=':') {
2001-12-11 20:47:02 +00:00
keyarg++;
if (keyarg==1) //first arg is modifier
mod = getModifier(val[argc].c_str());
2001-12-11 20:47:02 +00:00
else if (keyarg>1) {
2002-01-05 12:01:16 +00:00
2001-12-11 20:47:02 +00:00
//keyarg=0;
int tmpmod=getModifier(val[argc].c_str());
if(tmpmod)
mod|=tmpmod; //If it's a modifier
2002-01-05 12:01:16 +00:00
else{
key = getKey(val[argc].c_str()); // else get the key
2002-01-05 12:01:16 +00:00
if (!current_key) {
current_key = new t_key(key, mod);
last_key = current_key;
} else {
t_key *temp_key = new t_key(key, mod);
last_key->keylist.push_back(temp_key);
last_key = temp_key;
}
2001-12-11 20:47:02 +00:00
}
}
} else {
unsigned int i=0;
for (i=0; i< LASTKEYGRAB; i++) {
// +1 on the val[argc] because we dont want to compare the ':'
if (strcasecmp(m_actionlist[i].string, val[argc].c_str()+1) == 0)
2001-12-11 20:47:02 +00:00
break;
}
if (i < LASTKEYGRAB ) {
2001-12-11 20:47:02 +00:00
if (!current_key) {
cerr<<"Error on line: "<<line<<endl;
cerr<<linebuffer.get()<<endl;
2001-12-11 20:47:02 +00:00
delete current_key;
current_key = 0;
last_key = 0;
break; //break out and read next line
}
//special case for grabAbortKeychain
if (m_actionlist[i].action == ABORTKEYCHAIN) {
2001-12-11 20:47:02 +00:00
if (last_key!=current_key)
cerr<<"Keys: "<<m_actionlist[i].string<<" cant be in chained mode"<<endl;
else if (m_abortkey)
cerr<<"Keys: "<<m_actionlist[i].string<<" is already bound."<<endl;
else
m_abortkey = new t_key(current_key->key, current_key->mod, ABORTKEYCHAIN);
2001-12-11 20:47:02 +00:00
delete current_key;
current_key = 0;
last_key = 0;
break; //break out and read next line
}
last_key->action = m_actionlist[i].action;
2002-02-21 00:39:08 +00:00
switch(last_key->action) {
case Keys::EXECUTE:
last_key->execcommand =
2002-02-21 00:39:08 +00:00
const_cast<char *>
(StringUtil::strcasestr(linebuffer.get(),
getActionStr(Keys::EXECUTE))+
strlen(getActionStr(Keys::EXECUTE)));
2002-02-21 00:39:08 +00:00
break;
case WORKSPACE:
2002-02-26 22:19:51 +00:00
case SENDTOWORKSPACE:
2002-02-21 00:39:08 +00:00
if (argc + 1 < val.size())
last_key->param = atoi( val[argc+1].c_str());
else
last_key->param = 0;
break;
case LEFTWORKSPACE:
case RIGHTWORKSPACE:
case NEXTWORKSPACE:
case PREVWORKSPACE:
if (argc + 1 < val.size())
last_key->param = atoi( val[argc+1].c_str());
else
last_key->param = 1;
break;
case NUDGERIGHT:
case NUDGELEFT:
case NUDGEUP:
case NUDGEDOWN:
if (argc + 1 < val.size())
last_key->param = atoi( val[argc+1].c_str());
else
last_key->param = 2;
break;
default:
break;
}
2001-12-11 20:47:02 +00:00
//add the keychain to list
if (!mergeTree(current_key))
2002-01-08 21:45:49 +00:00
cerr<<"Keys: Failed to merge keytree!"<<endl;
2001-12-11 20:47:02 +00:00
//clear keypointers now that we have them in m_keylist
delete current_key;
current_key = 0;
last_key = 0;
} else { //destroy list if no action is found
#ifdef DEBUG
cerr<<"Didnt find action="<<val[argc]<<endl;
2001-12-11 20:47:02 +00:00
#endif
//destroy current_key ... this will also destroy the last_key
delete current_key;
current_key = 0;
last_key = 0;
}
break; //dont process this linebuffer more
}
2001-12-11 20:47:02 +00:00
}
}
2001-12-11 20:47:02 +00:00
return true;
}
2002-01-05 12:01:16 +00:00
//--------- grabKey ---------------------
2001-12-11 20:47:02 +00:00
// Grabs a key with the modifier
// and with numlock,capslock and scrollock
2002-01-05 12:01:16 +00:00
//----------------------------------------
2001-12-11 20:47:02 +00:00
void Keys::grabKey(unsigned int key, unsigned int mod) {
for (int screen=0; screen<ScreenCount(m_display); screen++) {
Window root = RootWindow(m_display, screen);
XGrabKey(m_display, key, mod,
root, True,
GrabModeAsync, GrabModeAsync);
2001-12-11 20:47:02 +00:00
// Grab with numlock, capslock and scrlock
//numlock
XGrabKey(m_display, key, mod|Mod2Mask,
root, True,
GrabModeAsync, GrabModeAsync);
2001-12-11 20:47:02 +00:00
//scrolllock
XGrabKey(m_display, key, mod|Mod5Mask,
root, True,
GrabModeAsync, GrabModeAsync);
2001-12-11 20:47:02 +00:00
//capslock
XGrabKey(m_display, key, mod|LockMask,
root, True,
GrabModeAsync, GrabModeAsync);
2001-12-11 20:47:02 +00:00
//capslock+numlock
XGrabKey(m_display, key, mod|LockMask|Mod2Mask,
root, True,
GrabModeAsync, GrabModeAsync);
2001-12-11 20:47:02 +00:00
//capslock+scrolllock
XGrabKey(m_display, key, mod|LockMask|Mod5Mask,
root, True,
GrabModeAsync, GrabModeAsync);
2001-12-11 20:47:02 +00:00
//capslock+numlock+scrolllock
XGrabKey(m_display, key, mod|Mod2Mask|Mod5Mask|LockMask,
root, True,
GrabModeAsync, GrabModeAsync);
2001-12-11 20:47:02 +00:00
//numlock+scrollLock
XGrabKey(m_display, key, mod|Mod2Mask|Mod5Mask,
root, True,
GrabModeAsync, GrabModeAsync);
2001-12-11 20:47:02 +00:00
}
}
//------------ getModifier ---------------
// Returns the modifier for the modstr
// else zero on failure.
// TODO fix more masks
//----------------------------------------
unsigned int Keys::getModifier(const char *modstr) {
2001-12-11 20:47:02 +00:00
if (!modstr)
return 0;
struct t_modlist{
char *string;
unsigned int mask;
bool operator == (const char *modstr) {
2001-12-11 20:47:02 +00:00
return (strcasecmp(string, modstr) == 0 && mask !=0);
}
} modlist[] = {
{"SHIFT", ShiftMask},
{"CONTROL", ControlMask},
{"MOD1", Mod1Mask},
{"MOD2", Mod2Mask},
{"MOD3", Mod3Mask},
{"MOD4", Mod4Mask},
{"MOD5", Mod5Mask},
{0, 0}
2001-12-11 20:47:02 +00:00
};
for (unsigned int i=0; modlist[i].string!=0; i++) {
if (modlist[i]==modstr)
return modlist[i].mask;
}
return 0;
}
//----------- getKey ----------------
// Returns keycode of keystr on success
// else it returns zero
//-----------------------------------
unsigned int Keys::getKey(const char *keystr) {
2001-12-11 20:47:02 +00:00
if (!keystr)
return 0;
return XKeysymToKeycode(m_display,
XStringToKeysym(keystr));
2001-12-11 20:47:02 +00:00
}
//--------- getAction -----------------
// returns the KeyAction of the XKeyEvent
//-------------------------------------
Keys::KeyAction Keys::getAction(XKeyEvent *ke) {
static t_key *next_key = 0;
//remove numlock, capslock and scrolllock
ke->state &= ~Mod2Mask & ~Mod5Mask & ~LockMask;
if (m_abortkey && *m_abortkey==ke) { //abort current keychain
next_key = 0;
return m_abortkey->action;
}
if (!next_key) {
for (unsigned int i=0; i<m_keylist.size(); i++) {
if (*m_keylist[i] == ke) {
if (m_keylist[i]->keylist.size()) {
next_key = m_keylist[i];
break; //end for-loop
} else {
if (m_keylist[i]->action == Keys::EXECUTE)
2001-12-11 20:47:02 +00:00
m_execcmdstring = m_keylist[i]->execcommand; //update execcmdstring if action is grabExecute
2002-02-21 00:39:08 +00:00
m_param = m_keylist[i]->param;
2001-12-11 20:47:02 +00:00
return m_keylist[i]->action;
}
}
}
} else { //check the nextkey
t_key *temp_key = next_key->find(ke);
if (temp_key) {
if (temp_key->keylist.size()) {
next_key = temp_key;
} else {
next_key = 0;
if (temp_key->action == Keys::EXECUTE)
2001-12-11 20:47:02 +00:00
m_execcmdstring = temp_key->execcommand; //update execcmdstring if action is grabExecute
return temp_key->action;
}
} else {
temp_key = next_key;
next_key = 0;
if (temp_key->action == Keys::EXECUTE)
2001-12-11 20:47:02 +00:00
m_execcmdstring = temp_key->execcommand; //update execcmdstring if action is grabExecute
return temp_key->action;
}
}
return Keys::LASTKEYGRAB;
2001-12-11 20:47:02 +00:00
}
//--------- reconfigure -------------
// deletes the tree and load configuration
// returns true on success else false
//-----------------------------------
bool Keys::reconfigure(char *filename) {
deleteTree();
return load(filename);
}
//------------- getActionStr ------------------
// Tries to find the action for the key
// Returns actionstring on success else
// 0 on failure
//---------------------------------------------
const char *Keys::getActionStr(KeyAction action) {
for (unsigned int i=0; m_actionlist[i].string!=0 ; i++) {
if (m_actionlist[i].action == action)
return m_actionlist[i].string;
}
return 0;
}
#ifdef DEBUG
//--------- showTree -----------
// Debug function that show the
// keytree. Starts with the
// rootlist
//------------------------------
void Keys::showTree() {
for (unsigned int i=0; i<m_keylist.size(); i++) {
if (m_keylist[i]) {
cerr<<i<<" ";
showKeyTree(m_keylist[i]);
} else
cerr<<"Null @ "<<i<<endl;
}
}
//---------- showKeyTree --------
// Debug function to show t_key tree
//-------------------------------
void Keys::showKeyTree(t_key *key, unsigned int w) {
for (unsigned int i=0; i<w+1; i++)
cerr<<"-";
if (!key->keylist.empty()) {
for (unsigned int i=0; i<key->keylist.size(); i++) {
cerr<<"( "<<(int)key->key<<" "<<(int)key->mod<<" )";
showKeyTree(key->keylist[i], 4);
cerr<<endl;
}
} else
cerr<<"( "<<(int)key->key<<" "<<(int)key->mod<<" ) {"<<getActionStr(key->action)<<"}"<<endl;
}
#endif //DEBUG
//------------ mergeTree ---------------
// Merges two chains and binds new keys
// Returns true on success else false.
//---------------------------------------
bool Keys::mergeTree(t_key *newtree, t_key *basetree) {
if (basetree==0) {
unsigned int baselist_i=0;
for (; baselist_i<m_keylist.size(); baselist_i++) {
if (m_keylist[baselist_i]->mod == newtree->mod &&
m_keylist[baselist_i]->key == newtree->key) {
if (newtree->keylist.size() && m_keylist[baselist_i]->action == LASTKEYGRAB) {
2001-12-11 20:47:02 +00:00
//assumes the newtree only have one branch
return mergeTree(newtree->keylist[0], m_keylist[baselist_i]);
} else
break;
}
}
if (baselist_i == m_keylist.size()) {
grabKey(newtree->key, newtree->mod);
m_keylist.push_back(new t_key(newtree));
if (newtree->keylist.size())
return mergeTree(newtree->keylist[0], m_keylist.back());
return true;
}
} else {
unsigned int baselist_i = 0;
for (; baselist_i<basetree->keylist.size(); baselist_i++) {
if (basetree->keylist[baselist_i]->mod == newtree->mod &&
basetree->keylist[baselist_i]->key == newtree->key) {
if (newtree->keylist.size()) {
//assumes the newtree only have on branch
return mergeTree(newtree->keylist[0], basetree->keylist[baselist_i]);
} else
return false;
}
}
//if it wasn't in the list grab the key and add it to the list
if (baselist_i==basetree->keylist.size()) {
grabKey(newtree->key, newtree->mod);
basetree->keylist.push_back(new t_key(newtree));
if (newtree->keylist.size())
return mergeTree(newtree->keylist[0], basetree->keylist.back());
return true;
}
}
return false;
}
Keys::t_key::t_key(unsigned int key_, unsigned int mod_, KeyAction action_) {
action = action_;
key = key_;
mod = mod_;
2002-02-21 00:39:08 +00:00
param = 0;
2001-12-11 20:47:02 +00:00
}
Keys::t_key::t_key(t_key *k) {
action = k->action;
key = k->key;
mod = k->mod;
execcommand = k->execcommand;
2002-02-21 00:39:08 +00:00
param = k-> param;
2001-12-11 20:47:02 +00:00
}
Keys::t_key::~t_key() {
while (!keylist.empty()) {
t_key *k = keylist.back();
delete k;
keylist.pop_back();
}
}