Two patches from Claus; two patches from Andre' (with additional bugfixes)

[lyx.git] / src / lyxfunc.h

diff --git a/src/lyxfunc.h b/src/lyxfunc.h
index 3abd7ce1ff968ef609c2358670552abe818e687e..24a0456f17781298b6d190762482b2fe6ac9c2a9 100644 (file)
--- a/src/lyxfunc.h
+++ b/src/lyxfunc.h
@@ -7,11 +7,10 @@
 #endif
 
 #include "commandtags.h"
-#include "kbmap.h"
-#include "tex-accent.h"
-#include "LyXAction.h"
+#include "kbsequence.h"
 #include "insets/lyxinset.h"
 #include "LString.h"
+
 class LyXView;
 
 /** This class encapsulates all the LyX command operations. 
@@ -22,63 +21,60 @@ class LyXView;
 */
 class LyXFunc {
 public:
-       ///
-       LyXFunc(LyXView*);
-       ///
-       ~LyXFunc();
+       /// The status of a function.
+       enum func_status {
+               OK = 0, // No problem
+               Unknown = 1,
+               Disabled = 2, // Command cannot be executed
+               ToggleOn = 4,
+               ToggleOff = 8
+       };
+       ///
+       explicit
+       LyXFunc(LyXView *);
     
        /// LyX distpatcher, executes lyx actions.
-       string Dispatch(int action, char const* arg = 0);
+       string Dispatch(int action, char const * arg = 0);
                         
        /// The same but uses the name of a lyx command.
-       string Dispatch(string const &cmd, string const &arg = string());
+       string Dispatch(string const & cmd);
 
-       
        /// A keyboard event is processed to execute a lyx action. 
-       int  processKeyEvent(XEvent *ev);
-     
+       int  processKeyEvent(XEvent * ev);
+
+       ///
+       func_status getStatus(int ac) const;
+       
        /// The last key was meta
-       bool wasMetaKey();
+       bool wasMetaKey() const;
 
-       // These can't be global because are part of the internat state (ale970227)
+       // These can't be global because are part of the
+       // internal state (ale970227)
        /// Get the current keyseq string
-       string keyseqStr(int l=190);
+       string keyseqStr() const;
 
        /// Is the key sequence uncomplete?
-       bool keyseqUncomplete();
+       bool keyseqUncomplete() const;
 
        /// get options for the current keyseq
-       string keyseqOptions(int l=190);
-
-       /// Returns the name of a funcion given a keyseq
-       char const* getFunc(char*) 
-       { /* unimplemented */ return 0; }
-
-       /// Return a string with the keybind to an action, if any
-       char const* getKeybind(int) 
-       { /* unimplemented */ return 0; }
+       string keyseqOptions() const;
 
         /// True if lyxfunc reports an error
         bool errorStat() const { return errorstat; }
         /// Buffer to store result messages
-        void setMessage(string const &m);
+        void setMessage(string const & m);
         /// Buffer to store result messages
-        void setErrorMessage(string const &); 
+        void setErrorMessage(string const &) const; 
         /// Buffer to store result messages
         string getMessage() const { return dispatch_buffer; }
         /// Get next inset of this class from current cursor position  
-        Inset* getInsetByCode(Inset::Code);
+        Inset * getInsetByCode(Inset::Code);
        
        /// Should a hint message be displayed?
        void setHintMessage(bool);
-
 private:
        ///
-       LyXView *owner;
-       ///
-       static kb_func_table* lyx_func_table;
-       ///
-       static kb_func_table *lyx_func_args;
+       LyXView * owner;
        ///
        static int psd_idx;
        ///
@@ -96,12 +92,12 @@ private:
         ///
         kb_action lyx_calling_dead_action;
         /// Error status, only Dispatch can change this flag
-        bool errorstat;
+        mutable bool errorstat;
 
         /** Buffer to store messages and result data. Is there a
-         good reason to have this one as static in Dispatch? (Ale)
-         */
-        string dispatch_buffer;
+           good reason to have this one as static in Dispatch? (Ale)
+       */
+        mutable string dispatch_buffer;
        /// Command name and shortcut information
        string commandshortcut;
 
@@ -114,10 +110,9 @@ private:
        void MenuOpen();
 
        ///
-       void doImportLaTeX(bool);
-
-       ///
-       void doImportASCII(bool);
+       void doImport(string const &);
+       void doImportHelper(string const &, string const &, string const &,
+               bool func(BufferView *, string const &) );
 
        ///
        void MenuInsertLyXFile(string const &);
@@ -134,42 +129,50 @@ private:
 /*--------------------  inlines  --------------------------*/
 
 inline
-bool LyXFunc::wasMetaKey() 
+bool LyXFunc::wasMetaKey() const 
 { 
        return (meta_fake_bit != 0);
 }
      
 
 inline
-string LyXFunc::keyseqStr(int l)
+string LyXFunc::keyseqStr() const
 {
-       char text[200];
-       keyseq.print(text, l, true);
-       string tmp(text);
-       return tmp;
+       // Why not just remove this function
+       string text;
+       keyseq.print(text, true);
+       return text;
 } 
 
 
 inline
-string LyXFunc::keyseqOptions(int l)
+string LyXFunc::keyseqOptions() const
 {
-       char text[200];
-       keyseq.printOptions(text, l);
-       string tmp(text);
-       return tmp;
+       // Why not just remove this function
+       string text;
+       keyseq.printOptions(text);
+       return text;
 } 
 
 
 inline
-bool LyXFunc::keyseqUncomplete() 
+bool LyXFunc::keyseqUncomplete() const
 { 
        return (keyseq.length > 0);
 }
 
+
 inline
 void LyXFunc::setHintMessage(bool hm) 
 { 
        show_sc = hm;
 }
 
+
+inline
+void operator|=(LyXFunc::func_status & fs, LyXFunc::func_status f)
+{
+       fs = static_cast<LyXFunc::func_status>(fs | f);
+}
+
 #endif