X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathMacro.h;h=6e795237e197d2b50480c9b69d6f0e19cde108f0;hb=5fdc577badb1cb133d6a0dc7d831bb1f82576adb;hp=72453cd8eb3bd7c4ae10093ab20e9c6f38125642;hpb=42123ab8a71080b6d15fca4e0c43ae76abf00a1e;p=lyx.git diff --git a/src/mathed/MathMacro.h b/src/mathed/MathMacro.h index 72453cd8eb..6e795237e1 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,77 +14,198 @@ #define MATH_MACRO_H #include "InsetMathNest.h" -#include "MathArray.h" -#include "InsetMathNest.h" -#include "MathMacroTable.h" +#include "MacroTable.h" +#include "MathData.h" +#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, int numargs); + MathMacro(Buffer * buf, docstring const & name); /// - void draw(PainterInfo & pi, int x, int y) const; + MathMacro(MathMacro const &); + /// + MathMacro & operator=(MathMacro const &); + /// + ~MathMacro(); + /// + virtual MathMacro * asMacro() { return this; } + /// + virtual MathMacro const * asMacro() const { return this; } /// - void drawExpanded(PainterInfo & pi, int x, int y) const; + /// If the macro is in normal edit mode, dissolve its contents in + /// the row. Otherwise, just insert the inset. + bool addToMathRow(MathRow &, MetricsInfo & mi) 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; + /// was the macro in edit mode when computing metrics? + bool editMetrics(BufferView const * bv) 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(Cursor & cur, int x, int y); - /// target pos when we enter the inset from the left by pressing "Right" + void edit(Cursor & cur, bool front, EntryDirection entry_from); + /// + 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 from the right by pressing "Left" + /// target pos when we enter the inset while moving backwards bool idxLast(Cursor &) const; + /// - virtual bool notifyCursorLeaves(Cursor &); - /// - docstring name() const; - /// - void setExpansion(MathArray const & exp, MathArray const & args) const; + virtual bool notifyCursorLeaves(Cursor const & old, Cursor & cur); + + /// 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; + /// + mode_type currentMode() const; + /// + 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; /// void infoize2(odocstream &) const; -private: - virtual std::auto_ptr 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 + }; + + /// + DisplayMode displayMode() const; + + /// + bool extraBraces() const; + /// - void updateExpansion() const; + docstring name() const; + /// FIXME: Often dangling. + MacroData const * macro() const; /// - void expand() const; + docstring macroName() const; + /// Level of nesting in macros (including this one) + int nesting() const; + /// + bool validName() const; + /// + size_t arity() const; - /// name of macro - docstring name_; - /// the unexpanded macro defintition - mutable MathArray tmpl_; - /// the macro substituted with our args - mutable MathArray expanded_; -}; + /// + 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; } + /// This is not used for display; however whether it is mathrel determines + /// how to split equations intelligently. + MathClass mathClass() const; //override + +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, int appetite = -1); + /// 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 * cur, MacroContext const & mc, + UpdateType, int nesting); + /// empty macro, put arguments into args, possibly strip arity-attachedArgsNum_ empty ones. + /// Includes the optional arguments. + void detachArguments(std::vector & 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 const & args, size_t arity, int optionals); +private: + /// Math mode for output and display. UNDECIDED for user macros: they could + /// be either. + mode_type modeToEnsure() const; + /// This function is needed for now because of two shortfalls of the current + /// implementation: the macro() pointer is often dangling, in which case we + /// fall back to a backup copy, and the macro is not known at inset + /// creation, in which case we fall back to the global macro with this name. + MacroData const * macroBackup() const; + /// + virtual Inset * clone() const; + /// + 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 #endif