src/KeyMap.cpp

   1 /**
   2  * \file KeyMap.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  * \author André Pönitz
  10  *
  11  * Full author contact details are available in file CREDITS.
  12  */
  13
  14 #include <config.h>
  15
  16 #include "KeyMap.h"
  17
  18 #include "debug.h"
  19 #include "KeySequence.h"
  20 #include "LyXAction.h"
  21 #include "Lexer.h"
  22
  23 #include "frontends/KeySymbol.h"
  24
  25 #include "support/filetools.h"
  26
  27 #include <sstream>
  28
  29 using std::endl;
  30 using std::string;
  31
  32
  33 namespace lyx {
  34
  35 using support::FileName;
  36 using support::i18nLibFileSearch;
  37
  38
  39 string const KeyMap::printKeySym(KeySymbol const & key,
  40                                     key_modifier::state mod)
  41 {
  42         string buf;
  43
  44         string const s = key.getSymbolName();
  45
  46         if (mod & key_modifier::shift)
  47                 buf += "S-";
  48         if (mod & key_modifier::ctrl)
  49                 buf += "C-";
  50         if (mod & key_modifier::alt)
  51                 buf += "M-";
  52
  53         buf += s;
  54         return buf;
  55 }
  56
  57
  58 size_t KeyMap::bind(string const & seq, FuncRequest const & func)
  59 {
  60         LYXERR(Debug::KBMAP) << "BIND: Sequence `"
  61                << seq << "' Action `"
  62                << func.action << '\'' << endl;
  63
  64         KeySequence k(0, 0);
  65
  66         string::size_type const res = k.parse(seq);
  67         if (res == string::npos) {
  68                 defkey(&k, func);
  69         } else {
  70                 LYXERR(Debug::KBMAP) << "Parse error at position " << res
  71                                      << " in key sequence '" << seq << "'."
  72                                      << endl;
  73         }
  74
  75         return res;
  76 }
  77
  78
  79 namespace {
  80
  81 enum BindTags {
  82         BN_BIND,
  83         BN_BINDFILE
  84 };
  85
  86 keyword_item bindTags[] = {
  87         { "\\bind", BN_BIND },
  88         { "\\bind_file", BN_BINDFILE }
  89 };
  90
  91 }
  92
  93
  94 bool KeyMap::read(string const & bind_file)
  95 {
  96         const int bindCount = sizeof(bindTags) / sizeof(keyword_item);
  97
  98         Lexer lexrc(bindTags, bindCount);
  99         if (lyxerr.debugging(Debug::PARSER))
 100                 lexrc.printTable(lyxerr);
 101
 102         FileName const tmp(i18nLibFileSearch("bind", bind_file, "bind"));
 103         lexrc.setFile(tmp);
 104         if (!lexrc.isOK()) {
 105                 lyxerr << "KeyMap::read: cannot open bind file:"
 106                        << tmp << endl;
 107                 return false;
 108         }
 109
 110         LYXERR(Debug::KBMAP) << "Reading bind file:" << tmp << endl;
 111
 112         bool error = false;
 113         while (lexrc.isOK()) {
 114                 switch (lexrc.lex()) {
 115                 case Lexer::LEX_UNDEF:
 116                         lexrc.printError("Unknown tag `$$Token'");
 117                         error = true;
 118                         continue;
 119                 case Lexer::LEX_FEOF:
 120                         continue;
 121                 case BN_BIND:
 122                 {
 123                         string seq, cmd;
 124
 125                         if (lexrc.next()) {
 126                                 seq = lexrc.getString();
 127                         } else {
 128                                 lexrc.printError("BN_BIND: Missing key sequence");
 129                                 error = true;
 130                                 break;
 131                         }
 132
 133                         if (lexrc.next(true)) {
 134                                 cmd = lexrc.getString();
 135                         } else {
 136                                 lexrc.printError("BN_BIND: missing command");
 137                                 error = true;
 138                                 break;
 139                         }
 140
 141                         FuncRequest func = lyxaction.lookupFunc(cmd);
 142                         if (func. action == LFUN_UNKNOWN_ACTION) {
 143                                 lexrc.printError("BN_BIND: Unknown LyX"
 144                                                  " function `$$Token'");
 145                                 error = true;
 146                                 break;
 147                         }
 148
 149                         bind(seq, func);
 150                         break;
 151                 }
 152                 case BN_BINDFILE:
 153                         if (lexrc.next()) {
 154                                 string const tmp(lexrc.getString());
 155                                 error |= !read(tmp);
 156                         } else {
 157                                 lexrc.printError("BN_BINDFILE: Missing file name");
 158                                 error = true;
 159                                 break;
 160
 161                         }
 162                         break;
 163                 }
 164         }
 165
 166         if (error)
 167                 lyxerr << "KeyMap::read: error while reading bind file:"
 168                        << tmp << endl;
 169         return !error;
 170 }
 171
 172
 173 FuncRequest const &
 174 KeyMap::lookup(KeySymbolPtr key,
 175                   key_modifier::state mod, KeySequence * seq) const
 176 {
 177         static FuncRequest const unknown(LFUN_UNKNOWN_ACTION);
 178
 179         if (table.empty()) {
 180                 seq->curmap = seq->stdmap;
 181                 seq->mark_deleted();
 182                 return unknown;
 183         }
 184
 185         Table::const_iterator end = table.end();
 186         for (Table::const_iterator cit = table.begin(); cit != end; ++cit) {
 187                 key_modifier::state mask(cit->mod.second);
 188                 key_modifier::state check =
 189                         static_cast<key_modifier::state>(mod & ~mask);
 190
 191                 if (*(cit->code) == *key && cit->mod.first == check) {
 192                         // match found
 193                         if (cit->table.get()) {
 194                                 // this is a prefix key - set new map
 195                                 seq->curmap = cit->table.get();
 196                                 static FuncRequest prefix(LFUN_COMMAND_PREFIX);
 197                                 return prefix;
 198                         } else {
 199                                 // final key - reset map
 200                                 seq->curmap = seq->stdmap;
 201                                 seq->mark_deleted();
 202                                 return cit->func;
 203                         }
 204                 }
 205         }
 206
 207         // error - key not found:
 208         seq->curmap = seq->stdmap;
 209         seq->mark_deleted();
 210
 211         return unknown;
 212 }
 213
 214
 215 docstring const KeyMap::print(bool forgui) const
 216 {
 217         docstring buf;
 218         Table::const_iterator end = table.end();
 219         for (Table::const_iterator cit = table.begin(); cit != end; ++cit) {
 220                 buf += cit->code->print(cit->mod.first, forgui);
 221                 buf += ' ';
 222         }
 223         return buf;
 224 }
 225
 226
 227 void KeyMap::defkey(KeySequence * seq, FuncRequest const & func, unsigned int r)
 228 {
 229         KeySymbolPtr code = seq->sequence[r];
 230         if (!code->isOK())
 231                 return;
 232
 233         key_modifier::state const mod1 = seq->modifiers[r].first;
 234         key_modifier::state const mod2 = seq->modifiers[r].second;
 235
 236         // check if key is already there
 237         Table::iterator end = table.end();
 238         for (Table::iterator it = table.begin(); it != end; ++it) {
 239                 if (*(code) == *(it->code)
 240                     && mod1 == it->mod.first
 241                     && mod2 == it->mod.second) {
 242                         // overwrite binding
 243                         if (r + 1 == seq->length()) {
 244                                 LYXERR(Debug::KBMAP)
 245                                         << "Warning: New binding for '"
 246                                         << to_utf8(seq->print(false))
 247                                         << "' is overriding old binding..."
 248                                         << endl;
 249                                 if (it->table.get()) {
 250                                         it->table.reset();
 251                                 }
 252                                 it->func = func;
 253                                 it->func.origin = FuncRequest::KEYBOARD;
 254                                 return;
 255                         } else if (!it->table.get()) {
 256                                 lyxerr << "Error: New binding for '"
 257                                        << to_utf8(seq->print(false))
 258                                        << "' is overriding old binding..."
 259                                                << endl;
 260                                 return;
 261                         } else {
 262                                 it->table->defkey(seq, func, r + 1);
 263                                 return;
 264                         }
 265                 }
 266         }
 267
 268         Table::iterator newone = table.insert(table.end(), Key());
 269         newone->code = code;
 270         newone->mod = seq->modifiers[r];
 271         if (r + 1 == seq->length()) {
 272                 newone->func = func;
 273                 newone->func.origin = FuncRequest::KEYBOARD;
 274                 newone->table.reset();
 275         } else {
 276                 newone->table.reset(new KeyMap);
 277                 newone->table->defkey(seq, func, r + 1);
 278         }
 279 }
 280
 281
 282 docstring const KeyMap::printbindings(FuncRequest const & func) const
 283 {
 284         odocstringstream res;
 285         Bindings bindings = findbindings(func);
 286         for (Bindings::const_iterator cit = bindings.begin();
 287              cit != bindings.end() ; ++cit)
 288                 res << '[' << cit->print(true) << ']';
 289         return res.str();
 290 }
 291
 292
 293 KeyMap::Bindings KeyMap::findbindings(FuncRequest const & func) const
 294 {
 295         return findbindings(func, KeySequence(0, 0));
 296 }
 297
 298
 299 KeyMap::Bindings KeyMap::findbindings(FuncRequest const & func,
 300                         KeySequence const & prefix) const
 301 {
 302         Bindings res;
 303         if (table.empty()) return res;
 304
 305         Table::const_iterator end = table.end();
 306         for (Table::const_iterator cit = table.begin();
 307             cit != end; ++cit) {
 308                 if (cit->table.get()) {
 309                         KeySequence seq = prefix;
 310                         seq.addkey(cit->code, cit->mod.first);
 311                         Bindings res2 =
 312                                 cit->table->findbindings(func, seq);
 313                         res.insert(res.end(), res2.begin(), res2.end());
 314                 } else if (cit->func == func) {
 315                         KeySequence seq = prefix;
 316                         seq.addkey(cit->code, cit->mod.first);
 317                         res.push_back(seq);
 318                 }
 319         }
 320
 321         return res;
 322 }
 323
 324
 325 std::pair<KeySymbol const *, key_modifier::state>
 326 KeyMap::find1keybinding(FuncRequest const & func) const
 327 {
 328         Table::const_iterator end = table.end();
 329         for (Table::const_iterator cit = table.begin();
 330             cit != end; ++cit) {
 331                 if (!cit->table.get() && cit->func == func)
 332                         return std::make_pair(cit->code.get(), cit->mod.first);
 333         }
 334
 335         return std::make_pair<KeySymbol const *, key_modifier::state>(0, key_modifier::none);
 336 }
 337
 338
 339 } // namespace lyx