-/* This file is part of
- * ======================================================
- *
- * LyX, The Document Processor
- *
- * Copyright 1995 Matthias Ettrich
- * Copyright 1995-2000 The LyX Team.
+/**
+ * \file kbmap.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
*
- * ====================================================== */
+ * \author Lars Gullik Bjønnes
+ * \author Jean-Marc Lasgouttes
+ * \author John Levon
+ * \author André Pönitz
+ *
+ * Full author contact details are available in file CREDITS.
+ */
#include <config.h>
-#include <cstring>
-#include <X11/Xlib.h>
-
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
#include "kbmap.h"
-#include "kbsequence.h"
+
#include "debug.h"
+#include "kbsequence.h"
+#include "LyXAction.h"
+#include "lyxlex.h"
-using std::endl;
+#include "frontends/LyXKeySym.h"
-// The only modifiers that we handle. We want to throw away things
-// like NumLock.
-enum { ModsMask = ShiftMask | ControlMask | Mod1Mask };
+#include "support/filetools.h"
+#include <sstream>
-// === static functions ===================================================
+namespace lyx {
-/* ---F+------------------------------------------------------------------ *\
- Function : printKeysym
- Called by : kb_sequence::print and printKeyMap. RVDK_PATCH_5
- Purpose : prints a keysym, including modifiers.
- Parameters: key - keysym
- mod - modifiers
- buf - string where the result goes
- maxlen - length of string (including '\0')
- Returns : length of printed string if ok, 0 otherwise.
-\* ---F------------------------------------------------------------------- */
-void printKeysym(unsigned int key, unsigned int mod, string & buf)
-{
- mod &= ModsMask;
-
- char * s = XKeysymToString(key);
-
- if (mod & ShiftMask) buf += "S-";
- if (mod & ControlMask) buf += "C-";
- if (mod & Mod1Mask) buf += "M-";
- if (s) buf += s;
-}
+using support::FileName;
+using support::i18nLibFileSearch;
+using std::endl;
+using std::string;
-/* ---F+------------------------------------------------------------------ *\
- Function : printKeyTab
- Called by : kb_keymap::print
- Purpose : print the keysyms found in the given key table. RVDK_PATCH_5
- Parameters: tabPt - keytable pointer
- buf - string where the result goes
- maxLen - length of string (including '\0')
- Returns : length of printed string.
-\* ---F------------------------------------------------------------------- */
-void kb_keymap::printKey(kb_key const & key, string & buf)
+string const kb_keymap::printKeySym(LyXKeySym const & key,
+ key_modifier::state mod)
{
- printKeysym(key.code, key.mod & 0xffff, buf);
+ string buf;
+
+ string const s = key.getSymbolName();
+
+ if (mod & key_modifier::shift)
+ buf += "S-";
+ if (mod & key_modifier::ctrl)
+ buf += "C-";
+ if (mod & key_modifier::alt)
+ buf += "M-";
+
+ buf += s;
+ return buf;
}
-// This binds a key to an action
-int kb_keymap::bind(string const & seq, int action)
+string::size_type kb_keymap::bind(string const & seq, FuncRequest const & func)
{
- kb_sequence k;
+ if (lyxerr.debugging(Debug::KBMAP)) {
+ lyxerr << "BIND: Sequence `"
+ << seq << "' Action `"
+ << func.action << '\'' << endl;
+ }
+
+ kb_sequence k(0, 0);
- int res = k.parse(seq);
- if (!res) {
- defkey(&k, action);
- } else
- lyxerr[Debug::KBMAP] << "Parse error at position " << res
+ string::size_type const res = k.parse(seq);
+ if (res == string::npos) {
+ defkey(&k, func);
+ } else {
+ LYXERR(Debug::KBMAP) << "Parse error at position " << res
<< " in key sequence '" << seq << "'."
<< endl;
+ }
+
return res;
}
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_keymap::lookup
- Called by : [user], kb_sequence::add()
- Purpose : look up a key press in a given keymap
- Parameters: key - the keysym of the key press
- mod - the modifier mask of the keypress
- seq - the key-sequence retrieved so far
- Returns : user defined action; 0 for prefix key, -1 if key not found
-\* ---F------------------------------------------------------------------- */
+namespace {
-int kb_keymap::lookup(unsigned int key,
- unsigned int mod, kb_sequence * seq) const
+enum BindTags {
+ BN_BIND,
+ BN_BINDFILE
+};
+
+keyword_item bindTags[] = {
+ { "\\bind", BN_BIND },
+ { "\\bind_file", BN_BINDFILE }
+};
+
+}
+
+
+bool kb_keymap::read(string const & bind_file)
{
+ const int bindCount = sizeof(bindTags) / sizeof(keyword_item);
+
+ LyXLex lexrc(bindTags, bindCount);
+ if (lyxerr.debugging(Debug::PARSER))
+ lexrc.printTable(lyxerr);
+
+ FileName const tmp(i18nLibFileSearch("bind", bind_file, "bind"));
+ lexrc.setFile(tmp);
+ if (!lexrc.isOK()) {
+ lyxerr << "kb_keymap::read: cannot open bind file:"
+ << tmp << endl;
+ return false;
+ }
+
+ LYXERR(Debug::KBMAP) << "Reading bind file:" << tmp << endl;
+
+ bool error = false;
+ while (lexrc.isOK()) {
+ switch (lexrc.lex()) {
+ case LyXLex::LEX_UNDEF:
+ lexrc.printError("Unknown tag `$$Token'");
+ error = true;
+ continue;
+ case LyXLex::LEX_FEOF:
+ continue;
+ case BN_BIND:
+ {
+ string seq, cmd;
+
+ if (lexrc.next()) {
+ seq = lexrc.getString();
+ } else {
+ lexrc.printError("BN_BIND: Missing key sequence");
+ error = true;
+ break;
+ }
+
+ if (lexrc.next(true)) {
+ cmd = lexrc.getString();
+ } else {
+ lexrc.printError("BN_BIND: missing command");
+ error = true;
+ break;
+ }
+
+ FuncRequest func = lyxaction.lookupFunc(cmd);
+ if (func. action == LFUN_UNKNOWN_ACTION) {
+ lexrc.printError("BN_BIND: Unknown LyX"
+ " function `$$Token'");
+ error = true;
+ break;
+ }
+
+ bind(seq, func);
+ break;
+ }
+ case BN_BINDFILE:
+ if (lexrc.next()) {
+ string const tmp(lexrc.getString());
+ error |= !read(tmp);
+ } else {
+ lexrc.printError("BN_BINDFILE: Missing file name");
+ error = true;
+ break;
+
+ }
+ break;
+ }
+ }
+
+ if (error)
+ lyxerr << "kb_keymap::read: error while reading bind file:"
+ << tmp << endl;
+ return !error;
+}
+
+
+FuncRequest const &
+kb_keymap::lookup(LyXKeySymPtr key,
+ key_modifier::state mod, kb_sequence * seq) const
+{
+ static FuncRequest const unknown(LFUN_UNKNOWN_ACTION);
+
if (table.empty()) {
seq->curmap = seq->stdmap;
- seq->delseq();
- return -1;
+ seq->mark_deleted();
+ return unknown;
}
- unsigned int msk1, msk0;
- //suppress modifier bits we do not handle
- mod &= ModsMask;
-
- for (Table::const_iterator cit = table.begin();
- cit != table.end(); ++cit) {
- msk1 = (*cit).mod & 0xffff;
- msk0 = ((*cit).mod >> 16) & 0xffff;
- if ((*cit).code == key && (mod & ~msk0) == msk1) {
- // math found:
- if ((*cit).table) {
+ Table::const_iterator end = table.end();
+ for (Table::const_iterator cit = table.begin(); cit != end; ++cit) {
+ key_modifier::state mask(cit->mod.second);
+ key_modifier::state check =
+ static_cast<key_modifier::state>(mod & ~mask);
+
+ if (*(cit->code) == *key && cit->mod.first == check) {
+ // match found
+ if (cit->table.get()) {
// this is a prefix key - set new map
- seq->curmap = (*cit).table;
- return 0;
+ seq->curmap = cit->table.get();
+ static FuncRequest prefix(LFUN_COMMAND_PREFIX);
+ return prefix;
} else {
// final key - reset map
seq->curmap = seq->stdmap;
- seq->delseq();
- return (*cit).action;
+ seq->mark_deleted();
+ return cit->func;
}
}
}
// error - key not found:
seq->curmap = seq->stdmap;
- seq->delseq();
- return -1;
-}
+ seq->mark_deleted();
+ return unknown;
+}
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_keymap::print
- Called by : [user]
- Purpose : Prints all the available keysyms. RVDK_PATCH_5
- Parameters: buf - string where output goes.
- maxLen - available length in string, including `\0'.
- Returns : updated maxLen.
-\* ---F------------------------------------------------------------------- */
-void kb_keymap::print(string & buf) const
+docstring const kb_keymap::print(bool forgui) const
{
- for (Table::const_iterator cit = table.begin();
- cit != table.end(); ++cit) {
- printKey((*cit), buf);
+ docstring buf;
+ Table::const_iterator end = table.end();
+ for (Table::const_iterator cit = table.begin(); cit != end; ++cit) {
+ buf += cit->code->print(cit->mod.first, forgui);
buf += ' ';
}
+ return buf;
}
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_keymap::defkey
- Called by : [user]
- Purpose : define an action for a key sequence
- Parameters: seq - the key sequence
- action - the action to be defined
- idx - recursion depth
- Returns : 0 if ok.
-\* ---F------------------------------------------------------------------- */
-
-int kb_keymap::defkey(kb_sequence * seq, int action, int idx /*= 0*/)
+void kb_keymap::defkey(kb_sequence * seq,
+ FuncRequest const & func, unsigned int r)
{
- unsigned int code = seq->sequence[idx];
- if(code == NoSymbol) return -1;
+ LyXKeySymPtr code = seq->sequence[r];
+ if (!code->isOK())
+ return;
- unsigned int modmsk = seq->modifiers[idx];
+ key_modifier::state const mod1 = seq->modifiers[r].first;
+ key_modifier::state const mod2 = seq->modifiers[r].second;
- // --- check if key is already there --------------------------------
- if (table.size() != 0) { // without this I get strange crashes
- Table::iterator end = table.end();
+ // check if key is already there
+ Table::iterator end = table.end();
for (Table::iterator it = table.begin(); it != end; ++it) {
- if (code == (*it).code && modmsk == (*it).mod) {
+ if (*(code) == *(it->code)
+ && mod1 == it->mod.first
+ && mod2 == it->mod.second) {
// overwrite binding
- if (idx + 1 == seq->length) {
- string buf;
- seq->print(buf, true);
- lyxerr[Debug::KBMAP]
+ if (r + 1 == seq->length()) {
+ LYXERR(Debug::KBMAP)
<< "Warning: New binding for '"
- << buf
+ << to_utf8(seq->print(false))
<< "' is overriding old binding..."
<< endl;
- if((*it).table) {
- delete (*it).table;
- (*it).table = 0;
+ if (it->table.get()) {
+ it->table.reset();
}
- (*it).action = action;
- return 0;
- } else if (!(*it).table) {
- string buf;
- seq->print(buf, true);
- lyxerr << "Error: New binding for '" << buf
+ it->func = func;
+ it->func.origin = FuncRequest::KEYBOARD;
+ return;
+ } else if (!it->table.get()) {
+ lyxerr << "Error: New binding for '"
+ << to_utf8(seq->print(false))
<< "' is overriding old binding..."
- << endl;
- return -1;
+ << endl;
+ return;
} else {
- return (*it).table->defkey(seq, action,
- idx + 1);
+ it->table->defkey(seq, func, r + 1);
+ return;
}
}
}
- }
-
+
Table::iterator newone = table.insert(table.end(), kb_key());
- (*newone).code = code;
- (*newone).mod = modmsk;
- if (idx + 1 == seq->length) {
- (*newone).action = action;
- (*newone).table = 0;
- return 0;
+ newone->code = code;
+ newone->mod = seq->modifiers[r];
+ if (r + 1 == seq->length()) {
+ newone->func = func;
+ newone->func.origin = FuncRequest::KEYBOARD;
+ newone->table.reset();
} else {
- (*newone).table = new kb_keymap;
- return (*newone).table->defkey(seq, action, idx + 1);
+ newone->table.reset(new kb_keymap);
+ newone->table->defkey(seq, func, r + 1);
}
}
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_keymap::~kb_keymap
- Called by : [destructor]
- Purpose : free keymap and its descendents
- Parameters: none
- Returns : nothing
-\* ---F------------------------------------------------------------------- */
-
-kb_keymap::~kb_keymap()
+docstring const kb_keymap::printbindings(FuncRequest const & func) const
{
- // This could be done by a destructor in kb_key.
- Table::iterator end = table.end();
- for (Table::iterator it = table.begin(); it != end; ++it) {
- delete (*it).table;
- }
+ odocstringstream res;
+ Bindings bindings = findbindings(func);
+ for (Bindings::const_iterator cit = bindings.begin();
+ cit != bindings.end() ; ++cit)
+ res << '[' << cit->print(true) << ']';
+ return res.str();
}
-string const kb_keymap::keyname(kb_key const & k)
+kb_keymap::Bindings
+kb_keymap::findbindings(FuncRequest const & func) const
{
- string buf;
- printKeysym(k.code, k.mod, buf);
- return buf;
+ return findbindings(func, kb_sequence(0, 0));
}
-// Finds a key for a keyaction, if possible
-string const kb_keymap::findbinding(int act) const
+kb_keymap::Bindings
+kb_keymap::findbindings(FuncRequest const & func,
+ kb_sequence const & prefix) const
{
- string res;
+ Bindings res;
if (table.empty()) return res;
Table::const_iterator end = table.end();
for (Table::const_iterator cit = table.begin();
cit != end; ++cit) {
- if ((*cit).table) {
- string suffix = (*cit).table->findbinding(act);
- suffix = strip(suffix, ' ');
- suffix = strip(suffix, ']');
- suffix = frontStrip(suffix, '[');
- if (!suffix.empty()) {
- res += "[" + keyname((*cit)) + " "
- + suffix + "] ";
- }
- } else if ((*cit).action == act) {
- res += "[";
- res += keyname((*cit));
- res += "] ";
+ if (cit->table.get()) {
+ kb_sequence seq = prefix;
+ seq.addkey(cit->code, cit->mod.first);
+ Bindings res2 =
+ cit->table->findbindings(func, seq);
+ res.insert(res.end(), res2.begin(), res2.end());
+ } else if (cit->func == func) {
+ kb_sequence seq = prefix;
+ seq.addkey(cit->code, cit->mod.first);
+ res.push_back(seq);
}
}
+
return res;
}
-/* === End of File: kbmap.C ============================================== */
+
+std::pair<LyXKeySym const *, key_modifier::state>
+kb_keymap::find1keybinding(FuncRequest const & func) const
+{
+ Table::const_iterator end = table.end();
+ for (Table::const_iterator cit = table.begin();
+ cit != end; ++cit) {
+ if (!cit->table.get() && cit->func == func)
+ return std::make_pair(cit->code.get(), cit->mod.first);
+ }
+
+ return std::make_pair<LyXKeySym const *, key_modifier::state>(0, key_modifier::none);
+}
+
+
+} // namespace lyx