X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FLyXAction.h;h=f61772c56c9239ebfc98f5712d4bfe1f05b8d7b6;hb=79cf3f5ec1088e7de988e889247ec300d42fb70b;hp=0fdc4c916b6ad4928e45b171c65a0804ba41f3cc;hpb=9ce32d63e5ff1dbf4c04e3d8263b2649ef3ac595;p=lyx.git diff --git a/src/LyXAction.h b/src/LyXAction.h index 0fdc4c916b..f61772c56c 100644 --- a/src/LyXAction.h +++ b/src/LyXAction.h @@ -1,131 +1,138 @@ // -*- C++ -*- +/** + * \file LyXAction.h + * This file is part of LyX, the document processor. + * Licence details can be found in the file COPYING. + * + * \author Lars Gullik Bjønnes + * \author John Levon + * + * Full author contact details are available in file CREDITS. + */ + #ifndef LYXACTION_H #define LYXACTION_H -#ifdef __GNUG__ -#pragma interface -#endif +#include "FuncCode.h" #include -using std::map; -using std::less; +#include + + +namespace lyx { + +// current LFUN format +static unsigned int const LFUN_FORMAT = 4; // gm: tabular-feature -#include "commandtags.h" -#include "LString.h" +class FuncRequest; +class LyXErr; -/** This class encapsulates LyX action and user command operations. +/** + * This class is a container for LyX actions. It associates a name to + * most of them and describes some of their properties. */ class LyXAction { +public: + /// category of an action, used in the Shortcuts dialog + enum FuncType { + Hidden, //< Not listed for configuration + Edit, //< Cursor and mouse movement, copy/paste etc + Math, //< Mathematics + Buffer, //< Buffer and window related + Layout, //< Font, Layout and textclass related + System //< Lyx preference, server etc + }; + private: - /// - struct func_info { - string name; + /// information for an action + struct FuncInfo { + /// the action name + std::string name; + /// the FuncAttribs values set unsigned int attrib; - string helpText; + /// the category of this func + FuncType type; }; + /// type for map between a function name and its action + typedef std::map FuncMap; + /// type for map between an action and its info + typedef std::map InfoMap; - /// - struct pseudo_func { - kb_action action; - string arg; - }; public: - /// - typedef map > func_map; - /// - typedef map > info_map; - /// - typedef map > pseudo_map; - /// - typedef map > arg_item; - /// - typedef map > arg_map; - - /// - enum func_attrib { - /// nothing special about this func - Noop = 0, - /// can be used in RO mode (perhaps this should change) - ReadOnly = 1, // , - /// Can be used when there is no document open - NoBuffer = 2, - //Interactive = 2, // Is interactive (requires a GUI) - Argument=4 // Requires argument - //MathOnly = 8, // Only math mode - //EtcEtc = ... // Or other attributes... + /// possible "permissions" for an action + enum FuncAttribs { + Noop = 0, //< Nothing special about this func + ReadOnly = 1, //< Can be used in RO mode (perhaps this should change) + NoBuffer = 2, //< Can be used when there is no document open + Argument = 4, //< Requires argument + NoUpdate = 8, //< Does not (usually) require update + SingleParUpdate = 16, //< Usually only requires this par updated + AtPoint = 32, //< dispatch first to inset at cursor if there is one + NoInternal = 64 //< Cannot be used for internal, non-document Buffers }; - - /// + LyXAction(); - - /** Returns an action tag from a string. Returns kb_action. - Include arguments in func_name ONLY if you - want to create new pseudo actions. */ - int LookupFunc(string const & func_name) const; - - /** Returns an action tag which name is the most similar to a string. - Don't include arguments, they would be ignored. */ - int getApproxFunc(string const & func) const; - - /** Returns an action name the most similar to a string. - Don't include arguments, they would be ignored. */ - string getApproxFuncName(string const & func) const; - - /// Returns a pseudo-action given an action and its argument. - int getPseudoAction(kb_action action, string const & arg) const; - - /// Retrieves the real action and its argument. - kb_action retrieveActionArg(int i, string & arg) const; - - /// Search for an existent pseudoaction, return -1 if it doesn't exist. - int searchActionArg(kb_action action, string const & arg) const; - - /// Check if a value is a pseudo-action. - bool isPseudoAction(int) const; - - /// Return the name associated with command - string getActionName(int action) const; - - /// Return one line help text associated with (pseudo)action - string helpText(int action) const; + + /** + * Creates a FuncRequest from a string of the form: + * lyx-function [argument] + * where the argument is optional and "lyx-function" is in the form you'd + * enter it in the mini-buffer. + */ + FuncRequest lookupFunc(std::string const & func_name) const; + + /// Return the command name associated with the given action + /// Thus: getActionName(LFUN_ERT_INSERT) --> "ert-insert". + std::string const getActionName(FuncCode action) const; + /// + FuncType getActionType(FuncCode action) const; /// True if the command has `flag' set - bool funcHasFlag(kb_action action, func_attrib flag) const; + bool funcHasFlag(FuncCode action, FuncAttribs flag) const; + + /// iterator across all LFUNs + typedef FuncMap::const_iterator const_iterator; + + /// return an iterator to the start of the list of LFUNs + const_iterator func_begin() const; + + /// return an iterator to one past the end of the list of LFUNs + const_iterator func_end() const; private: - /// + /// noncopyable + LyXAction(LyXAction const &); + void operator=(LyXAction const &); + + /// populate the action container with our actions void init(); - /// - void newFunc(kb_action, string const & name, - string const & helpText, unsigned int attrib); - - /** This is a list of all the LyXFunc names with the - coresponding action number. It is usually only used by the - minibuffer or when assigning commands to keys during init. */ - func_map lyx_func_map; - - /** This is a mapping from action number to an object holding - info about this action. f.ex. helptext, command name (string), - command attributes (ro) */ - info_map lyx_info_map; - - /** A mapping from the automatically created pseudo action number - to the real action and its argument. */ - mutable pseudo_map lyx_pseudo_map; - - /** A (multi) mapping from the lyx action to all the generated - pseudofuncs and the arguments the action should use. */ - mutable arg_map lyx_arg_map; + /// add the given action + void newFunc(FuncCode, std::string const & name, unsigned int attrib, FuncType type); + + /** + * This maps LyX function names to function codes, e.g.: + * lyx_func_map["ert-insert"] == LFUN_ERT_INSERT + */ + FuncMap lyx_func_map; + + /** + * This maps function codes to objects holding info about the corresponding + * action. E.g., if + * FuncInfo const & ert = lyx_info_map[LFUN_ERT_INSERT]; + * then: + * ert.name == "ert-insert"' + * ert.attrib == Noop + * ert.type == Edit + */ + InfoMap lyx_info_map; }; - - -/* -------------------- Inlines ------------------ */ - - -inline -bool LyXAction::isPseudoAction(int a) const -{ - return a > int(LFUN_LASTACTION); -} - -#endif + +LyXErr & operator<<(LyXErr &, FuncCode); + +/// singleton instance +extern LyXAction lyxaction; + + +} // namespace lyx + +#endif // LYXACTION_H