Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/C/Lyx/src/ (Beweissystem der NASA Version 6.0.9^©) Datei vom 23.0.1999 mit Größe 11 kB

Quelle kbmap.C Sprache: C

/* This file is part of
* ======================================================
*
*          LyX, The Document Processor
*
*     Copyright (C) 1995 Matthias Ettrich
*          Copyright (C) 1995-1998 The LyX Team.
*
*======================================================*/

#include <config.h>
#include <string.h>
#include <stdio.h>
#include "gettext.h"

// $Id: kbmap.C,v 1.1.1.1 1998/04/20 21:14:49 larsbj Exp $

#if !defined(lint) && !defined(WITH_WARNINGS)
static char vcid[] = "$Id: kbmap.C,v 1.1.1.1 1998/04/20 21:14:49 larsbj Exp $";
#endif /* lint */

#ifdef __GNUG__
#pragma implementation
#endif

#include "kbmap.h"
#include "error.h"

// The only modifiers that we handle. We want to throw away things
// like NumLock.
enum { ModsMask = ShiftMask | ControlMask | Mod1Mask};

// === static functions ===================================================

/* ---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 )
{
int len;
char *s;

mod &= ModsMask;

// calc required length;
len = 0;
if ( mod & ShiftMask )   len += 2;
if ( mod & ControlMask ) len += 2;
if ( mod & Mod1Mask )    len += 2;

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;
}

/* ---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;
}

// === 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)
{
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] && ((unsigned char) 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] && ((unsigned char)s[j])>' '; j++)
    tbuf[j-i] = s[j];    // (!!!check bounds :-)

   tbuf[j-i] = '\0';

   key = XStringToKeysym(tbuf);
   if(key == NoSymbol) {
    lyxerr.debug("kbmap.C: No such keysym: "
          + LString(tbuf),Error::KBMAP);
    return j;
   }
   i = j;

   addkey(key, mod, nmod);
   mod = 0;
   nmod = 0;
  }
}
return 0;
}

/* ---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
{
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+1<l && maxlen>1) {  // append a blank
   *buf++ = ' ';
   maxlen--;
  }
}
*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
{
int len;

print( buf, maxlen, true );
len = strlen( buf );
maxlen -= len;
buf    += len;

if ( maxlen < 20 || !curmap ) return -1;
#ifdef WITH_WARNINGS
#warning reimplement kb_sequence using LString
#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 (char)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);
if (!res) {
  defkey(&k, action);
} else
  lyxerr.debug(LString("Parse error at position ") + res +
        " in key sequence '" + seq + "'.", Error::KBMAP);
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)
{
unsigned int hashval, ksym, msk1, msk0;
kb_key *tab;

//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;
   } else {
      // final key - reset map
    seq->curmap = seq->stdmap;
    seq->delseq();
    return tab->action; // ... and return action
   }
  }
}

// error - key not found:
seq->curmap = seq->stdmap;
seq->delseq();
return -1;
}

/* ---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
{
int                    len;

/* -----> 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] ) {
    len = printKeyTab( htable[ix], buf, maxLen );
    maxLen -= len;
    buf    += len;
   }
  }
} else {
  /* -------> Normal table. */
  len = printKeyTab( table, buf, maxLen );
  maxLen -= len;
  buf    += len;
}
return maxLen;
}

/* ---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*/)
{
int      tsize;
unsigned int code, modmsk;
kb_key  *tab, **ptab;

code = seq->sequence[idx];
modmsk = seq->modifiers[idx];
if(code == NoSymbol) return -1;

// --- 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;
}

// --- check if key is already there --------------------------------

kb_key *t;
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(LString("Warning: New binding for '") + buf +
          "' is overriding old binding...", Error::KEY);

    if(t->table) {
     delete t->table;
     t->table = 0;
    }
    t->action = action;
    return 0;
   } else if (!t->table) {
    char buf[20]; buf[0] = 0;
    seq->print(buf, 20, true);
    lyxerr.print(LString("Error: New binding for '") + buf +
          "' is overriding old binding...");
    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 NULL as table is used uninitialised later (thornley)
  nt[tsize].table = NULL;
  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;
   }
   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) {
  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;
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;
}
}

LString keyname(kb_key k) {
char buf[100];
printKeysym(k.code, k.mod, buf, 100);
return buf;
}

// Finds a key for a keyaction, if possible
LString kb_keymap::findbinding(int act) const {
LString 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) {
      LString suffix = t->table->findbinding(act);
      suffix.strip(' ');
      suffix.strip(']');
      suffix.frontStrip('[');
      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) {
    LString suffix = t->table->findbinding(act);
    suffix.strip(' ');
    suffix.strip(']');
    suffix.frontStrip('[');
    if (!suffix.empty()) {
     res += "[" + keyname(*t) + " " + suffix + "] ";
    }
   } else if (t->action == act) {
    res += "[" + keyname(*t) + "] ";
   }
  }
}
return res;
}

/* === End of File: kbmap.C ============================================== */

quality95%

¤ Dauer der Verarbeitung: 0.19 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.