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