X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FKeyMap.h;h=cd28782356ac98336fb791def7b84c5d5824d789;hb=3d4076b598deb18660e50ec9c327efc3b15f15d0;hp=bb28d37433e4df7c23d0fef004cef112628cff5d;hpb=c4033d401202ffc57b5a04ef9cf83b494b7ddfa0;p=lyx.git diff --git a/src/KeyMap.h b/src/KeyMap.h index bb28d37433..cd28782356 100644 --- a/src/KeyMap.h +++ b/src/KeyMap.h @@ -4,7 +4,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 * @@ -15,35 +15,84 @@ #define KEYMAP_H #include "FuncRequest.h" +#include "KeySequence.h" -#include "frontends/KeyModifier.h" -#include "frontends/KeySymbol.h" +#include "support/strfwd.h" -#include "support/docstream.h" - -#include +#include "support/shared_ptr.h" #include -#include namespace lyx { -class KeySequence; +namespace support { + class FileName; +} /// Defines key maps and actions for key sequences class KeyMap { public: + enum ItemType { + System, //< loaded from a bind file + UserBind, //< \bind loaded from user.bind + UserUnbind, //< \unbind loaded from user.bind, with corresponding + //< entry in system bind file + UserExtraUnbind //< \unbind loaded from user.bind, without + //< corresponding entry in system bind file. + }; + enum BindReadType { + MissingOK, //< It's OK if this file is missing. + Fallback, //< If missing, fallback to default "cua". This should only + //< be used when attempting to read the user-secified bind file. + Default //< Report error and return. + }; /** - * Bind a key sequence to an action. + * Bind/Unbind a key sequence to an action. * @return 0 on success, or position in string seq where error * occurs. * See KeySequence::parse for the syntax of the seq string */ size_t bind(std::string const & seq, FuncRequest const & func); + size_t unbind(std::string const & seq, FuncRequest const & func); + + /** + * Define/Undefine an action for a key sequence. + * @param r internal recursion level + */ + void bind(KeySequence * seq, FuncRequest const & func, + unsigned int r = 0); + void unbind(KeySequence * seq, FuncRequest const & func, + unsigned int r = 0); + + + /// returns the function bound to this key sequence, or + /// FuncRequest::unknown if no binding exists for it. + /// @param r an internal recursion counter + // FIXME Surely there's a better way to do that? + FuncRequest getBinding(KeySequence const & seq, unsigned int r = 0); + + /// clear all bindings + void clear(); - // Parse a bind file - bool read(std::string const & bind_file); + /** Parse a bind file. If a valid unbind_map is given, put \unbind + * bindings to a separate KeyMap. This is used in the Shortcut preference + * dialog where main and user bind files are loaded separately so \unbind + * in user.bind can not nullify \bind in the master bind file. + * + * @param bind_file bind file + * @param unbind_map pointer to a KeyMap that holds \unbind bindings + * @param rt how to respond if the file can't be found + */ + bool read(std::string const & bind_file, KeyMap * unbind_map = 0, + BindReadType rt = Default); + + /** write to a bind file. + * @param append append to the bind_file instead of overwrite it + * @param unbind use \unbind instead of \bind, indicating this KeyMap + * actually record unbind maps. + */ + void write(std::string const & bind_file, bool append, bool unbind = false) const; /** * print all available keysyms @@ -60,16 +109,32 @@ public: * @return the action / LFUN_COMMAND_PREFIX / LFUN_UNKNOWN_ACTION */ FuncRequest const & - lookup(KeySymbol const & key, KeyModifier mod, KeySequence * seq) const; + lookup(KeySymbol const & key, KeyModifier mod, KeySequence * seq) const; /// - typedef std::deque Bindings; + typedef std::vector Bindings; /// Given an action, find all keybindings. - Bindings findbindings(FuncRequest const & func) const; + Bindings findBindings(FuncRequest const & func) const; /// Given an action, print the keybindings. - docstring const printbindings(FuncRequest const & func) const; + docstring printBindings(FuncRequest const & func, + KeySequence::outputFormat format) const; + + struct Binding { + Binding(FuncRequest const & r, KeySequence const & s, ItemType t) + : request(r), sequence(s), tag(t) {} + FuncRequest request; + KeySequence sequence; + KeyMap::ItemType tag; + }; + typedef std::vector BindingList; + /** + * Return all lfun and their associated bindings. + * @param unbound list unbound (func without any keybinding) as well + * @param tag an optional tag to indicate the source of the bindinglist + */ + BindingList listBindings(bool unbound, ItemType tag = System) const; /** * Given an action, find the first 1-key binding (if it exists). @@ -77,8 +142,7 @@ public: * [only used by the Qt/Mac frontend] */ std::pair - find1keybinding(FuncRequest const & func) const; - + find1keybinding(FuncRequest const & func) const; /** * Returns a string of the given keysym, with modifiers. @@ -88,38 +152,43 @@ public: static std::string const printKeySym(KeySymbol const & key, KeyModifier mod); +private: + /// typedef std::pair ModifierPair; -private: /// struct Key { /// Keysym KeySymbol code; - /// Modifier masks ModifierPair mod; - /// Keymap for prefix keys - boost::shared_ptr table; - + shared_ptr prefixes; /// Action for !prefix keys FuncRequest func; }; - /** - * Define an action for a key sequence. - * @param r internal recursion level - */ - void defkey(KeySequence * seq, FuncRequest const & func, - unsigned int r = 0); + enum ReturnValues { + ReadOK, + ReadError, + FileError, + FormatMismatch + }; + /// + bool read(support::FileName const & bind_file, KeyMap * unbind_map = 0); + /// + ReturnValues readWithoutConv(support::FileName const & bind_file, KeyMap * unbind_map = 0); /** * Given an action, find all keybindings * @param func the action * @param prefix a sequence to prepend the results */ - Bindings findbindings(FuncRequest const & func, - KeySequence const & prefix) const; + Bindings findBindings(FuncRequest const & func, + KeySequence const & prefix) const; + + void listBindings(BindingList & list, KeySequence const & prefix, + ItemType tag) const; /// is the table empty ? bool empty() const { return table.empty(); }