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