X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FLyXAction.h;h=5203bc4fcd62338098f481f240fb8e7283953e34;hb=823e44822e6638824900eee2f7e2e7165af97f8d;hp=2c1bda9e2b685d402c450ecf47c69e0709913f96;hpb=27de1486ca34aaad446adb798d71a77d6f6304da;p=lyx.git diff --git a/src/LyXAction.h b/src/LyXAction.h index 2c1bda9e2b..5203bc4fcd 100644 --- a/src/LyXAction.h +++ b/src/LyXAction.h @@ -1,93 +1,130 @@ // -*- C++ -*- -#ifndef _LYXACTION_H_ -#define _LYXACTION_H_ +/** + * \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. + */ -#ifdef __GNUG__ -#pragma interface -#endif +#ifndef LYXACTION_H +#define LYXACTION_H -#include "commandtags.h" +#include "FuncCode.h" -class LString; +#include +#include -/// Command name - action -struct kb_func_table { - /// - char const *name; - /// - kb_action action; -}; +namespace lyx { + +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 func_type { + 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: + /// information for an action + struct FuncInfo { + /// the action name + std::string name; + /// the func_attrib values set + unsigned int attrib; + /// the category of this func + func_type type; + }; + +public: + /// noncopyable + LyXAction(LyXAction const &); + void operator=(LyXAction const &); + + /// type for map between a function name and its action + typedef std::map func_map; + /// type for map between an action and its info + typedef std::map info_map; + + /// possible "permissions" for an action + enum func_attrib { + Noop = 0, //< Nothing special about this func + ReadOnly = 1, //< Can be used in RO mode (perhaps this should change); no automatic markDirty + 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 + }; + LyXAction(); - /// - ~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(char const *func_name); - - /** Returns an action tag which name is the most similar to a string. - Don't include arguments, they would be ignored. */ - int getApproxFunc(char const *func); - - /** Returns an action name the most similar to a string. - Don't include arguments, they would be ignored. */ - const char *getApproxFuncName(char const *func); - - /// Returns a pseudo-action given an action and its argument. - int getPseudoAction(kb_action action, char const *arg); - - /// Retrieves the real action and its argument. - int retrieveActionArg(int i, char const **arg); - - /// Search for an existent pseudoaction, return -1 if it doesn't exist. - int searchActionArg(kb_action action, char const *arg); - - /// Check if a value is a pseudo-action. - bool isPseudoAction(int); - - /// Not sure if this function should be here - int bindKey(char const* seq, int action); - - /// Return the name associated with command - char const *getActionName(int action) const; - - /// Return one line help text associated with command - char const *helpText(kb_action action) const; - - /// True if the command is Read Only (not allowed for RO buffers) - bool isFuncRO(kb_action action) const; + + /** + * Returns an pseudoaction from a string + * If you include arguments in func_name, a new pseudoaction + * will be created if needed. + */ + FuncRequest lookupFunc(std::string const & func_name) const; + + /// Return the name (and argument) associated with the given (pseudo) action + std::string const getActionName(FuncCode action) const; + + func_type getActionType(FuncCode action) const; + + /// True if the command has `flag' set + bool funcHasFlag(FuncCode action, func_attrib flag) const; + + /// iterator across all real actions + typedef func_map::const_iterator const_func_iterator; + + /// return an iterator to the start of all real actions + const_func_iterator func_begin() const; + + /// return an iterator to the end of all real actions + const_func_iterator func_end() const; private: - - /// Standard commands - static kb_func_table const * lyx_func_table; - /// Number of commands - int funcCount; - /// Pseudoactions - static kb_func_table *lyx_func_args; - /// Pseudoaction index - static int psd_idx; - /// Last action index found - int last_action_idx; + /// populate the action container with our actions + void init(); + /// add the given action + void newFunc(FuncCode, std::string const & name, unsigned int attrib, func_type type); + + /** + * 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. command name (string), + * command attributes (ro) + */ + info_map lyx_info_map; }; - - -/* -------------------- Inlines ------------------ */ - - -inline -bool LyXAction::isPseudoAction(int a) -{ - return (a >= (int)LFUN_LASTACTION); -} - - -#endif + +LyXErr & operator<<(LyXErr &, FuncCode); + +/// singleton instance +extern LyXAction lyxaction; + + +} // namespace lyx + +#endif // LYXACTION_H