src/KeySequence.cpp

   1 /**
   2  * \file KeySequence.cpp
   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 "KeySequence.h"
  16
  17 #include "gettext.h"
  18 #include "KeyMap.h"
  19 #include "lfuns.h"
  20
  21 #include "frontends/KeySymbol.h"
  22
  23 using std::make_pair;
  24 using std::string;
  25
  26
  27 namespace lyx {
  28
  29 FuncRequest const & KeySequence::addkey(KeySymbol const & key,
  30         KeyModifier mod, KeyModifier nmod)
  31 {
  32         // adding a key to a deleted sequence
  33         // starts a new sequence
  34         if (deleted_) {
  35                 deleted_ = false;
  36                 sequence.clear();
  37                 modifiers.clear();
  38         }
  39
  40         modifiers.push_back(make_pair(mod, nmod));
  41         sequence.push_back(key);
  42
  43         if (curmap) {
  44                 return curmap->lookup(key, mod, this);
  45         }
  46
  47         static FuncRequest unknown(LFUN_UNKNOWN_ACTION);
  48         return unknown;
  49 }
  50
  51
  52 size_t KeySequence::parse(string const & s)
  53 {
  54         if (s.empty())
  55                 return 1;
  56
  57         size_t i = 0;
  58         KeyModifier mod = NoModifier;
  59         KeyModifier nmod = NoModifier;
  60
  61         while (i < s.length()) {
  62                 if (s[i] == ' ')
  63                         ++i;
  64                 if (i >= s.length())
  65                         break;
  66
  67                 if (i + 1 < s.length() && s[i + 1] == '-') {
  68                         switch (s[i]) {
  69                         case 's': case 'S':
  70                                 mod |= ShiftModifier;
  71                                 i += 2;
  72                                 continue;
  73                         case 'c': case 'C':
  74                                 mod |= ControlModifier;
  75                                 i += 2;
  76                                 continue;
  77                         case 'm': case 'M':
  78                                 mod |= AltModifier;
  79                                 i += 2;
  80                                 continue;
  81                         default:
  82                                 return i + 1;
  83                         }
  84                 } else if (i + 2 < s.length() && s[i] == '~'
  85                            && s[i + 2] == '-') {
  86                         switch (s[i + 1]) {
  87                         case 's': case 'S':
  88                                 nmod |= ShiftModifier;
  89                                 i += 3;
  90                                 continue;
  91                         case 'c': case 'C':
  92                                 nmod |= ControlModifier;
  93                                 i += 3;
  94                                 continue;
  95                         case 'm': case 'M':
  96                                 nmod |= AltModifier;
  97                                 i += 3;
  98                                 continue;
  99                         default:
 100                                 return i + 2;
 101                         }
 102                 } else {
 103                         string tbuf;
 104                         size_t j = i;
 105                         for (; j < s.length() && s[j] != ' '; ++j)
 106                                 tbuf += s[j];    // (!!!check bounds :-)
 107
 108                         KeySymbol key;
 109                         key.init(tbuf);
 110
 111                         if (!key.isOK())
 112                                 return j;
 113
 114                         i = j;
 115
 116                         addkey(key, mod, nmod);
 117                         mod = NoModifier;
 118                 }
 119         }
 120
 121         // empty sequence?
 122         if (sequence.size() == 0)
 123                 return 0;
 124
 125         // everything is fine
 126         return string::npos;
 127 }
 128
 129
 130 docstring const KeySequence::print(outputFormat format) const
 131 {
 132         docstring buf;
 133
 134         size_t const length = sequence.size();
 135
 136         for (size_t i = 0; i != length; ++i) {
 137                 switch (format) {
 138                 case Portable:
 139                         buf += sequence[i].print(modifiers[i].first, false);
 140                         break;
 141                 case ForGui:
 142                         buf += sequence[i].print(modifiers[i].first, true);
 143                         break;
 144                 case BindFile:
 145                         KeyModifier mod = modifiers[i].first;
 146                         if (mod & ShiftModifier)
 147                                 buf += "S-";
 148                         if (mod & ControlModifier)
 149                                 buf += "C-";
 150                         if (mod & AltModifier)
 151                                 buf += "M-";
 152
 153                         buf += from_utf8(sequence[i].getSymbolName());
 154                         break;
 155                 }
 156                 // append a blank
 157                 if (i + 1 != length)
 158                         buf += ' ';
 159         }
 160         return buf;
 161 }
 162
 163
 164 docstring const KeySequence::printOptions(bool forgui) const
 165 {
 166         docstring buf = print(forgui ? ForGui : Portable);
 167
 168         if (!curmap)
 169                 return buf;
 170
 171         buf += _("   options: ");
 172         buf += curmap->print(forgui ? ForGui : Portable);
 173         return buf;
 174 }
 175
 176
 177 void KeySequence::mark_deleted()
 178 {
 179         deleted_ = true;
 180 }
 181
 182
 183 void KeySequence::reset()
 184 {
 185         mark_deleted();
 186         curmap = stdmap;
 187 }
 188
 189
 190 void KeySequence::clear()
 191 {
 192         sequence.clear();
 193         reset();
 194 }
 195
 196
 197 } // namespace lyx