Fix bug #9544: Mark file clean after we write it.

[lyx.git] / src / mathed / MathMacro.h

diff --git a/src/mathed/MathMacro.h b/src/mathed/MathMacro.h
index 801c19dfb8d9d5972028aa31b82406cbacc857f2..b389e272e4b2f3aa4ff3bad1799c19876f4d03ef 100644 (file)
--- a/src/mathed/MathMacro.h
+++ b/src/mathed/MathMacro.h
@@ -14,7 +14,6 @@
 #define MATH_MACRO_H
 
 #include "InsetMathNest.h"
-#include "InsetMathSqrt.h"
 #include "MacroTable.h"
 #include "MathData.h"
 
@@ -26,7 +25,13 @@ namespace lyx {
 class MathMacro : public InsetMathNest {
 public:
        /// A macro can be built from an existing template
-       MathMacro(docstring const & name);
+       MathMacro(Buffer * buf, docstring const & name);
+       ///
+       MathMacro(MathMacro const &);
+       ///
+       MathMacro & operator=(MathMacro const &);
+       ///
+       ~MathMacro();
        ///
        virtual MathMacro * asMacro() { return this; }
        ///
@@ -57,7 +62,7 @@ public:
 
        ///
        virtual bool notifyCursorLeaves(Cursor const & old, Cursor & cur);
-       
+
        /// Remove cell (starting from 0)
        void removeArgument(pos_type pos);
        /// Insert empty cell (starting from 0)
@@ -69,10 +74,18 @@ public:
        ///
        void write(WriteStream & os) const;
        ///
+       void normalize(NormalStream & os) const;
+       ///
        void maple(MapleStream &) const;
        ///
+       void maxima(MaximaStream &) const;
+       ///
+       void mathematica(MathematicaStream &) const;
+       ///
        void mathmlize(MathStream &) const;
        ///
+       void htmlize(HtmlStream &) const;
+       ///
        void octave(OctaveStream &) const;
        ///
        void infoize(odocstream &) const;
@@ -85,41 +98,35 @@ public:
        void unfold(Cursor & cur);
        /// will it be folded or unfolded in the next metric call?
        bool folded() const;
-               
+
        enum DisplayMode {
                DISPLAY_INIT,
                DISPLAY_INTERACTIVE_INIT,
                DISPLAY_UNFOLDED,
-               DISPLAY_NORMAL,
+               DISPLAY_NORMAL
        };
 
        ///
-       DisplayMode displayMode() const { return displayMode_; }
+       DisplayMode displayMode() const;
 
        ///
-       bool extraBraces() const { return displayMode_ == DISPLAY_NORMAL && arity() > 0; }
+       bool extraBraces() const;
 
        ///
        docstring name() const;
        ///
+       docstring macroName() const;
+       ///
        bool validName() const;
        ///
-       size_t arity() const { 
-               if (displayMode_ == DISPLAY_NORMAL )
-                       return cells_.size();
-               else
-                       return 0;
-       }
-               
+       size_t arity() const;
+
        ///
-       size_t optionals() const { return optionals_; }
+       size_t optionals() const;
        ///
-       void setOptionals(int n) { 
-               if (n <= int(nargs()))
-                       optionals_ = n;
-       }
+       void setOptionals(int n);
        /// Return the maximal number of arguments the macro is greedy for.
-       size_t appetite() const { return appetite_; }
+       size_t appetite() const;
        ///
        InsetCode lyxCode() const { return MATH_MACRO_CODE; }
 
@@ -135,7 +142,7 @@ protected:
        /// update macro definition
        void updateMacro(MacroContext const & mc);
        /// check if macro definition changed, argument changed etc. and adapt
-       void updateRepresentation();
+       void updateRepresentation(Cursor * cur, MacroContext const & mc, UpdateType);
        /// empty macro, put arguments into args, possibly strip arity-attachedArgsNum_ empty ones.
        /// Includes the optional arguments.
        void detachArguments(std::vector<MathData> & args, bool strip);
@@ -143,7 +150,7 @@ protected:
        /// including the optional ones (even if it can be empty here)
        void attachArguments(std::vector<MathData> const & args, size_t arity, int optionals);
        ///
-       MacroData const * macro() { return macro_; }
+       MacroData const * macro();
        ///
        bool editMetrics(BufferView const * bv) const;
 
@@ -152,35 +159,14 @@ private:
        virtual Inset * clone() const;
        ///
        bool editMode(BufferView const * bv) const;
-       
-       /// name of macro
-       docstring name_;
-       /// current display mode
-       DisplayMode displayMode_;
-       /// expanded macro with ArgumentProxies
-       InsetMathSqrt expanded_;
-       /// macro definition with #1,#2,.. insets
-       MathData definition_;
-       /// number of arguments that were really attached
-       size_t attachedArgsNum_;
-       /// optional argument attached? (only in DISPLAY_NORMAL mode)
-       size_t optionals_;
-       /// fold mode to be set in next metrics call?
-       bool nextFoldMode_;
-       /// if macro_ == true, then here is a copy of the macro
-       /// don't use it for locking
-       MacroData macroBackup_;
-       /// if macroNotFound_ == false, then here is a reference to the macro
-       /// this might invalidate after metrics was called
-       MacroData const * macro_;
-       ///
-       mutable std::map<BufferView const *, bool> editing_;
-       ///
-       std::string requires_;
-       /// update macro representation
-       bool needsUpdate_;
-       /// maximal number of arguments the macro is greedy for
-       size_t appetite_;
+
+       ///
+       class Private;
+       ///
+       Private * d;
+       /// update lock to avoid loops
+       class UpdateLocker;
+       friend class UpdateLocker;
 
 public:
        ///