Source Code (Use browser search to find items of interest.)

kikbd'KeyMap (./kdebase/kikbd/keymap.h:61)

class KeyMap: public QObject {
  Q_OBJECT
 protected:
  static  bool isToggleCaps;
  QString name, label, comment;
  bool    altKeys, compose;
  KeySyms keySyms[4], capsKeySyms[4];
 public:
  KeyMap(KiKbdMapConfig&, KeySyms& initSyms);
  bool  changeKeySym(const char*, const char*, int, unsigned);
  const QString getName()    const { return name;    }
  const QString getLabel()   const { return label;   }
  const QString getComment() const { return comment; }
  bool  hasAltKeys() const {return altKeys;}
  bool  hasCompose() const {return compose;}
  void  toggle(unsigned);
  void  toggleCaps(bool, unsigned);
 signals:
  void infoChanged(QString, QString);
};

kikbd'KeyMap::KeyMap() (./kdebase/kikbd/keymap.cpp:40)

KeyMap::KeyMap(KiKbdMapConfig& config, KeySyms& initSyms)
{
  /**
     language information
  */
  name    = config.getName();
  label   = config.getLabel();
  comment = config.getGoodLabel();
  altKeys = config.getHasAltKeys();
  compose = config.getHasCompose();

  unsigned g;
  
  for(g=0; g<4; g++) {
    /**
       new main symbols
    */
    keySyms[g] = initSyms;

    /**
       load symbols from symbols(k==0) and codes(k==1)
    */
    unsigned count = keySyms[g].kcodes + 1;
    unsigned i;
    for(unsigned k=0; k<2; k++) {
      QList<QStrList> &symmap = k==0?config.getKeysyms(g):config.getKeycodes(g);

      for(i=0; i<symmap.count(); i++) {
        QStrList list = *(symmap.at(i));
        /**
	   entry with less then 2 symbols are bad
        */
        if(list.count() < 2) continue;
        /**
	   change symbols
        */
        int index = k==0?initSyms.findSym(list.at(0))
	  :initSyms.findCode(list.at(0));
        if(index == -1)  continue;
        
        unsigned j;for(j=list.count()<=count?list.count():count; j-->1;)
          keySyms[g].change(index, list.at(j), j-1);
      }
    }

    /**
       create capslocked symbols
    */
    QStrList &capssyms = config.getCapssyms(g);
    capsKeySyms[g] = keySyms[g];
    if(capssyms.count() > 0) {
      /**
	  special capsed symbols
      */
      for(i=0; i<capssyms.count(); i++) {
	KeySym test = KeyTranslate::stringToSym(capssyms.at(i));
	if(test == NoSymbol) continue;
	/**
	   look for capsed symbol
	*/
	unsigned j;for(j=0; j<(initSyms.maxKeyCode-initSyms.minKeyCode-1)*
		         initSyms.kcodes; j+=initSyms.kcodes) {
	  if(KeyTranslate::tolower(initSyms.syms[j]) 
	     == KeyTranslate::tolower(test)) {
	    capsKeySyms[g].syms[j]   = keySyms[g].syms[j+1];
	    capsKeySyms[g].syms[j+1] = keySyms[g].syms[j];
	  }
	  if(capsKeySyms[g].kcodes >=4) {
	    if(KeyTranslate::tolower(keySyms[g].syms[j+2]) 
	       == KeyTranslate::tolower(test)) {
	      capsKeySyms[g].syms[j+2] = keySyms[g].syms[j+3];
	      capsKeySyms[g].syms[j+3] = keySyms[g].syms[j+2];
	    }
	  }
	}
      }
    } else {
      /**
	  default capsed symbols
      */
      for(i=0; i<(initSyms.maxKeyCode-initSyms.minKeyCode-1)*
	    initSyms.kcodes; i+=initSyms.kcodes) {
	if(KeyTranslate::tolower(initSyms.syms[i]) >= 'a' 
	   && KeyTranslate::tolower(initSyms.syms[i]) <= 'z') {
	  capsKeySyms[g].syms[i]   = keySyms[g].syms[i+1];
	  capsKeySyms[g].syms[i+1] = keySyms[g].syms[i];
	}
	if(capsKeySyms[g].kcodes >=4) {
	  if(KeyTranslate::tolower(keySyms[g].syms[i+2]) >= 'a' 
	     && KeyTranslate::tolower(initSyms.syms[i+2]) <= 'z') {
	    capsKeySyms[g].syms[i+2] = keySyms[g].syms[i+3];
	    capsKeySyms[g].syms[i+3] = keySyms[g].syms[i+2];
	  }
	}
      }
    }
  }
}
/**
   change symbol by symbol in both normal and caps map
   return true if Ok
*/

kikbd'KeyMap::changeKeySym() (./kdebase/kikbd/keymap.cpp:142)

bool KeyMap::changeKeySym(const char* from, const char* to, int index, unsigned g)
{
  int i = keySyms[g].findSym(from);
  if(i == -1) return FALSE;
  keySyms[g].change(i, to, index);
  capsKeySyms[g].change(i, to, index);
  return TRUE;
}

/**
   change X window keyboard mapping to this one
*/

kikbd'KeyMap::toggle() (./kdebase/kikbd/keymap.cpp:154)

void KeyMap::toggle(unsigned g)
{
  if(isToggleCaps && !capsKeySyms[g].isNull()) capsKeySyms[g].write();
  else keySyms[g].write();
}
/**
   activate capslocked keys
*/

kikbd'KeyMap::toggleCaps() (./kdebase/kikbd/keymap.cpp:162)

void KeyMap::toggleCaps(bool on, unsigned g)
{
  if(isToggleCaps == on) return;
  isToggleCaps = on;
  if(isToggleCaps) {
    if(!capsKeySyms[g].isNull()) capsKeySyms[g].write();
  } else {
    keySyms[g].write();
  }
}

//=========================================================
//  KeySyms members
//=========================================================