src/kbsequence.C

   1 /**
   2  * \file kbsequence.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author Jean-Marc Lasgouttes
   8  * \author John Levon
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #include <config.h>
  14
  15 #include "kbsequence.h"
  16
  17 #include "gettext.h"
  18 #include "kbmap.h"
  19 #include "lfuns.h"
  20
  21 #include "frontends/LyXKeySym.h"
  22 #include "frontends/LyXKeySymFactory.h"
  23
  24 using std::make_pair;
  25
  26
  27 FuncRequest const &
  28 kb_sequence::addkey(LyXKeySymPtr key,
  29                     key_modifier::state mod, key_modifier::state nmod)
  30 {
  31         // adding a key to a deleted sequence
  32         // starts a new sequence
  33         if (deleted_) {
  34                 deleted_ = false;
  35                 sequence.clear();
  36                 modifiers.clear();
  37         }
  38
  39         modifiers.push_back(make_pair(mod, nmod));
  40         sequence.push_back(key);
  41
  42         if (curmap) {
  43                 return curmap->lookup(key, mod, this);
  44         }
  45
  46         static FuncRequest unknown(LFUN_UNKNOWN_ACTION);
  47         return unknown;
  48 }
  49
  50
  51 string::size_type kb_sequence::parse(string const & s)
  52 {
  53         if (s.empty()) return 1;
  54
  55         string::size_type i = 0;
  56         key_modifier::state mod = key_modifier::none;
  57         key_modifier::state nmod = key_modifier::none;
  58
  59         while (i < s.length()) {
  60                 if (s[i] == ' ')
  61                         ++i;
  62                 if (i >= s.length())
  63                         break;
  64
  65                 if (i + 1 < s.length() && s[i + 1] == '-') {
  66                         switch (s[i]) {
  67                         case 's': case 'S':
  68                                 mod |= key_modifier::shift;
  69                                 i += 2;
  70                                 continue;
  71                         case 'c': case 'C':
  72                                 mod |= key_modifier::ctrl;
  73                                 i += 2;
  74                                 continue;
  75                         case 'm': case 'M':
  76                                 mod |= key_modifier::alt;
  77                                 i += 2;
  78                                 continue;
  79                         default:
  80                                 return i + 1;
  81                         }
  82                 } else if (i + 2 < s.length() && s[i] == '~'
  83                            && s[i + 2] == '-') {
  84                         switch (s[i + 1]) {
  85                         case 's': case 'S':
  86                                 nmod |= key_modifier::shift;
  87                                 i += 3;
  88                                 continue;
  89                         case 'c': case 'C':
  90                                 nmod |= key_modifier::ctrl;
  91                                 i += 3;
  92                                 continue;
  93                         case 'm': case 'M':
  94                                 nmod |= key_modifier::alt;
  95                                 i += 3;
  96                                 continue;
  97                         default:
  98                                 return i + 2;
  99                         }
 100                 } else {
 101                         string tbuf;
 102                         string::size_type j = i;
 103                         for (; j < s.length() && s[j] != ' '; ++j)
 104                                 tbuf += s[j];    // (!!!check bounds :-)
 105
 106                         LyXKeySymPtr key(LyXKeySymFactory::create());
 107                         key->init(tbuf);
 108
 109                         if ( ! key->isOK() ) {
 110                                 return j;
 111                         }
 112
 113                         i = j;
 114
 115                         addkey(key, mod, nmod);
 116                         mod = key_modifier::none;
 117                 }
 118         }
 119
 120         // empty sequence?
 121         if (sequence.size() == 0)
 122                 return 0;
 123
 124         // everything is fine
 125         return string::npos;
 126 }
 127
 128
 129 string const kb_sequence::print() const
 130 {
 131         string buf;
 132
 133         //if (deleted_)
 134         //      return buf;
 135
 136         KeySequence::size_type i, length = sequence.size();
 137
 138         for (i = 0; i < length; ++i) {
 139                 buf += kb_keymap::printKeysym(sequence[i], modifiers[i].first);
 140
 141                 // append a blank
 142                 if (i + 1 < length) {
 143                         buf += ' ';
 144                 }
 145         }
 146         return buf;
 147 }
 148
 149
 150 string const kb_sequence::printOptions() const
 151 {
 152         string buf;
 153
 154         buf += print();
 155
 156         if (!curmap)
 157                 return buf;
 158
 159         buf += _("   options: ");
 160         buf += curmap->print();
 161         return buf;
 162 }
 163
 164
 165 void kb_sequence::mark_deleted()
 166 {
 167         deleted_ = true;
 168 }
 169
 170
 171 void kb_sequence::reset()
 172 {
 173         mark_deleted();
 174         curmap = stdmap;
 175 }
 176
 177 void kb_sequence::clear()
 178 {
 179         sequence.clear();
 180         reset();
 181 }