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