X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fkbmap.C;h=7004b3ec73298a54fc2ed3af5ab75f3f5ecfe960;hb=98c966c64594611e469313314abd1e59524adb4a;hp=4b04792a8d5e39387aec09ca7890d6d55bd5f848;hpb=e8db0ccc46566f36a1711e35c3758a2e785021f1;p=lyx.git diff --git a/src/kbmap.C b/src/kbmap.C index 4b04792a8d..7004b3ec73 100644 --- a/src/kbmap.C +++ b/src/kbmap.C @@ -1,728 +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}; - - -// === static functions =================================================== +using std::endl; +// 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 -int printKeysym( KeySym key, unsigned int mod, char *buf, int maxlen ) +string const kb_keymap::printKeysym(unsigned int key, unsigned int mod) { + string buf; mod &= ModsMask; - // calc required length; - int len = 0; - if ( mod & ShiftMask ) len += 2; - if ( mod & ControlMask ) len += 2; - if ( mod & Mod1Mask ) len += 2; - - char * s = XKeysymToString( key ); - if ( s ) len += strlen( s ); - if ( len < maxlen ) { - if ( mod & ShiftMask ) { - *buf++ = 'S'; *buf++ = '-'; } - if ( mod & ControlMask ) { - *buf++ = 'C'; *buf++ = '-'; } - if ( mod & Mod1Mask ) { - *buf++ = 'M'; *buf++ = '-'; } - if ( s ) strcpy( buf, s ); - return len; - } else - return 0; -} - + char const * const s = XKeysymToString(key); -/* ---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 -int printKeyTab( kb_key * tabPt, char *buf, int maxLen ) -{ - int len, doneLen = 0; - unsigned int ksym, mod; - - /* -------> Print each of the slots into buf. */ - for( ; (tabPt->code & 0xffff) != NoSymbol; ++tabPt) { - if ( maxLen <= 0 ) break; - - ksym = tabPt->code; - mod = tabPt->mod & 0xffff; - - len = printKeysym( ksym, mod, buf, maxLen ); - if ( len <= 0 ) break; - buf += len; - maxLen -= len; - doneLen += len; - - /* -------> Add space when possible. */ - if ( maxLen > 0 ) { - *buf++ = ' '; - *buf = '\0'; - maxLen--; - doneLen++; - } - } - return doneLen; + if (mod & ShiftMask) buf += "S-"; + if (mod & ControlMask) buf += "C-"; + if (mod & Mod1Mask) buf += "M-"; + if (s) buf += s; + return 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*/) +char kb_keymap::getiso(unsigned int c) { - 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; + 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 { - 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; + 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(char * buf, int maxlen, bool when_defined) const +string::size_type kb_keymap::bind(string const & seq, int action) { - KeySym key; - unsigned int mod; - int len; - int l = length; - if ( l < 0 && !when_defined ) l = -l; - - for(int i = 0; i < l; ++i) { - key = sequence[i]; - mod = modifiers[i] & 0xffff; - - len = printKeysym( key, mod, buf, maxlen ); // RVDK_PATCH_5 - buf += len; - maxlen -= len; - - if ( len == 0 ) { - *buf = '\0'; - return -1; - } - - if(i+11) { // append a blank - *buf++ = ' '; - maxlen--; - } + if (lyxerr.debugging(Debug::KBMAP)) { + lyxerr << "BIND: Sequence `" + << seq << "' Action `" + << action << "'" << endl; } - *buf = '\0'; - 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(char * buf, int maxlen) const -{ - print(buf, maxlen, true); - int len = strlen(buf); - maxlen -= len; - buf += len; - - if ( maxlen < 20 || !curmap ) return -1; -#ifdef WITH_WARNINGS -#warning reimplement kb_sequence using string -#endif - char s[20]; - strcpy(s, _(" options: ")); - strcpy( buf, s); - buf += strlen(s); - maxlen -= strlen(s); - - curmap->print(buf, maxlen); - 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; -} + kb_sequence k(0, 0); -/* ---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); - 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 { - unsigned int hashval, ksym, msk1, msk0; - kb_key * tab; + if (table.empty()) { + seq->curmap = seq->stdmap; + seq->mark_deleted(); + return LFUN_UNKNOWN_ACTION; + } //suppress modifier bits we do not handle mod &= ModsMask; - if(!table) { - // error - no keymap defined: - seq->curmap = seq->stdmap; - seq->delseq(); - return -1; - } - - 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 --- - 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; - - if(ksym == key && (mod & ~msk0) == msk1) { - // match found: - if(tab->table) { - // this is a prefix key - set new map - seq->curmap = tab->table; - return 0; + 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 = cit->table.get(); + return LFUN_PREFIX; } else { - // final key - reset map + // 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------------------------------------------------------------------- */ - -int kb_keymap::print(char * buf, int maxLen) const +string const kb_keymap::print() const { - /* -----> Return when running out of string space or when keymap has no table. - Else, place a terminating newline in case no other output is generated. */ - - if ( maxLen <= 3 || !buf ) return maxLen; - if ( !table ) return maxLen; - *buf = '\0'; - - /* -------> Hash table. Process each of its slots recursively and return. */ - if ( size < 0 ) { - for ( int ix = 0; (ix < KB_HASHSIZE) && (maxLen > 1); ++ix ) { - if ( htable[ix] ) { - int len = printKeyTab( htable[ix], buf, maxLen ); - maxLen -= len; - buf += len; - } - } - } else { - /* -------> Normal table. */ - int len = printKeyTab( table, buf, maxLen ); - maxLen -= len; - buf += len; + string buf; + for (Table::const_iterator cit = table.begin(); + cit != table.end(); ++cit) { + buf += printKey((*cit)); + buf += ' '; } - return maxLen; + 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; - } 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; - } - } 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) { - char buf[20]; buf[0] = 0; - seq->print(buf, 20, 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) { - char buf[20]; buf[0] = 0; - seq->print(buf, 20, 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 ---------------------- - - 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; } - - // --- 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; + newone->table.reset(0); + return; } else { - newone->table = new kb_keymap; - int res = newone->table->defkey(seq, action, idx+1); - return res; + newone->table.reset(new kb_keymap); + newone->table->defkey(seq, action, r + 1); + return; } } -/* ---F+------------------------------------------------------------------ *\ - Function : kb_keymap::~kb_keymap - Called by : [destructor] - Purpose : free keymap and its descendents - Parameters: none - Returns : nothing -\* ---F------------------------------------------------------------------- */ - -kb_keymap::~kb_keymap() +string const kb_keymap::findbinding(int act, string const & prefix) const { - if(!table) return; - 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 { - for(kb_key * t = table; t->code != NoSymbol; ++t) - if(t->table) - delete t->table; - delete table; - } -} - -string keyname(kb_key k) { - char buf[100]; - printKeysym(k.code, k.mod, buf, 100); - return buf; -} - -// Finds a key for a keyaction, if possible -string kb_keymap::findbinding(int act) const { string res; - if (!table) - return res; - - 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 { - 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.get()) { + res += cit->table->findbinding(act, + prefix + + printKey((*cit)) + + " "); + } else if (cit->action == act) { + res += "["; + res += prefix + printKey((*cit)); + res += "] "; } } return res; } - - -/* === End of File: kbmap.C ============================================== */