X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathMacro.h;h=b389e272e4b2f3aa4ff3bad1799c19876f4d03ef;hb=61448d8cb2e922a9a891817a114c76c687be4811;hp=050abe1849d4b2d3e432df0527c95fad91d0c08e;hpb=565475a43917af9c52a3d9d8272e020160d0b971;p=lyx.git diff --git a/src/mathed/MathMacro.h b/src/mathed/MathMacro.h index 050abe1849..b389e272e4 100644 --- a/src/mathed/MathMacro.h +++ b/src/mathed/MathMacro.h @@ -5,7 +5,7 @@ * Licence details can be found in the file COPYING. * * \author Alejandro Aguilar Sierra - * \author André Pönitz + * \author André Pönitz * * Full author contact details are available in file CREDITS. */ @@ -14,18 +14,24 @@ #define MATH_MACRO_H #include "InsetMathNest.h" -#include "InsetMathSqrt.h" #include "MacroTable.h" #include "MathData.h" -namespace lyx { +#include +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); + MathMacro(Buffer * buf, docstring const & name); + /// + MathMacro(MathMacro const &); + /// + MathMacro & operator=(MathMacro const &); + /// + ~MathMacro(); /// virtual MathMacro * asMacro() { return this; } /// @@ -40,23 +46,23 @@ public: /// void metrics(MetricsInfo & mi, Dimension & dim) const; /// - int kerning() 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; /// - void edit(Cursor & cur, bool left); + void edit(Cursor & cur, bool front, EntryDirection entry_from); /// Inset * editXY(Cursor & cur, int x, int y); - /// target pos when we enter the inset from the left by pressing "Right" + /// target pos when we enter the inset while moving forward bool idxFirst(Cursor &) const; - /// target pos when we enter the inset from the right by pressing "Left" + /// target pos when we enter the inset while moving backwards bool idxLast(Cursor &) const; /// - virtual bool notifyCursorLeaves(Cursor &); - + virtual bool notifyCursorLeaves(Cursor const & old, Cursor & cur); + /// Remove cell (starting from 0) void removeArgument(pos_type pos); /// Insert empty cell (starting from 0) @@ -68,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; @@ -84,54 +98,51 @@ public: void unfold(Cursor & cur); /// will it be folded or unfolded in the next metric call? bool folded() const; - + enum DisplayMode { DISPLAY_INIT, - DISPLAY_NONGREEDY_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 optionals() const { return optionals_; } - /// - void setOptionals(int n) { - if (n <= int(nargs())) - optionals_ = n; - } - + size_t arity() const; + + /// + size_t optionals() const; + /// + void setOptionals(int n); + /// Return the maximal number of arguments the macro is greedy for. + size_t appetite() const; + /// + InsetCode lyxCode() const { return MATH_MACRO_CODE; } + 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); + void setDisplayMode(DisplayMode mode, int appetite = -1); /// compute the next display mode - DisplayMode computeDisplayMode(MetricsInfo const & mi) const; + DisplayMode computeDisplayMode() const; /// update macro definition - void updateMacro(MetricsInfo & mi); + void updateMacro(MacroContext const & mc); /// check if macro definition changed, argument changed etc. and adapt - void updateRepresentation(MetricsInfo & mi); + 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 & args, bool strip); @@ -139,44 +150,41 @@ protected: /// including the optional ones (even if it can be empty here) void attachArguments(std::vector const & args, size_t arity, int optionals); /// - bool editing() { return editing_; } + MacroData const * macro(); /// - MacroData const * macro() { return macro_; } + bool editMetrics(BufferView const * bv) const; private: /// virtual Inset * clone() const; - /// the index of the cursor slice of the macro, or -1 if it is not edited - int cursorIdx(Cursor const & cur) const; - /// - bool editMode(Cursor const & cur) const; - - /// name of macro - docstring name_; - /// current display mode - DisplayMode displayMode_; - /// display mode before change - InsetMathSqrt expanded_; - /// number of arguments that were really attached - size_t attachedArgsNum_; - /// cursor position during last draw - idx_type previousCurIdx_; - /// 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_; - /// - bool editing_; - /// - std::string requires_; - /// update macro representation - bool needsUpdate_; + /// + bool editMode(BufferView const * bv) const; + + /// + class Private; + /// + Private * d; + /// update lock to avoid loops + class UpdateLocker; + friend class UpdateLocker; + +public: + /// + bool completionSupported(Cursor const &) const; + /// + bool inlineCompletionSupported(Cursor const & cur) const; + /// + bool automaticInlineCompletion() const; + /// + bool automaticPopupCompletion() const; + /// + CompletionList const * createCompletionList(Cursor const & cur) const; + /// + docstring completionPrefix(Cursor const & cur) const; + /// + bool insertCompletion(Cursor & cur, docstring const & s, bool finished); + /// + void completionPosAndDim(Cursor const &, int & x, int & y, Dimension & dim) const; }; } // namespace lyx