X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathStream.h;h=153e7df3c584404a43b68ebae48db36a6ba2edce;hb=d9082639080b9de993742bd352f92e5183058cf5;hp=51760a33dde485c22fdf4e041d503d77b024c88b;hpb=19cd5f0e824b6ee6d03c6037c3db4527ecc8beeb;p=lyx.git diff --git a/src/mathed/MathStream.h b/src/mathed/MathStream.h index 51760a33dd..153e7df3c5 100644 --- a/src/mathed/MathStream.h +++ b/src/mathed/MathStream.h @@ -12,17 +12,18 @@ #ifndef MATH_MATHMLSTREAM_H #define MATH_MATHMLSTREAM_H -#include "support/strfwd.h" - #include "InsetMath.h" -// FIXME: Move to individual insets -#include "MetricsInfo.h" + +#include "TexRow.h" +#include "texstream.h" + +#include "support/Changer.h" +#include "support/strfwd.h" namespace lyx { class Encoding; -class InsetMath; class MathAtom; class MathData; @@ -30,7 +31,7 @@ class MathData; // LaTeX/LyX // -class WriteStream { +class TeXMathStream { public: /// enum OutputType { @@ -39,12 +40,17 @@ public: wsPreview }; /// - WriteStream(odocstream & os, bool fragile, bool latex, OutputType output, - Encoding const * encoding = 0); + enum UlemCmdType { + NONE, + UNDERLINE, + STRIKEOUT + }; /// - explicit WriteStream(odocstream & os); + explicit TeXMathStream(otexrowstream & os, bool fragile = false, + bool latex = false, OutputType output = wsDefault, + Encoding const * encoding = nullptr); /// - ~WriteStream(); + ~TeXMathStream(); /// int line() const { return line_; } /// @@ -54,15 +60,33 @@ public: /// OutputType output() const { return output_; } /// - odocstream & os() { return os_; } + otexrowstream & os() { return os_; } + /// + TexRow & texrow() { return os_.texrow(); } /// bool & firstitem() { return firstitem_; } /// void addlines(unsigned int); + /// record whether we can write an immediately following newline char + void canBreakLine(bool breakline) { canbreakline_ = breakline; } + /// tell whether we can write an immediately following newline char + bool canBreakLine() const { return canbreakline_; } + /// record whether we have to take care for striking out display math + void strikeoutMath(bool mathsout) { mathsout_ = mathsout; } + /// tell whether we have to take care for striking out display math + bool strikeoutMath() const { return mathsout_; } + /// record which ulem command type we are inside + void ulemCmd(UlemCmdType ulemcmd) { ulemcmd_ = ulemcmd; } + /// tell which ulem command type we are inside + UlemCmdType ulemCmd() const { return ulemcmd_; } /// writes space if next thing is isalpha() - void pendingSpace(bool how); + void pendingSpace(bool space); /// writes space if next thing is isalpha() bool pendingSpace() const { return pendingspace_; } + /// write braces if a space is pending and next char is [ + void useBraces(bool braces); + /// write braces if a space is pending and next char is [ + bool useBraces() const { return usebraces_; } /// tell whether to write the closing brace of \ensuremath void pendingBrace(bool brace); /// tell whether to write the closing brace of \ensuremath @@ -75,53 +99,82 @@ public: void lockedMode(bool locked); /// tell whether we are allowed to switch mode when producing latex code bool lockedMode() const { return locked_; } + /// tell whether to use only ascii chars when producing latex code + void asciiOnly(bool ascii); + /// tell whether to use only ascii chars when producing latex code + bool asciiOnly() const { return ascii_; } + /// tell whether we are in a MathClass inset + void inMathClass(bool mathclass) { mathclass_ = mathclass; }; + /// tell whether we are in a MathClass inset + bool inMathClass() const { return mathclass_; } /// LaTeX encoding Encoding const * encoding() const { return encoding_; } + + /// Temporarily change the TexRow information about the outer row entry. + Changer changeRowEntry(TexRow::RowEntry entry); + /// TexRow::starts the innermost outer math inset + /// returns true if the outer row entry will appear at this line + bool startOuterRow(); private: /// - odocstream & os_; + otexrowstream & os_; /// do we have to write \\protect sometimes - bool fragile_; + bool fragile_ = false; /// are we at the beginning of an MathData? - bool firstitem_; + bool firstitem_ = false; /// are we writing to .tex? - int latex_; + int latex_ = false; /// output type (default, source preview, instant preview)? - OutputType output_; + OutputType output_ = wsDefault; /// do we have a space pending? - bool pendingspace_; + bool pendingspace_ = false; + /// do we have to write braces when a space is pending and [ follows? + bool usebraces_ = false; /// do we have a brace pending? - bool pendingbrace_; + bool pendingbrace_ = false; /// are we in text mode when producing latex code? - bool textmode_; + bool textmode_ = false; /// are we allowed to switch mode when producing latex code? - bool locked_; - /// - int line_; - /// - Encoding const * encoding_; + bool locked_ = false; + /// should we use only ascii chars when producing latex code? + bool ascii_ = false; + /// are we allowed to output an immediately following newline? + bool canbreakline_ = true; + /// should we take care for striking out display math? + bool mathsout_ = false; + /// what ulem command are we inside (none, underline, strikeout)? + UlemCmdType ulemcmd_ = NONE; + /// + int line_ = 0; + /// + Encoding const * encoding_ = nullptr; + /// Row entry we are in + TexRow::RowEntry row_entry_ = TexRow::row_none; + /// whether we are in a MathClass inset + bool mathclass_ = false; }; /// -WriteStream & operator<<(WriteStream &, MathAtom const &); +TeXMathStream & operator<<(TeXMathStream &, MathAtom const &); /// -WriteStream & operator<<(WriteStream &, MathData const &); +TeXMathStream & operator<<(TeXMathStream &, MathData const &); /// -WriteStream & operator<<(WriteStream &, docstring const &); +TeXMathStream & operator<<(TeXMathStream &, docstring const &); /// -WriteStream & operator<<(WriteStream &, char const * const); +TeXMathStream & operator<<(TeXMathStream &, char const * const); /// -WriteStream & operator<<(WriteStream &, char); +TeXMathStream & operator<<(TeXMathStream &, char); /// -WriteStream & operator<<(WriteStream &, int); +TeXMathStream & operator<<(TeXMathStream &, int); /// -WriteStream & operator<<(WriteStream &, unsigned int); +TeXMathStream & operator<<(TeXMathStream &, unsigned int); -/// ensure math mode, possibly by opening \ensuremath -bool ensureMath(WriteStream & os, bool needs_math_mode = true, bool macro = false); +/// ensure correct mode, possibly by opening \ensuremath or \lyxmathsym +bool ensureMath(TeXMathStream & os, bool needs_mathmode = true, + bool macro = false, bool textmode_macro = false); -/// ensure the requested mode, possibly by closing \ensuremath -int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked); +/// ensure the requested mode, possibly by closing \ensuremath or \lyxmathsym +int ensureMode(TeXMathStream & os, InsetMath::mode_type mode, bool locked, bool ascii); /** @@ -129,6 +182,8 @@ int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked); * * A local variable of this type can be used to either ensure math mode * or delay the writing of a pending brace when outputting LaTeX. + * A LyX InsetMathMacro is always assumed needing a math mode environment, while + * no assumption is made for macros defined through \newcommand or \def. * * Example 1: * @@ -147,28 +202,40 @@ int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked); * * Example 3: * - * MathEnsurer ensurer(os, needs_math_mode, true); + * MathEnsurer ensurer(os, needs_mathmode, true, textmode_macro); + * + * This form is mainly used for math macros as they are treated specially. + * In essence, the macros defined in the lib/symbols file and tagged as + * textmode will be enclosed in \lyxmathsym if they appear in a math mode + * environment, while macros defined in the preamble or ERT are left as is. + * The third parameter must be set to true and the fourth parameter has also + * to be specified. Only the following 3 different cases are handled. + * + * When the needs_mathmode parameter is true the behavior is as in Example 1. + * This is the case for a LyX InsetMathMacro or a macro not tagged as textmode. * - * The third parameter is set to true only for a user defined macro, which - * needs special handling. When it is a MathMacro, the needs_math_mode - * parameter is true and the behavior is as in Example 1. When the - * needs_math_mode parameter is false (not a MathMacro) and the macro - * was entered in a text box and we are in math mode, the mode is reset - * to text. This is because the macro was probably designed for text mode - * (given that it was entered in text mode and we have no way to tell the - * contrary). + * When the needs_mathmode and textmode_macro parameters are both false the + * macro is left in the same (text or math mode) environment it was entered. + * This is because it is assumed that the macro was designed for that mode + * and we have no way to tell the contrary. + * This is the case for macros defined by using \newcommand or \def in ERT. + * + * When the needs_mathmode parameter is false while textmode_macro is true the + * macro will be enclosed in \lyxmathsym if it appears in a math mode environment. + * This is the case for the macros tagged as textmode in lib/symbols. */ class MathEnsurer { public: /// - explicit MathEnsurer(WriteStream & os, bool needs_math_mode = true, bool macro = false) - : os_(os), brace_(ensureMath(os, needs_math_mode, macro)) {} + explicit MathEnsurer(TeXMathStream & os, bool needs_mathmode = true, + bool macro = false, bool textmode_macro = false) + : os_(os), brace_(ensureMath(os, needs_mathmode, macro, textmode_macro)) {} /// ~MathEnsurer() { os_.pendingBrace(brace_); } private: /// - WriteStream & os_; + TeXMathStream & os_; /// bool brace_; }; @@ -185,6 +252,8 @@ private: * the mode needs being temporarily switched when a command would not work * in the current mode. As there are cases where this switching is to be * avoided, the optional third parameter can be used to lock the mode. + * When the mode is locked, the optional fourth parameter specifies whether + * strings are to be output by using a suitable ascii representation. * * Example 1: * @@ -198,24 +267,32 @@ private: * * Sets the current mode to text mode and disallows mode switching. * + * Example 3: + * + * ModeSpecifier specifier(os, TEXT_MODE, true, true); + * + * Sets the current mode to text mode, disallows mode switching, and outputs + * strings as ascii only. + * * At the end of specifier's scope the mode is reset to its previous value. */ class ModeSpecifier { public: /// - explicit ModeSpecifier(WriteStream & os, InsetMath::mode_type mode, - bool locked = false) - : os_(os), oldmodes_(ensureMode(os, mode, locked)) {} + explicit ModeSpecifier(TeXMathStream & os, InsetMath::mode_type mode, + bool locked = false, bool ascii = false) + : os_(os), oldmodes_(ensureMode(os, mode, locked, ascii)) {} /// ~ModeSpecifier() { - os_.textMode(oldmodes_ & 1); - os_.lockedMode(oldmodes_ & 2); + os_.textMode(oldmodes_ & 0x01); + os_.lockedMode(oldmodes_ & 0x02); + os_.asciiOnly(oldmodes_ & 0x04); } private: /// - WriteStream & os_; + TeXMathStream & os_; /// int oldmodes_; }; @@ -226,27 +303,54 @@ private: // MathML // + +/// Start tag. class MTag { public: /// - MTag(char const * const tag) : tag_(tag) {} + MTag(char const * const tag, std::string const & attr = std::string()) + : tag_(tag), attr_(attr) {} /// char const * const tag_; + /// + std::string attr_; }; + +/// End tag. class ETag { public: /// - ETag(char const * const tag) : tag_(tag) {} + explicit ETag(char const * const tag) : tag_(tag) {} /// char const * const tag_; }; -class MathStream { +/// Compound tag (no content, directly closed). +class CTag { public: /// - explicit MathStream(odocstream & os); + CTag(char const * const tag, std::string const & attr = "") + : tag_(tag), attr_(attr) {} + /// + char const * const tag_; + /// + std::string attr_; +}; + + +/// Throw MathExportException to signal that the attempt to export +/// some math in the current format did not succeed. E.g., we can't +/// export xymatrix as MathML, so that will throw, and we'll fall back +/// to images. +class MathExportException : public std::exception {}; + + +class MathMLStream { +public: + /// Builds a stream proxy for os; the MathML namespace is given by xmlns (supposed to be already defined elsewhere in the document). + explicit MathMLStream(odocstream & os, std::string const & xmlns = "", bool xmlMode = false); /// void cr(); /// @@ -256,7 +360,7 @@ public: /// int & tab() { return tab_; } /// - friend MathStream & operator<<(MathStream &, char const *); + friend MathMLStream & operator<<(MathMLStream &, char const *); /// void defer(docstring const &); /// @@ -265,11 +369,17 @@ public: docstring deferred() const; /// bool inText() const { return in_text_; } -private: /// - void setTextMode() { in_text_ = true; } + std::string xmlns() const { return xmlns_; } + /// + bool xmlMode() const { return xml_mode_; } + /// Returns the tag name prefixed by the name space if needed. + std::string namespacedTag(std::string const & tag) const { + return (xmlns().empty() ? "" : xmlns() + ":") + tag; + } +private: /// - void setMathMode() { in_text_ = false; } + void setTextMode(bool t) { in_text_ = t; } /// odocstream & os_; /// @@ -277,47 +387,118 @@ private: /// int line_; /// - char lastchar_; - /// bool in_text_; /// odocstringstream deferred_; /// + std::string xmlns_; + /// + bool xml_mode_; + /// friend class SetMode; }; /// -MathStream & operator<<(MathStream &, MathAtom const &); +MathMLStream & operator<<(MathMLStream &, MathAtom const &); +/// +MathMLStream & operator<<(MathMLStream &, MathData const &); /// -MathStream & operator<<(MathStream &, MathData const &); +MathMLStream & operator<<(MathMLStream &, docstring const &); /// -MathStream & operator<<(MathStream &, docstring const &); +MathMLStream & operator<<(MathMLStream &, char const *); /// -MathStream & operator<<(MathStream &, char const *); +MathMLStream & operator<<(MathMLStream &, char); /// -MathStream & operator<<(MathStream &, char); +MathMLStream & operator<<(MathMLStream &, char_type); /// -MathStream & operator<<(MathStream &, char_type); +MathMLStream & operator<<(MathMLStream &, MTag const &); /// -MathStream & operator<<(MathStream &, MTag const &); +MathMLStream & operator<<(MathMLStream &, ETag const &); /// -MathStream & operator<<(MathStream &, ETag const &); +MathMLStream & operator<<(MathMLStream &, CTag const &); -// A simpler version of ModeSpecifier, for MathML +/// A simpler version of ModeSpecifier, for MathML class SetMode { public: /// - explicit SetMode(MathStream & os, bool text, docstring attrs); - /// - explicit SetMode(MathStream & os, bool text); + explicit SetMode(MathMLStream & ms, bool text); /// ~SetMode(); private: /// - void init(bool, docstring); + MathMLStream & ms_; + /// + bool was_text_; +}; + + +class HtmlStream { +public: + /// + explicit HtmlStream(odocstream & os); /// - MathStream & os_; + void cr(); + /// + odocstream & os() { return os_; } + /// + int line() const { return line_; } + /// + int & tab() { return tab_; } + /// + friend HtmlStream & operator<<(HtmlStream &, char const *); + /// + void defer(docstring const &); + /// + void defer(std::string const &); + /// + docstring deferred() const; + /// + bool inText() const { return in_text_; } +private: + /// + void setTextMode(bool t) { in_text_ = t; } + /// + odocstream & os_; + /// + int tab_; + /// + int line_; + /// + bool in_text_; + /// + odocstringstream deferred_; + /// + friend class SetHTMLMode; +}; + +/// +HtmlStream & operator<<(HtmlStream &, MathAtom const &); +/// +HtmlStream & operator<<(HtmlStream &, MathData const &); +/// +HtmlStream & operator<<(HtmlStream &, docstring const &); +/// +HtmlStream & operator<<(HtmlStream &, char const *); +/// +HtmlStream & operator<<(HtmlStream &, char); +/// +HtmlStream & operator<<(HtmlStream &, char_type); +/// +HtmlStream & operator<<(HtmlStream &, MTag const &); +/// +HtmlStream & operator<<(HtmlStream &, ETag const &); + + +class SetHTMLMode { +public: + /// + explicit SetHTMLMode(HtmlStream & os, bool text); + /// + ~SetHTMLMode(); +private: + /// + HtmlStream & os_; /// bool was_text_; }; @@ -480,6 +661,9 @@ OctaveStream & operator<<(OctaveStream &, char); /// OctaveStream & operator<<(OctaveStream &, int); + +docstring convertDelimToXMLEscape(docstring const & name, bool xmlmode); + } // namespace lyx #endif