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