X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fkbmap.C;h=26f7bbe66a13a923b4e0075e1499a9f4bca4b9eb;hb=35e1157317931babf8ce692952d3ff20d6946c0b;hp=3a491f334df26a9c3f6ff5bd179d0f64479dcef2;hpb=5f3f9ad231bc0c24d34c00e3936e226d9834589a;p=lyx.git diff --git a/src/kbmap.C b/src/kbmap.C index 3a491f334d..26f7bbe66a 100644 --- a/src/kbmap.C +++ b/src/kbmap.C @@ -1,682 +1,217 @@ /* This file is part of - * ====================================================== - * + * ====================================================== + * * LyX, The Document Processor - * + * * Copyright 1995 Matthias Ettrich - * Copyright 1995-1999 The LyX Team. + * Copyright 1995-2001 The LyX Team. * * ====================================================== */ #include -#include -#include -#include "support/lstrings.h" -#include "gettext.h" + +#include #ifdef __GNUG__ #pragma implementation #endif #include "kbmap.h" +#include "commandtags.h" +#include "kbsequence.h" #include "debug.h" -// The only modifiers that we handle. We want to throw away things -// like NumLock. -enum { ModsMask = ShiftMask | ControlMask | Mod1Mask}; +using std::endl; - -// === static functions =================================================== +// The only modifiers that we handle. We want to throw away things +// like NumLock. +enum { ModsMask = ShiftMask | ControlMask | Mod1Mask }; -/* ---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------------------------------------------------------------------- */ -static -void printKeysym(KeySym key, unsigned int mod, string & buf) +string const kb_keymap::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-"; if (mod & Mod1Mask) buf += "M-"; if (s) buf += s; + return buf; } -/* ---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------------------------------------------------------------------- */ - -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; +char kb_keymap::getiso(unsigned int c) +{ + switch (c & 0x0000FF00) { + // latin 1 byte 3 = 0 + case 0x00000000: break; + // latin 2 byte 3 = 1 + case 0x00000100: + // latin 3 byte 3 = 2 + case 0x00000200: + // latin 4 byte 3 = 3 + case 0x00000300: + // latin 8 byte 3 = 18 (0x12) + case 0x00001200: + // latin 9 byte 3 = 19 (0x13) + case 0x00001300: + c &= 0x000000FF; + break; + default: + c = 0; } - - modifiers[length] = mod + (nmod << 16); - sequence[length++] = key; - - if(curmap) - return curmap->lookup(key, mod, this); - - return -1; + return c; } - -/* ---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) +string const kb_keymap::printKey(kb_key const & key) const { - if(!s[0]) return 1; - - int i = 0; - unsigned int mod = 0, nmod = 0; - 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 { - string tbuf; - int j = i; - for(; s[j] && s[j] > ' '; ++j) - tbuf += s[j]; // (!!!check bounds :-) - - KeySym key = XStringToKeysym(tbuf.c_str()); - 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; + return printKeysym(key.code, key.mod & 0xffff); } -/* ---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 +string::size_type 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; + kb_sequence k(0, 0); - int res = k.parse(seq); - if (!res) { + string::size_type const res = k.parse(seq); + if (res == string::npos) { defkey(&k, action); - } else + } 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------------------------------------------------------------------- */ - -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; + seq->mark_deleted(); + return LFUN_UNKNOWN_ACTION; } -#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; + //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) { + // match found + if (cit->table.get()) { // this is a prefix key - set new map - seq->curmap = tab->table; - return 0; + seq->curmap = cit->table.get(); + return LFUN_PREFIX; } else { // final key - reset map seq->curmap = seq->stdmap; - seq->delseq(); - return tab->action; // ... and return action + seq->mark_deleted(); + return cit->action; } } } - + // error - key not found: seq->curmap = seq->stdmap; - seq->delseq(); - return -1; + seq->mark_deleted(); + return LFUN_UNKNOWN_ACTION; } -/* ---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 +string const kb_keymap::print() 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); + string buf; + for (Table::const_iterator cit = table.begin(); + cit != table.end(); ++cit) { + buf += printKey((*cit)); + 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, int action, unsigned int r) { - 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[r]; + if (code == NoSymbol) return; - // --- check if key is already there -------------------------------- + unsigned int const modmsk = seq->modifiers[r]; - 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) { - string buf; - seq->print(buf, true); - lyxerr[Debug::KEY] + // check if key is already there + for (Table::iterator it = table.begin(); it != table.end(); ++it) { + if (code == it->code && modmsk == it->mod) { + // overwrite binding + if (r + 1 == seq->length()) { + lyxerr[Debug::KBMAP] << "Warning: New binding for '" - << buf + << seq->print() << "' is overriding old binding..." << endl; - - if(t->table) { - delete t->table; - t->table = 0; + if (it->table.get()) { + it->table.reset(0); } - t->action = action; - return 0; - } else if (!t->table) { - string buf; - seq->print(buf, true); - lyxerr << "Error: New binding for '" << buf + it->action = action; + return; + } else if (!it->table.get()) { + lyxerr << "Error: New binding for '" << seq->print() << "' is overriding old binding..." - << endl; - return -1; - } else - return t->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; + << endl; + return; + } else { + it->table->defkey(seq, action, r + 1); + return; } - 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) { + + Table::iterator newone = table.insert(table.end(), kb_key()); + newone->code = code; + newone->mod = modmsk; + if (r + 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; - } -} - - -/* ---F+------------------------------------------------------------------ *\ - Function : kb_keymap::~kb_keymap - Called by : [destructor] - Purpose : free keymap and its descendents - Parameters: none - Returns : nothing -\* ---F------------------------------------------------------------------- */ - -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; + newone->table.reset(0); + return; } else { -#endif - for(kb_key * t = table; t->code != NoSymbol; ++t) - if(t->table) - delete t->table; - delete table; -#ifndef NO_HASH + newone->table.reset(new kb_keymap); + newone->table->defkey(seq, action, r + 1); + return; } -#endif } -string keyname(kb_key k) -{ - string buf; - printKeysym(k.code, k.mod, buf); - return buf; -} - - -// Finds a key for a keyaction, if possible -string kb_keymap::findbinding(int act) const +string const kb_keymap::findbinding(int act, string const & prefix) 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) + "] "; - } - } - } + if (table.empty()) return res; + + Table::const_iterator end = table.end(); + for (Table::const_iterator cit = table.begin(); + cit != end; ++cit) { + if (cit->table.get()) { + res += cit->table->findbinding(act, + prefix + + printKey((*cit)) + + " "); + } else if (cit->action == act) { + res += "["; + res += prefix + printKey((*cit)); + res += "] "; } - } 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) + "] "; - } - } -#ifndef NO_HASH } -#endif return res; } - - -/* === End of File: kbmap.C ============================================== */