X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FInsetMath.h;h=c872316abfbf5bc38613f991d9c0a562b8f9699b;hb=d9082639080b9de993742bd352f92e5183058cf5;hp=f60602c5fe8fb4dd58d850422a80d34505a82c68;hpb=f1cba8ff64b369792fd49f5ddf90e8126ab476ac;p=lyx.git diff --git a/src/mathed/InsetMath.h b/src/mathed/InsetMath.h index f60602c5fe..c872316abf 100644 --- a/src/mathed/InsetMath.h +++ b/src/mathed/InsetMath.h @@ -13,7 +13,7 @@ #ifndef MATH_INSET_H #define MATH_INSET_H -#include "MathData.h" +#include "MathClass.h" #include "insets/Inset.h" @@ -31,20 +31,42 @@ enum HullType { hullXXAlignAt, hullFlAlign, hullMultline, - hullGather + hullGather, + hullRegexp, + hullUnknown }; HullType hullType(docstring const & name); docstring hullName(HullType type); + +enum Limits { + // what is obtained with \c \\nolimits + NO_LIMITS = -1, + // the default + AUTO_LIMITS = 0, + // what is obtained with \c \\limits + LIMITS = 1 +}; + + +/// The possible marker types for math insets +enum class marker_type : int { + NO_MARKER, + MARKER2, + MARKER, + BOX_MARKER +}; + + /** Abstract base class for all math objects. A math insets is for use of the math editor only, it isn't a general LyX inset. It's used to represent all the math objects. -Math insets do not know there parents, a cursor position or things -like that. The are dumb object that are contained in other math insets +Math insets do not know their parents, a cursor position or things +like that. They are dumb objects that are contained in other math insets (InsetMathNests, in fact) thus forming a tree. The root of this tree is always a InsetMathHull, which provides an interface to the Outer World by inclusion in the "real LyX insets" FormulaInset and FormulaMacroInset. @@ -52,11 +74,15 @@ inclusion in the "real LyX insets" FormulaInset and FormulaMacroInset. */ class OutputParams; +class MetricsInfo; + class InsetMathArray; class InsetMathAMSArray; class InsetMathBrace; class InsetMathChar; +class InsetMathClass; class InsetMathDelim; +class InsetMathFracBase; class InsetMathFrac; class InsetMathFont; class InsetMathGrid; @@ -68,23 +94,23 @@ class InsetMathString; class InsetMathSpace; class InsetMathSpecialChar; class InsetMathSymbol; +class InsetMathSubstack; class InsetMathUnknown; - class InsetMathRef; +class HtmlStream; class NormalStream; class OctaveStream; class MapleStream; class MaximaStream; class MathematicaStream; -class MathStream; -class WriteStream; -class InfoStream; - -class MathMacroTemplate; -class MathMacro; -class MathPosFinder; -class Cursor; +class MathMLStream; +class TeXMathStream; + +class MathData; +class InsetMathMacroTemplate; +class InsetMathMacro; +class MathRow; class TextPainter; class TextMetricsInfo; class ReplaceData; @@ -92,10 +118,22 @@ class ReplaceData; class InsetMath : public Inset { public: + /// + explicit InsetMath(Buffer * buf = 0) : Inset(buf) {} /// identification as math inset - InsetMath * asInsetMath() { return this; } + InsetMath * asInsetMath() override { return this; } + /// identification as math inset + InsetMath const * asInsetMath() const override { return this; } /// this is overridden in math text insets (i.e. mbox) - bool inMathed() const { return true; } + bool inMathed() const override { return true; } + /// + virtual docstring name() const; + + /// this is overridden by specific insets + mode_type currentMode() const override { return MATH_MODE; } + + /// this is overridden by insets with specific edit marker type + virtual marker_type marker(BufferView const *) const; /// the ascent of the inset above the baseline /// compute the size of the object for text based drawing @@ -109,56 +147,77 @@ public: virtual MathData const & cell(idx_type) const; /// identifies certain types of insets - virtual InsetMathAMSArray * asAMSArrayInset() { return 0; } - virtual InsetMathAMSArray const * asAMSArrayInset() const { return 0; } - virtual InsetMathArray * asArrayInset() { return 0; } - virtual InsetMathArray const * asArrayInset() const { return 0; } - virtual InsetMathBrace * asBraceInset() { return 0; } - virtual InsetMathBrace const * asBraceInset() const { return 0; } - virtual InsetMathChar const * asCharInset() const { return 0; } - virtual InsetMathDelim * asDelimInset() { return 0; } - virtual InsetMathDelim const * asDelimInset() const { return 0; } - virtual InsetMathFrac * asFracInset() { return 0; } - virtual InsetMathFrac const * asFracInset() const { return 0; } - virtual InsetMathFont * asFontInset() { return 0; } - virtual InsetMathFont const * asFontInset() const { return 0; } - virtual InsetMathGrid * asGridInset() { return 0; } - virtual InsetMathGrid const * asGridInset() const { return 0; } - virtual InsetMathHull * asHullInset() { return 0; } - virtual InsetMathHull const * asHullInset() const { return 0; } - virtual MathMacro * asMacro() { return 0; } - virtual MathMacro const * asMacro() const { return 0; } - virtual MathMacroTemplate * asMacroTemplate() { return 0; } - virtual MathMacroTemplate const * asMacroTemplate() const { return 0; } - virtual InsetMathMatrix const * asMatrixInset() const { return 0; } - virtual InsetMathNest * asNestInset() { return 0; } - virtual InsetMathNest const * asNestInset() const { return 0; } - virtual InsetMathScript * asScriptInset() { return 0; } - virtual InsetMathScript const * asScriptInset() const { return 0; } - virtual InsetMathSpace * asSpaceInset() { return 0; } - virtual InsetMathSpace const * asSpaceInset() const { return 0; } - virtual InsetMathString * asStringInset() { return 0; } - virtual InsetMathString const * asStringInset() const { return 0; } - virtual InsetMathSymbol const * asSymbolInset() const { return 0; } - virtual InsetMathUnknown * asUnknownInset() { return 0; } - virtual InsetMathUnknown const * asUnknownInset() const { return 0; } - virtual InsetMathRef * asRefInset() { return 0; } - virtual InsetMathSpecialChar const * asSpecialCharInset() const { return 0; } - - /// identifies things that can get scripts - virtual bool isScriptable() const { return false; } - /// is the a relational operator (used for splitting equations) - virtual bool isRelOp() const { return false; } + virtual InsetMathAMSArray * asAMSArrayInset() { return nullptr; } + virtual InsetMathAMSArray const * asAMSArrayInset() const { return nullptr; } + virtual InsetMathArray * asArrayInset() { return nullptr; } + virtual InsetMathArray const * asArrayInset() const { return nullptr; } + virtual InsetMathBrace * asBraceInset() { return nullptr; } + virtual InsetMathBrace const * asBraceInset() const { return nullptr; } + virtual InsetMathChar const * asCharInset() const { return nullptr; } + virtual InsetMathClass const * asClassInset() const { return nullptr; } + virtual InsetMathDelim * asDelimInset() { return nullptr; } + virtual InsetMathDelim const * asDelimInset() const { return nullptr; } + virtual InsetMathFracBase * asFracBaseInset() { return nullptr; } + virtual InsetMathFracBase const * asFracBaseInset() const { return nullptr; } + virtual InsetMathFrac * asFracInset() { return nullptr; } + virtual InsetMathFrac const * asFracInset() const { return nullptr; } + virtual InsetMathFont * asFontInset() { return nullptr; } + virtual InsetMathFont const * asFontInset() const { return nullptr; } + virtual InsetMathGrid * asGridInset() { return nullptr; } + virtual InsetMathGrid const * asGridInset() const { return nullptr; } + virtual InsetMathHull * asHullInset() { return nullptr; } + virtual InsetMathHull const * asHullInset() const { return nullptr; } + virtual InsetMathMacro * asMacro() { return nullptr; } + virtual InsetMathMacro const * asMacro() const { return nullptr; } + virtual InsetMathMacroTemplate * asMacroTemplate() { return nullptr; } + virtual InsetMathMacroTemplate const * asMacroTemplate() const { return nullptr; } + virtual InsetMathMatrix const * asMatrixInset() const { return nullptr; } + virtual InsetMathNest * asNestInset() { return nullptr; } + virtual InsetMathNest const * asNestInset() const { return nullptr; } + virtual InsetMathScript * asScriptInset() { return nullptr; } + virtual InsetMathScript const * asScriptInset() const { return nullptr; } + virtual InsetMathSpace * asSpaceInset() { return nullptr; } + virtual InsetMathSpace const * asSpaceInset() const { return nullptr; } + virtual InsetMathString * asStringInset() { return nullptr; } + virtual InsetMathString const * asStringInset() const { return nullptr; } + virtual InsetMathSubstack * asSubstackInset() { return nullptr; } + virtual InsetMathSubstack const * asSubstackInset() const { return nullptr; } + virtual InsetMathSymbol const * asSymbolInset() const { return nullptr; } + virtual InsetMathUnknown * asUnknownInset() { return nullptr; } + virtual InsetMathUnknown const * asUnknownInset() const { return nullptr; } + virtual InsetMathRef * asRefInset() { return nullptr; } + virtual InsetMathSpecialChar const * asSpecialCharInset() const { return nullptr; } + + /// The class of the math object (used primarily for spacing) + virtual MathClass mathClass() const { return MC_ORD; } + /// Add this inset to a math row. Return true if contents got added + virtual bool addToMathRow(MathRow &, MetricsInfo & mi) const; + /// Hook that is run before metrics computation starts + virtual void beforeMetrics() const {} + /// Hook that is run after metrics computation + virtual void afterMetrics() const {} + /// Hook that is run before actual drawing + virtual void beforeDraw(PainterInfo const &) const {} + /// Hook that is run after drawing + virtual void afterDraw(PainterInfo const &) const {} + /// will this get written as a single block in {..} virtual bool extraBraces() const { return false; } /// return the content as char if the inset is able to do so virtual char_type getChar() const { return 0; } - /// identifies things that can get \limits or \nolimits - virtual bool takesLimits() const { return false; } - /// char char code if possible - virtual void handleFont(docstring const &) {} + /// Whether the inset allows \(no)limits + bool allowsLimitsChange() const { return mathClass() == MC_OP; } + /// The default limits value depending on whether display mode is on + virtual Limits defaultLimits(bool /* display */) const { return NO_LIMITS; } + /// whether the inset has limit-like sub/superscript + virtual Limits limits() const { return AUTO_LIMITS; } + /// sets types of sub/superscripts + virtual void limits(Limits) {} + /// write limits status for LaTeX and LyX code + void writeLimits(TeXMathStream & os) const; + /// replace things by other things virtual void replace(ReplaceData &) {} /// do we contain a given subsequence? @@ -168,8 +227,11 @@ public: /// access to the lock (only nest array have one) virtual void lock(bool) {} - /// write LaTeX and Lyx code - virtual void write(WriteStream & os) const; + // Indicate that we do not want to hide the normal version of + // write(). This is to shut off a clang warning. + using Inset::write; + /// write LaTeX and LyX code + virtual void write(TeXMathStream & os) const; /// write normalized content virtual void normalize(NormalStream &) const; /// write content as something readable by Maple @@ -178,16 +240,21 @@ public: virtual void maxima(MaximaStream &) const; /// write content as something readable by Mathematica virtual void mathematica(MathematicaStream &) const; - /// write content as something resembling MathML - virtual void mathmlize(MathStream &) const; + /// write content as MathML + virtual void mathmlize(MathMLStream &) const; + /// write content as HTML, best we can. + /// the idea for this, and some of the details, come from + /// eLyXer, written by Alex Fernandez. no code is borrowed. rather, + /// we try to mimic how eLyXer outputs some math. + virtual void htmlize(HtmlStream &) const; /// write content as something readable by Octave virtual void octave(OctaveStream &) const; /// plain text output in ucs4 encoding - int plaintext(odocstream &, OutputParams const &) const; + int plaintext(odocstringstream &, OutputParams const &, size_t) const override; /// dump content to stderr for debugging - virtual void dump() const; + void dump() const override; /// LyXInset stuff virtual bool numberedType() const { return false; } @@ -197,10 +264,16 @@ public: virtual void mutate(HullType /*newtype*/) {} /// math stuff usually isn't allowed in text mode - virtual bool allowedIn(mode_type mode) const { return mode == MATH_MODE; } + bool allowedIn(mode_type mode) const override { return mode == MATH_MODE; } - /// superscript kerning + /// Italic correction as described in InsetMathScript.h virtual int kerning(BufferView const *) const { return 0; } + /// + bool isInToc() const override { return true; } + /// + InsetCode lyxCode() const override { return MATH_CODE; } + /// + uid_type id() const { return this; } }; ///