X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathStream.h;h=28eda3ff25abc91a2e66573ce0a894eb2d7d2885;hb=c6ce76c2;hp=a973975107dd0be2efbe19f6ed59e249f16af269;hpb=0a90c42b866d17ba0c5818be363f320b894b1d7b;p=lyx.git diff --git a/src/mathed/MathStream.h b/src/mathed/MathStream.h index a973975107..28eda3ff25 100644 --- a/src/mathed/MathStream.h +++ b/src/mathed/MathStream.h @@ -12,11 +12,13 @@ #ifndef MATH_MATHMLSTREAM_H #define MATH_MATHMLSTREAM_H -#include "support/strfwd.h" - #include "InsetMath.h" -// FIXME: Move to individual insets -#include "MetricsInfo.h" +#include "texstream.h" +#include "TexRow.h" + +#include "support/Changer.h" +#include "support/strfwd.h" +#include "support/unique_ptr.h" namespace lyx { @@ -33,10 +35,15 @@ class MathData; class WriteStream { public: /// - WriteStream(odocstream & os, bool fragile, bool latex, bool dryrun, - Encoding const * encoding = 0); + enum OutputType { + wsDefault, + wsDryrun, + wsPreview + }; /// - explicit WriteStream(odocstream & os); + explicit WriteStream(otexrowstream & os, bool fragile = false, + bool latex = false, OutputType output = wsDefault, + Encoding const * encoding = 0); /// ~WriteStream(); /// @@ -46,13 +53,19 @@ public: /// bool latex() const { return latex_; } /// - bool dryrun() const { return dryrun_; } + 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_; } /// writes space if next thing is isalpha() void pendingSpace(bool how); /// writes space if next thing is isalpha() @@ -69,19 +82,29 @@ 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_; } /// LaTeX encoding Encoding const * encoding() const { return encoding_; } + + /// Temporarily change the TexRow information about the outer row entry. + Changer changeRowEntry(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_; /// are we at the beginning of an MathData? bool firstitem_; /// are we writing to .tex? int latex_; - /// is it for preview? - bool dryrun_; + /// output type (default, source preview, instant preview)? + OutputType output_; /// do we have a space pending? bool pendingspace_; /// do we have a brace pending? @@ -90,10 +113,17 @@ private: bool textmode_; /// are we allowed to switch mode when producing latex code? bool locked_; + /// should we use only ascii chars when producing latex code? + bool ascii_; + /// are we allowed to output an immediately following newline? + bool canbreakline_; /// int line_; /// Encoding const * encoding_; + /// Row entry we are in + /// (it is a pointer to allow forward-declaration) + unique_ptr row_entry_; }; /// @@ -115,7 +145,7 @@ WriteStream & operator<<(WriteStream &, unsigned int); bool ensureMath(WriteStream & os, bool needs_math_mode = true, bool macro = false); /// ensure the requested mode, possibly by closing \ensuremath -int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked); +int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked, bool ascii); /** @@ -179,6 +209,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: * @@ -192,6 +224,13 @@ 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 @@ -199,13 +238,14 @@ class ModeSpecifier public: /// explicit ModeSpecifier(WriteStream & os, InsetMath::mode_type mode, - bool locked = false) - : os_(os), oldmodes_(ensureMode(os, mode, locked)) {} + 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: /// @@ -223,9 +263,12 @@ private: class MTag { public: /// - MTag(char const * const tag) : tag_(tag) {} + MTag(char const * const tag, std::string attr = "") + : tag_(tag), attr_(attr) {} /// char const * const tag_; + /// + std::string attr_; }; class ETag { @@ -236,6 +279,14 @@ public: char const * const tag_; }; + +/// 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 MathStream { public: /// @@ -250,7 +301,17 @@ public: int & tab() { return tab_; } /// friend MathStream & operator<<(MathStream &, 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_; /// @@ -258,7 +319,11 @@ private: /// int line_; /// - char lastchar_; + bool in_text_; + /// + odocstringstream deferred_; + /// + friend class SetMode; }; /// @@ -272,11 +337,98 @@ MathStream & operator<<(MathStream &, char const *); /// MathStream & operator<<(MathStream &, char); /// +MathStream & operator<<(MathStream &, char_type); +/// MathStream & operator<<(MathStream &, MTag const &); /// MathStream & operator<<(MathStream &, ETag const &); +/// A simpler version of ModeSpecifier, for MathML +class SetMode { +public: + /// + explicit SetMode(MathStream & os, bool text); + /// + ~SetMode(); +private: + /// + MathStream & os_; + /// + bool was_text_; +}; + + +class HtmlStream { +public: + /// + explicit HtmlStream(odocstream & 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_; +}; + // // Debugging @@ -435,6 +587,9 @@ OctaveStream & operator<<(OctaveStream &, char); /// OctaveStream & operator<<(OctaveStream &, int); + +docstring convertDelimToXMLEscape(docstring const & name); + } // namespace lyx #endif