X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathStream.h;h=b7e79434af1c02bea66f460abc4b39e215fe7648;hb=999831043e6da50b3095a2dfec7000d4209e586c;hp=6fb8f8265fe18b3b45d8458edfa096876fa19871;hpb=d652a84f4b10251af9e9d216e5642506047cdb29;p=lyx.git
diff --git a/src/mathed/MathStream.h b/src/mathed/MathStream.h
index 6fb8f8265f..b7e79434af 100644
--- a/src/mathed/MathStream.h
+++ b/src/mathed/MathStream.h
@@ -12,11 +12,14 @@
#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"
+#include "support/unique_ptr.h"
namespace lyx {
@@ -39,10 +42,15 @@ 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 WriteStream(otexrowstream & os, bool fragile = false,
+ bool latex = false, OutputType output = wsDefault,
+ Encoding const * encoding = 0);
///
~WriteStream();
///
@@ -54,11 +62,25 @@ 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);
/// writes space if next thing is isalpha()
@@ -81,9 +103,15 @@ public:
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(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_;
/// are we at the beginning of an MathData?
@@ -102,10 +130,18 @@ private:
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_;
+ /// should we take care for striking out display math?
+ bool mathsout_;
+ /// what ulem command are we inside (none, underline, strikeout)?
+ UlemCmdType ulemcmd_;
///
int line_;
///
Encoding const * encoding_;
+ /// Row entry we are in
+ TexRow::RowEntry row_entry_;
};
///
@@ -123,10 +159,11 @@ 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 correct mode, possibly by opening \ensuremath or \lyxmathsym
+bool ensureMath(WriteStream & os, bool needs_mathmode = true,
+ bool macro = false, bool textmode_macro = false);
-/// ensure the requested mode, possibly by closing \ensuremath
+/// ensure the requested mode, possibly by closing \ensuremath or \lyxmathsym
int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked, bool ascii);
@@ -135,6 +172,8 @@ int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked, bool as
*
* 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:
*
@@ -153,23 +192,35 @@ int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked, bool as
*
* Example 3:
*
- * MathEnsurer ensurer(os, needs_math_mode, true);
+ * MathEnsurer ensurer(os, needs_mathmode, true, textmode_macro);
*
- * 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).
+ * 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.
+ *
+ * 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(WriteStream & 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:
@@ -245,7 +296,7 @@ private:
class MTag {
public:
///
- MTag(char const * const tag, std::string attr = "")
+ MTag(char const * const tag, std::string attr = "")
: tag_(tag), attr_(attr) {}
///
char const * const tag_;
@@ -262,6 +313,13 @@ public:
};
+/// 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:
///
@@ -286,9 +344,7 @@ public:
bool inText() const { return in_text_; }
private:
///
- void setTextMode() { in_text_ = true; }
- ///
- void setMathMode() { in_text_ = false; }
+ void setTextMode(bool t) { in_text_ = t; }
///
odocstream & os_;
///
@@ -296,8 +352,6 @@ private:
///
int line_;
///
- char lastchar_;
- ///
bool in_text_;
///
odocstringstream deferred_;
@@ -324,29 +378,86 @@ MathStream & operator<<(MathStream &, ETag const &);
/// A simpler version of ModeSpecifier, for MathML
-// FIXME There are still problems here with nesting, at least
-// potentially. The problem is that true nesting of text mode isn't
-// actually possible. I.e., we can't have:
-//
-// So we have to have:
-//
-// instead, where the last is really a continuation of the first.
-// We'll need some kind of stack to remember all that.
class SetMode {
public:
- ///
- explicit SetMode(MathStream & os, bool text, docstring attrs);
///
explicit SetMode(MathStream & os, bool text);
///
~SetMode();
private:
- ///
- void init(bool, docstring);
///
MathStream & os_;
///
- bool opened_;
+ 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_;
};
@@ -509,6 +620,9 @@ OctaveStream & operator<<(OctaveStream &, char);
///
OctaveStream & operator<<(OctaveStream &, int);
+
+docstring convertDelimToXMLEscape(docstring const & name);
+
} // namespace lyx
#endif