#define MATH_MACRO_H
#include "InsetMathNest.h"
-#include "MathArray.h"
-#include "InsetMathNest.h"
-#include "MathMacroTable.h"
+#include "InsetMathSqrt.h"
+#include "MacroTable.h"
+#include "MathData.h"
+#include <map>
namespace lyx {
-
/// This class contains the data for a macro.
class MathMacro : public InsetMathNest {
public:
/// A macro can be built from an existing template
- MathMacro(docstring const & name, int numargs);
+ MathMacro(docstring const & name);
///
- void draw(PainterInfo & pi, int x, int y) const;
+ virtual MathMacro * asMacro() { return this; }
+ ///
+ virtual MathMacro const * asMacro() const { return this; }
///
- void drawExpanded(PainterInfo & pi, int x, int y) const;
+ void draw(PainterInfo & pi, int x, int y) const;
/// draw selection background
void drawSelection(PainterInfo & pi, int x, int y) const;
/// draw decorations.
void drawDecoration(PainterInfo & pi, int x, int y) const
{ drawMarkers2(pi, x, y); }
///
- bool metrics(MetricsInfo & mi, Dimension & dim) const;
+ void metrics(MetricsInfo & mi, Dimension & dim) const;
+ ///
+ int kerning(BufferView const * bv) const;
/// get cursor position
void cursorPos(BufferView const & bv, CursorSlice const & sl,
bool boundary, int & x, int & y) const;
///
- InsetBase * editXY(LCursor & cur, int x, int y);
- /// target pos when we enter the inset from the left by pressing "Right"
- bool idxFirst(LCursor &) const;
- /// target pos when we enter the inset from the right by pressing "Left"
- bool idxLast(LCursor &) const;
+ void edit(Cursor & cur, bool left);
///
- virtual bool notifyCursorLeaves(LCursor &);
- ///
- docstring name() const;
+ Inset * editXY(Cursor & cur, int x, int y);
+
+ /// target pos when we enter the inset while moving forward
+ bool idxFirst(Cursor &) const;
+ /// target pos when we enter the inset while moving backwards
+ bool idxLast(Cursor &) const;
+
///
- void setExpansion(MathArray const & exp, MathArray const & args) const;
+ virtual bool notifyCursorLeaves(Cursor &);
+
+ /// Remove cell (starting from 0)
+ void removeArgument(pos_type pos);
+ /// Insert empty cell (starting from 0)
+ void insertArgument(pos_type pos);
///
void validate(LaTeXFeatures &) const;
+ ///
+ void write(WriteStream & os) const;
///
void maple(MapleStream &) const;
///
///
void infoize2(odocstream &) const;
-private:
- virtual std::auto_ptr<InsetBase> doClone() const;
+ /// fold the macro in the next metrics call
+ void fold(Cursor & cur);
+ /// unfold the macro in the next metrics call
+ 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,
+ };
+
///
- void updateExpansion() const;
+ DisplayMode displayMode() const { return displayMode_; }
+
///
- void expand() const;
+ bool extraBraces() const { return displayMode_ == DISPLAY_NORMAL && arity() > 0; }
+ ///
+ docstring name() const;
+ ///
+ bool validName() const;
+ ///
+ size_t arity() const {
+ if (displayMode_ == DISPLAY_NORMAL )
+ return cells_.size();
+ else
+ return 0;
+ }
+
+ ///
+ size_t optionals() const { return optionals_; }
+ ///
+ void setOptionals(int n) {
+ if (n <= int(nargs()))
+ optionals_ = n;
+ }
+
+protected:
+ friend class MathData;
+ friend class ArgumentProxy;
+ friend class Cursor;
+
+ /// update the display mode (should only be called after detaching arguments)
+ void setDisplayMode(DisplayMode mode);
+ /// compute the next display mode
+ DisplayMode computeDisplayMode() const;
+ /// update macro definition
+ void updateMacro(MacroContext const & mc);
+ /// check if macro definition changed, argument changed etc. and adapt
+ void updateRepresentation(Cursor const * bvCur);
+ /// empty macro, put arguments into args, possibly strip arity-attachedArgsNum_ empty ones.
+ /// Includes the optional arguments.
+ void detachArguments(std::vector<MathData> & args, bool strip);
+ /// attach arguments (maybe less than arity at the end of an MathData),
+ /// 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_; }
+ ///
+ bool editMetrics(BufferView const * bv) const;
+
+private:
+ ///
+ virtual Inset * clone() const;
+ ///
+ bool editMode(BufferView const * bv) const;
+
/// name of macro
docstring name_;
- /// the unexpanded macro defintition
- mutable MathArray tmpl_;
- /// the macro substituted with our args
- mutable MathArray expanded_;
+ /// current display mode
+ DisplayMode displayMode_;
+ /// display mode before change
+ InsetMathSqrt expanded_;
+ /// 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_;
};
-
-
-
} // namespace lyx
#endif