* LyX, The Document Processor
*
* Copyright 1995 Matthias Ettrich
- * Copyright 1995-1999 The LyX Team.
+ * Copyright 1995-2000 The LyX Team.
*
* ====================================================== */
#include <config.h>
+
#include <cstring>
-#include <cstdio>
-#include "support/lstrings.h"
-#include "gettext.h"
+#include <X11/Xlib.h>
#ifdef __GNUG__
#pragma implementation
#endif
#include "kbmap.h"
+#include "kbsequence.h"
#include "debug.h"
+using std::endl;
+
// The only modifiers that we handle. We want to throw away things
// like NumLock.
-enum { ModsMask = ShiftMask | ControlMask | Mod1Mask};
+enum { ModsMask = ShiftMask | ControlMask | Mod1Mask };
// === static functions ===================================================
maxlen - length of string (including '\0')
Returns : length of printed string if ok, 0 otherwise.
\* ---F------------------------------------------------------------------- */
-static
-void printKeysym( KeySym key, unsigned int mod, string & buf)
+void printKeysym(unsigned int key, unsigned int mod, string & buf)
{
mod &= ModsMask;
- char * s = XKeysymToString(key);
+ char const * const s = XKeysymToString(key);
if (mod & ShiftMask) buf += "S-";
if (mod & ControlMask) buf += "C-";
Returns : length of printed string.
\* ---F------------------------------------------------------------------- */
-static
-void printKeyTab( kb_key * tabPt, string & buf)
-{
- unsigned int ksym, mod;
-
- /* -------> Print each of the slots into buf. */
- for( ; (tabPt->code & 0xffff) != NoSymbol; ++tabPt) {
- ksym = tabPt->code;
- mod = tabPt->mod & 0xffff;
-
- printKeysym(ksym, mod, buf);
- buf += ' ';
- }
-}
-
-
-// === kb_sequence methods ================================================
-
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_sequence::addkey
- Called by : [user]
- Purpose : add a key to the sequence, look up in map and return action
- Parameters: key - keysym of key
- mod - modifier mask
- nmod - modifier veto mask (unused now)
- Returns : action or -1 if error (no map defined or key not found)
-\* ---F------------------------------------------------------------------- */
-
-int kb_sequence::addkey(KeySym key,
- unsigned int mod, unsigned int nmod /*= 0*/)
-{
- if(length < 0) length = 0;
-
- if(length + 1 >= size) {
- unsigned int * nseq = new unsigned int[size + KB_PREALLOC];
- size += KB_PREALLOC;
- memcpy(nseq, sequence, length * sizeof(unsigned int));
- if(sequence != staticseq) delete sequence;
- sequence = nseq;
- nseq = new unsigned int[size];
- memcpy(nseq, modifiers, length * sizeof(unsigned int));
- if(modifiers != staticmod) delete modifiers;
- modifiers = nseq;
- }
-
- modifiers[length] = mod + (nmod << 16);
- sequence[length++] = key;
-
- if(curmap)
- return curmap->lookup(key, mod, this);
-
- return -1;
-}
-
-
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_sequence::parse
- Called by : [user]
- Purpose : parse a string that holds a key sequence and add the keys
- Parameters: s - string holding the key sequence
- Returns : 0 - if ok, error pos if error
- Note : Keys must be separated with whitespace;
- Use the keysym names used by XStringToKeysym
- Prefixes are S-, C-, M- for shift, control, meta
-\* ---F------------------------------------------------------------------- */
-
-int kb_sequence::parse(char const * s)
+void kb_keymap::printKey(kb_key const & key, string & buf)
{
- int i = 0;
- unsigned int mod = 0, nmod = 0;
- KeySym key = 0;
- char tbuf[100];
-
- if(!s[0]) return 1;
-
- while(s[i]) {
- if(s[i] && (s[i]) <= ' ') ++i;
- if(!s[i]) break;
-
- if(s[i+1] == '-') { // is implicit that s[i] == true
- switch(s[i]) {
- case 's': case 'S':
- mod |= ShiftMask;
- i+= 2;
- continue;
- case 'c': case 'C':
- mod |= ControlMask;
- i+= 2;
- continue;
- case 'm': case 'M':
- mod |= Mod1Mask;
- i+= 2;
- continue;
- default:
- return i+1;
- }
- } else if(s[i] == '~' && s[i+1] && s[i+2] == '-') {
- switch(s[i+1]) {
- case 's': case 'S':
- nmod |= ShiftMask;
- i+= 3;
- continue;
- case 'c': case 'C':
- nmod |= ControlMask;
- i+= 3;
- continue;
- case 'm': case 'M':
- nmod |= Mod1Mask;
- i+= 3;
- continue;
- default:
- return i+2;
- }
- } else {
- int j = 0;
- for(j = i; s[j] && s[j] > ' '; ++j)
- tbuf[j-i] = s[j]; // (!!!check bounds :-)
-
- tbuf[j-i] = '\0';
-
- key = XStringToKeysym(tbuf);
- if(key == NoSymbol) {
- lyxerr[Debug::KBMAP]
- << "kbmap.C: No such keysym: "
- << tbuf << endl;
- return j;
- }
- i = j;
-
- addkey(key, mod, nmod);
- mod = 0;
- nmod = 0;
- }
- }
- return 0;
+ printKeysym(key.code, key.mod & 0xffff, buf);
}
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_sequence::print
- Called by : [user]
- Purpose : print the currently defined sequence into a string
- Parameters: buf - string where the result goes
- maxlen - length of string (including '\0')
- when_defined - only print when sequence is real: length > 0.
- Returns : 0, if ok, -1 if string too long
-\* ---F------------------------------------------------------------------- */
-
-int kb_sequence::print(string & buf, bool when_defined) const
+// This binds a key to an action
+int kb_keymap::bind(string const & seq, int action)
{
- KeySym key;
- unsigned int mod;
- int l = length;
- if ( l < 0 && !when_defined ) l = -l;
-
- for(int i = 0; i < l; ++i) {
- key = sequence[i];
- mod = modifiers[i] & 0xffff;
-
- printKeysym(key, mod, buf); // RVDK_PATCH_5
-
- if(i + 1 < l) { // append a blank
- buf += ' ';
- }
+ if (lyxerr.debugging(Debug::KBMAP)) {
+ lyxerr << "BIND: Sequence `"
+ << seq << "' Action `"
+ << action << "'" << endl;
}
- return 0;
-}
-
-
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_sequence::printOptions
- Called by : [user]
- Purpose : print the available key options from the current state in the
- sequence. RVDK_PATCH_5
- Parameters: buf - string where the result goes
- maxlen - length of string (including '\0')
- Returns : 0, if ok, -1 if string too long
-\* ---F------------------------------------------------------------------- */
-
-int kb_sequence::printOptions(string & buf) const
-{
- print(buf, true);
- if (!curmap) return -1;
- buf += _(" options: ");
- curmap->print(buf);
- return 0;
-}
-
-
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_sequence::delseq
- Called by : [user]
- Purpose : mark the sequence as deleted
- Parameters: none
- Returns : nothing
-\* ---F------------------------------------------------------------------- */
-
-void kb_sequence::delseq()
-{
- // negative length marks sequence as deleted, but we can still
- // print() it or retrieve the last char using getiso()
- length = -length;
-}
-
-
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_sequence::getsym
- Called by : [user], getiso
- Purpose : get the keysym of the last key in sequence
- Parameters: none
- Returns : keysym
-\* ---F------------------------------------------------------------------- */
-
-KeySym kb_sequence::getsym()
-{
- int l = length;
- if(l == 0) return NoSymbol;
- if(l < 0) l = -l;
- return sequence[l-1];
-}
-
-
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_sequence::getiso
- Called by : [user]
- Purpose : return iso character code of last key, if any
- Parameters: none
- Returns : iso code or 0 if none
-\* ---F------------------------------------------------------------------- */
-
-char kb_sequence::getiso()
-{
- int c = getsym();
-
- if(c > 0xff)
- return '\0';
- return c;
-}
-
-
-/* ---F+------------------------------------------------------------------ *\
- Function : kb_sequence::reset
- Called by : [user]
- Purpose : reset sequence to initial state. RVDK_PATCH_5
- Parameters: none
- Returns : void
-\* ---F------------------------------------------------------------------- */
-
-void kb_sequence::reset()
-{
- delseq();
- curmap = stdmap;
- if ( length > 0 ) length = -length;
-}
-
-
-// === kb_keymap methods ==================================================
-
-// This binds a key to an action
-int kb_keymap::bind(char const * seq, int action)
-{
kb_sequence k;
- int res = k.parse(seq);
+ int const res = k.parse(seq);
if (!res) {
defkey(&k, action);
} else
Returns : user defined action; 0 for prefix key, -1 if key not found
\* ---F------------------------------------------------------------------- */
-int kb_keymap::lookup(KeySym key, unsigned int mod, kb_sequence * seq)
+int kb_keymap::lookup(unsigned int key,
+ unsigned int mod, kb_sequence * seq) const
{
-#ifndef NO_HASH
- unsigned int hashval;
-#endif
- unsigned int ksym, msk1, msk0;
- kb_key * tab;
-
- //suppress modifier bits we do not handle
- mod &= ModsMask;
-
- if(!table) {
- // error - no keymap defined:
+ if (table.empty()) {
seq->curmap = seq->stdmap;
seq->delseq();
return -1;
}
-#ifndef NO_HASH
- if(size < 0) { // --- if hash table ---
- hashval = ((key&0xff) ^ ((key>>8)&0xff)) % KB_HASHSIZE;
- tab = htable[hashval];
- if(!tab) {
- seq->curmap = seq->stdmap;
- seq->delseq();
- return -1;
- }
- } else // --- else: linear list ---
-#endif
- tab = table;
-
- // --- now search the list of keys ---
-
- for( ; (tab->code & 0xffff) != NoSymbol; ++tab) {
- ksym = tab->code;
- msk1 = tab->mod & 0xffff;
- msk0 = (tab->mod >> 16) & 0xffff;
+ //unsigned int msk1, msk0;
+ //suppress modifier bits we do not handle
+ mod &= ModsMask;
- if(ksym == key && (mod & ~msk0) == msk1) {
- // match found:
- if(tab->table) {
+ for (Table::const_iterator cit = table.begin();
+ cit != table.end(); ++cit) {
+ unsigned int const msk1 = (*cit).mod & 0xffff;
+ unsigned int const msk0 = ((*cit).mod >> 16) & 0xffff;
+ if ((*cit).code == key && (mod & ~msk0) == msk1) {
+ // math found:
+ if ((*cit).table) {
// this is a prefix key - set new map
- seq->curmap = tab->table;
+ seq->curmap = (*cit).table;
return 0;
} else {
// final key - reset map
seq->curmap = seq->stdmap;
seq->delseq();
- return tab->action; // ... and return action
+ return (*cit).action;
}
}
}
-
+
// error - key not found:
seq->curmap = seq->stdmap;
seq->delseq();
void kb_keymap::print(string & buf) const
{
- // Return when keymap has no table.
- if (!table) return;
-
- // Process each of its slots recursively and return.
-#ifndef NO_HASH
- if ( size < 0 ) { // Hash table
- for ( int ix = 0; ix < KB_HASHSIZE; ++ix ) {
- if ( htable[ix] ) {
- printKeyTab(htable[ix], buf);
- }
- }
- } else // Normal table
-#endif
- printKeyTab(table, buf);
+ for (Table::const_iterator cit = table.begin();
+ cit != table.end(); ++cit) {
+ printKey((*cit), buf);
+ buf += ' ';
+ }
}
int kb_keymap::defkey(kb_sequence * seq, int action, int idx /*= 0*/)
{
- unsigned int code = seq->sequence[idx];
- if(code == NoSymbol) return -1;
-
- unsigned int modmsk = seq->modifiers[idx];
- kb_key * tab, ** ptab;
- // --- get list------------------------------------------------------
- if(!table) {
- // If we don't have any yet, make an empty one
- table = new kb_key[KB_PREALLOC];
- table[0].code = NoSymbol;
- tab = table;
- ptab = &table;
- size = KB_PREALLOC;
-#ifndef NO_HASH
- } else if(size < 0) {
- // Hash table.
- int hashval = code & 0xffff;
- hashval = ((hashval & 0xff) ^ ((hashval >> 8) & 0xff)) % KB_HASHSIZE;
- tab = htable[hashval];
- ptab = htable+hashval;
- if(!tab) {
- tab = new kb_key[KB_PREALLOC];
- tab[0].code = NoSymbol;
- *ptab = tab;
- }
-#endif
- } else {
- tab = table;
- ptab = &table;
- }
+ unsigned int const code = seq->sequence[idx];
+ if (code == NoSymbol) return -1;
- // --- check if key is already there --------------------------------
+ unsigned int const modmsk = seq->modifiers[idx];
- kb_key * t;
- int tsize;
- for(t = tab, tsize = 1; t->code != NoSymbol; ++t, ++tsize) {
- if(code == t->code && modmsk == t->mod) { // -- overwrite binding ---
- if(idx+1 == seq->length) {
+ // --- check if key is already there --------------------------------
+ if (table.size() != 0) { // without this I get strange crashes
+ Table::iterator end = table.end();
+ for (Table::iterator it = table.begin(); it != end; ++it) {
+ if (code == (*it).code && modmsk == (*it).mod) {
+ // overwrite binding
+ if (idx + 1 == seq->length) {
string buf;
seq->print(buf, true);
- lyxerr[Debug::KEY]
+ lyxerr[Debug::KBMAP]
<< "Warning: New binding for '"
- << buf
+ << buf
<< "' is overriding old binding..."
<< endl;
-
- if(t->table) {
- delete t->table;
- t->table = 0;
+ if ((*it).table) {
+ delete (*it).table;
+ (*it).table = 0;
}
- t->action = action;
+ (*it).action = action;
return 0;
- } else if (!t->table) {
+ } else if (!(*it).table) {
string buf;
seq->print(buf, true);
lyxerr << "Error: New binding for '" << buf
<< "' is overriding old binding..."
<< endl;
return -1;
- } else
- return t->table->defkey(seq, action, idx + 1);
+ } else {
+ return (*it).table->defkey(seq, action,
+ idx + 1);
+ }
}
}
-
- // --- extend list if necessary -------------------------------------
-
- if(tsize % KB_PREALLOC == 0) {
- kb_key * nt = new kb_key[tsize + KB_PREALLOC];
- // Set to 0 as table is used uninitialised later (thornley)
- nt[tsize].table = 0;
- memcpy(nt, tab, tsize * sizeof(kb_key));
- *ptab = nt;
- delete[] tab;
- tab = nt;
- if(size >= 0) size = tsize + KB_PREALLOC;
}
-
- // --- add action ---------------------------------------------------
-
- tab[tsize--].code = NoSymbol;
- tab[tsize].code = code;
- tab[tsize].mod = modmsk;
- kb_key * newone = &tab[tsize];
- // --- convert list to hash table if necessary ----------------------
-
-#ifndef NO_HASH
- if(size >= 0 && tsize >= 32) {
- kb_key * oldtab = tab;
- kb_key ** nht = new kb_key*[KB_HASHSIZE];
- for(int i = 0; i < KB_HASHSIZE; ++i)
- nht[i] = 0;
- htable = nht;
- size = -KB_HASHSIZE;
-
- // --- copy old keys to new hash table ---
- int hashval;
- for(kb_key * tu = oldtab; tu->code != NoSymbol; ++tu) {
- // copy values from oldtab to htable
- hashval = (tu->code & 0xffff);
- hashval = ((hashval & 0xff) ^ ((hashval>>8) & 0xff)) % KB_HASHSIZE;
- tab = htable[hashval];
-
- if(!tab){
- htable[hashval] = tab = new kb_key[KB_PREALLOC];
- tab->code = NoSymbol;
- }
- int ts = 1;
- for(kb_key * tt = tab; tt->code != NoSymbol; ++tt)
- ++ts;
- if(ts % KB_PREALLOC == 0){
- // extend table
- kb_key * nt = new kb_key[ts+KB_PREALLOC];
- memcpy(nt, tab, ts * sizeof(kb_key));
- htable[hashval] = nt;
- delete[] tab;
- tab = nt;
- }
- tab[ts--].code = NoSymbol;
- tab[ts].code = tu->code;
- tab[ts].mod = tu->mod;
- tab[ts].action = tu->action;
- tab[ts].table = tu->table;
-
- if(tu == newone)
- newone = &tab[ts];
- }
- delete[] oldtab;
- }
-#endif
- // --- define rest of sequence --------------------------------------
-
- if(idx+1 == seq->length) {
- newone->action = action;
- newone->table = 0;
+ 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;
} else {
- newone->table = new kb_keymap;
- int res = newone->table->defkey(seq, action, idx+1);
- return res;
+ (*newone).table = new kb_keymap;
+ return (*newone).table->defkey(seq, action, idx + 1);
}
}
kb_keymap::~kb_keymap()
{
- if(!table) return;
-#ifndef NO_HASH
- if(size < 0) {
- for(int i = 0; i < KB_HASHSIZE; ++i) {
- if(htable[i]) {
- for(kb_key * t = htable[i];
- t->code != NoSymbol; ++t)
- if(t->table)
- delete t->table;
- delete htable[i];
- }
- }
- delete htable;
- } else {
-#endif
- for(kb_key * t = table; t->code != NoSymbol; ++t)
- if(t->table)
- delete t->table;
- delete table;
-#ifndef NO_HASH
+ // 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;
}
-#endif
}
-string keyname(kb_key k)
+string const kb_keymap::keyname(kb_key const & k)
{
string buf;
printKeysym(k.code, k.mod, buf);
// Finds a key for a keyaction, if possible
-string kb_keymap::findbinding(int act) const
+string const kb_keymap::findbinding(int act) const
{
string res;
- if (!table) return res;
-
-#ifndef NO_HASH
- if (size < 0) {
- for(int i = 0; i < KB_HASHSIZE; ++i) {
- if(htable[i]) {
- for(kb_key * t = htable[i];
- t->code != NoSymbol; ++t) {
- if(t->table) {
- string suffix = t->table->findbinding(act);
- suffix = strip(suffix, ' ');
- suffix = strip(suffix, ']');
- suffix = frontStrip(suffix, '[');
- if (!suffix.empty()) {
- res += "[" + keyname(*t) + " " + suffix + "] ";
- }
- } else if (t->action == act) {
- res += "[" + keyname(*t) + "] ";
- }
- }
- }
- }
- } else {
-#endif
- for(kb_key * t = table; t->code != NoSymbol; ++t) {
- if(t->table) {
- string suffix = t->table->findbinding(act);
- suffix = strip(suffix, ' ');
- suffix = strip(suffix, ']');
- suffix = frontStrip(suffix, '[');
- if (!suffix.empty()) {
- res += "[" + keyname(*t) + " " + suffix + "] ";
- }
- } else if (t->action == act) {
- res += "[" + keyname(*t) + "] ";
+ 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 += "] ";
}
-#ifndef NO_HASH
}
-#endif
return res;
}
-
/* === End of File: kbmap.C ============================================== */
projects / lyx.git / blobdiff