X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathStream.h;h=ad1baada353dcd214b682442db7def4527a3a0d2;hb=efaae780dbbe3685e26e040ed4255e5abf268106;hp=2262ad9df88bc3c71b94270c6ddad38f168795dd;hpb=00e305c9d9bd8b0ff54b6c58adb6192d5934ed60;p=lyx.git diff --git a/src/mathed/MathStream.h b/src/mathed/MathStream.h index 2262ad9df8..ad1baada35 100644 --- a/src/mathed/MathStream.h +++ b/src/mathed/MathStream.h @@ -4,7 +4,7 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author André Pönitz + * \author André Pönitz * * Full author contact details are available in file CREDITS. */ @@ -12,21 +12,19 @@ #ifndef MATH_MATHMLSTREAM_H #define MATH_MATHMLSTREAM_H +#include "support/strfwd.h" -// Please keep all four streams in one file until the interface has -// settled. - - +#include "InsetMath.h" +// FIXME: Move to individual insets #include "MetricsInfo.h" -#include "support/docstream.h" -#include "support/docstring.h" namespace lyx { -class MathArray; +class Encoding; class InsetMath; class MathAtom; +class MathData; // // LaTeX/LyX @@ -35,7 +33,14 @@ class MathAtom; class WriteStream { public: /// - WriteStream(odocstream & os, bool fragile, bool latex); + enum OutputType { + wsDefault, + wsDryrun, + wsPreview + }; + /// + WriteStream(odocstream & os, bool fragile, bool latex, OutputType output, + Encoding const * encoding = 0); /// explicit WriteStream(odocstream & os); /// @@ -47,34 +52,72 @@ public: /// bool latex() const { return latex_; } /// + OutputType output() const { return output_; } + /// odocstream & os() { return os_; } /// 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() bool pendingSpace() const { return pendingspace_; } + /// tell whether to write the closing brace of \ensuremath + void pendingBrace(bool brace); + /// tell whether to write the closing brace of \ensuremath + bool pendingBrace() const { return pendingbrace_; } + /// tell whether we are in text mode or not when producing latex code + void textMode(bool textmode); + /// tell whether we are in text mode or not when producing latex code + bool textMode() const { return textmode_; } + /// tell whether we are allowed to switch mode when producing latex code + 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_; } private: /// odocstream & os_; /// do we have to write \\protect sometimes bool fragile_; - /// are we at the beginning of an MathArray? + /// are we at the beginning of an MathData? bool firstitem_; /// are we writing to .tex? int latex_; + /// output type (default, source preview, instant preview)? + OutputType output_; /// do we have a space pending? bool pendingspace_; + /// do we have a brace pending? + bool pendingbrace_; + /// are we in text mode when producing latex code? + 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_; }; /// WriteStream & operator<<(WriteStream &, MathAtom const &); /// -WriteStream & operator<<(WriteStream &, MathArray const &); +WriteStream & operator<<(WriteStream &, MathData const &); /// WriteStream & operator<<(WriteStream &, docstring const &); /// @@ -86,6 +129,119 @@ WriteStream & operator<<(WriteStream &, int); /// WriteStream & operator<<(WriteStream &, unsigned int); +/// ensure math mode, possibly by opening \ensuremath +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, bool ascii); + + +/** + * MathEnsurer - utility class for ensuring math mode + * + * 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. + * + * Example 1: + * + * MathEnsurer ensurer(os); + * + * If not already in math mode, inserts an \ensuremath command followed + * by an open brace. This brace will be automatically closed when exiting + * math mode. Math mode is automatically exited when writing something + * that doesn't explicitly require math mode. + * + * Example 2: + * + * MathEnsurer ensurer(os, false); + * + * Simply suspend writing a closing brace until the end of ensurer's scope. + * + * Example 3: + * + * MathEnsurer ensurer(os, needs_math_mode, true); + * + * 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). + */ +class MathEnsurer +{ +public: + /// + explicit MathEnsurer(WriteStream & os, bool needs_math_mode = true, bool macro = false) + : os_(os), brace_(ensureMath(os, needs_math_mode, macro)) {} + /// + ~MathEnsurer() { os_.pendingBrace(brace_); } +private: + /// + WriteStream & os_; + /// + bool brace_; +}; + + +/** + * ModeSpecifier - utility class for specifying a given mode (math or text) + * + * A local variable of this type can be used to specify that a command or + * environment works in a given mode. For example, \mbox works in text + * mode, but \boxed works in math mode. Note that no mode changing commands + * are needed, but we have to track the current mode, hence this class. + * This is only used when exporting to latex and helps determining whether + * 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: + * + * ModeSpecifier specifier(os, TEXT_MODE); + * + * Sets the current mode to text mode and allows mode switching. + * + * Example 2: + * + * ModeSpecifier specifier(os, TEXT_MODE, true); + * + * 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, bool ascii = false) + : os_(os), oldmodes_(ensureMode(os, mode, locked, ascii)) {} + /// + ~ModeSpecifier() + { + os_.textMode(oldmodes_ & 0x01); + os_.lockedMode(oldmodes_ & 0x02); + os_.asciiOnly(oldmodes_ & 0x04); + } +private: + /// + WriteStream & os_; + /// + int oldmodes_; +}; + // @@ -95,23 +251,30 @@ WriteStream & operator<<(WriteStream &, unsigned int); class MTag { public: /// - MTag(docstring const tag) : tag_(tag) {} + MTag(char const * const tag, std::string attr = "") + : tag_(tag), attr_(attr) {} /// - MTag(char const * const tag) : tag_(from_ascii(tag)) {} + char const * const tag_; /// - docstring const tag_; + std::string attr_; }; class ETag { public: /// - ETag(docstring const tag) : tag_(tag) {} - /// - ETag(char const * const tag) : tag_(from_ascii(tag)) {} + ETag(char const * const tag) : tag_(tag) {} /// - docstring const tag_; + 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: /// @@ -126,7 +289,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_; /// @@ -134,13 +307,17 @@ private: /// int line_; /// - char lastchar_; + bool in_text_; + /// + odocstringstream deferred_; + /// + friend class SetMode; }; /// MathStream & operator<<(MathStream &, MathAtom const &); /// -MathStream & operator<<(MathStream &, MathArray const &); +MathStream & operator<<(MathStream &, MathData const &); /// MathStream & operator<<(MathStream &, docstring const &); /// @@ -148,11 +325,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 @@ -172,7 +436,7 @@ private: /// NormalStream & operator<<(NormalStream &, MathAtom const &); /// -NormalStream & operator<<(NormalStream &, MathArray const &); +NormalStream & operator<<(NormalStream &, MathData const &); /// NormalStream & operator<<(NormalStream &, docstring const &); /// @@ -203,7 +467,7 @@ private: /// MapleStream & operator<<(MapleStream &, MathAtom const &); /// -MapleStream & operator<<(MapleStream &, MathArray const &); +MapleStream & operator<<(MapleStream &, MathData const &); /// MapleStream & operator<<(MapleStream &, docstring const &); /// @@ -236,7 +500,7 @@ private: /// MaximaStream & operator<<(MaximaStream &, MathAtom const &); /// -MaximaStream & operator<<(MaximaStream &, MathArray const &); +MaximaStream & operator<<(MaximaStream &, MathData const &); /// MaximaStream & operator<<(MaximaStream &, docstring const &); /// @@ -269,7 +533,7 @@ private: /// MathematicaStream & operator<<(MathematicaStream &, MathAtom const &); /// -MathematicaStream & operator<<(MathematicaStream &, MathArray const &); +MathematicaStream & operator<<(MathematicaStream &, MathData const &); /// MathematicaStream & operator<<(MathematicaStream &, docstring const &); /// @@ -299,7 +563,7 @@ private: /// OctaveStream & operator<<(OctaveStream &, MathAtom const &); /// -OctaveStream & operator<<(OctaveStream &, MathArray const &); +OctaveStream & operator<<(OctaveStream &, MathData const &); /// OctaveStream & operator<<(OctaveStream &, docstring const &); ///