Provide proper fallback if a bibliography processor is not found

[lyx.git] / src / KeySequence.cpp

diff --git a/src/KeySequence.cpp b/src/KeySequence.cpp
index 19677388749c217632e20a256fd3f84aef37ba7e..c80490f38fafa03f72f6a7183554157128a9bfed 100644 (file)
--- a/src/KeySequence.cpp
+++ b/src/KeySequence.cpp
@@ -3,7 +3,7 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
  * \author Jean-Marc Lasgouttes
  * \author John Levon
  *
@@ -13,21 +13,18 @@
 #include <config.h>
 
 #include "KeySequence.h"
-
-#include "gettext.h"
 #include "KeyMap.h"
-#include "lfuns.h"
 
-#include "frontends/KeySymbol.h"
+#include "support/gettext.h"
 
-using std::make_pair;
-using std::string;
+#include "frontends/KeySymbol.h"
 
+using namespace std;
 
 namespace lyx {
 
 FuncRequest const & KeySequence::addkey(KeySymbol const & key,
-       key_modifier::state mod, key_modifier::state nmod)
+       KeyModifier mod, KeyModifier nmod)
 {
        // adding a key to a deleted sequence
        // starts a new sequence
@@ -40,12 +37,10 @@ FuncRequest const & KeySequence::addkey(KeySymbol const & key,
        modifiers.push_back(make_pair(mod, nmod));
        sequence.push_back(key);
 
-       if (curmap) {
+       if (curmap)
                return curmap->lookup(key, mod, this);
-       }
 
-       static FuncRequest unknown(LFUN_UNKNOWN_ACTION);
-       return unknown;
+       return FuncRequest::unknown;
 }
 
 
@@ -55,8 +50,8 @@ size_t KeySequence::parse(string const & s)
                return 1;
 
        size_t i = 0;
-       key_modifier::state mod = key_modifier::none;
-       key_modifier::state nmod = key_modifier::none;
+       KeyModifier mod = NoModifier;
+       KeyModifier nmod = NoModifier;
 
        while (i < s.length()) {
                if (s[i] == ' ')
@@ -67,15 +62,21 @@ size_t KeySequence::parse(string const & s)
                if (i + 1 < s.length() && s[i + 1] == '-') {
                        switch (s[i]) {
                        case 's': case 'S':
-                               mod |= key_modifier::shift;
+                               mod |= ShiftModifier;
                                i += 2;
                                continue;
                        case 'c': case 'C':
-                               mod |= key_modifier::ctrl;
+                               mod |= ControlModifier;
                                i += 2;
                                continue;
                        case 'm': case 'M':
-                               mod |= key_modifier::alt;
+#if defined(USE_MACOSX_PACKAGING) || defined(USE_META_KEYBINDING)
+                               mod |= MetaModifier;
+                               i += 2;
+                               continue;
+#endif
+                       case 'a': case 'A':
+                               mod |= AltModifier;
                                i += 2;
                                continue;
                        default:
@@ -85,15 +86,21 @@ size_t KeySequence::parse(string const & s)
                           && s[i + 2] == '-') {
                        switch (s[i + 1]) {
                        case 's': case 'S':
-                               nmod |= key_modifier::shift;
+                               nmod |= ShiftModifier;
                                i += 3;
                                continue;
                        case 'c': case 'C':
-                               nmod |= key_modifier::ctrl;
+                               nmod |= ControlModifier;
                                i += 3;
                                continue;
                        case 'm': case 'M':
-                               nmod |= key_modifier::alt;
+#if defined(USE_MACOSX_PACKAGING) || defined(USE_META_KEYBINDING)
+                               nmod |= MetaModifier;
+                               i += 3;
+                               continue;
+#endif
+                       case 'a': case 'A':
+                               nmod |= AltModifier;
                                i += 3;
                                continue;
                        default:
@@ -114,12 +121,11 @@ size_t KeySequence::parse(string const & s)
                        i = j;
 
                        addkey(key, mod, nmod);
-                       mod = key_modifier::none;
+                       mod = NoModifier;
                }
        }
 
-       // empty sequence?
-       if (sequence.size() == 0)
+       if (sequence.empty())
                return 0;
 
        // everything is fine
@@ -127,14 +133,36 @@ size_t KeySequence::parse(string const & s)
 }
 
 
-docstring const KeySequence::print(bool forgui) const
+docstring const KeySequence::print(outputFormat format) const
 {
        docstring buf;
 
        size_t const length = sequence.size();
 
        for (size_t i = 0; i != length; ++i) {
-               buf += sequence[i].print(modifiers[i].first, forgui);
+               switch (format) {
+               case Portable:
+                       buf += sequence[i].print(modifiers[i].first, false);
+                       break;
+               case ForGui:
+                       buf += sequence[i].print(modifiers[i].first, true);
+                       break;
+               case BindFile:
+                       KeyModifier mod = modifiers[i].first;
+                       if (mod & ControlModifier)
+                               buf += "C-";
+                       if (mod & AltModifier)
+#if defined(USE_MACOSX_PACKAGING) || defined(USE_META_KEYBINDING)
+                               buf += "A-";
+                       if (mod & MetaModifier)
+#endif
+                               buf += "M-";
+                       if (mod & ShiftModifier)
+                               buf += "S-";
+
+                       buf += from_utf8(sequence[i].getSymbolName());
+                       break;
+               }
                // append a blank
                if (i + 1 != length)
                        buf += ' ';
@@ -145,26 +173,20 @@ docstring const KeySequence::print(bool forgui) const
 
 docstring const KeySequence::printOptions(bool forgui) const
 {
-       docstring buf = print(forgui);
+       docstring buf = print(forgui ? ForGui : Portable);
 
        if (!curmap)
                return buf;
 
        buf += _("   options: ");
-       buf += curmap->print(forgui);
+       buf += curmap->print(forgui ? ForGui : Portable);
        return buf;
 }
 
 
-void KeySequence::mark_deleted()
-{
-       deleted_ = true;
-}
-
-
 void KeySequence::reset()
 {
-       mark_deleted();
+       deleted_ = true;
        curmap = stdmap;
 }
 
@@ -176,4 +198,15 @@ void KeySequence::clear()
 }
 
 
+void KeySequence::removeKey()
+{
+       if (deleted_)
+               return;
+       sequence.pop_back();
+       modifiers.pop_back();
+       if (sequence.empty())
+               deleted_ = true;
+}
+
+
 } // namespace lyx