X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathStream.h;h=153e7df3c584404a43b68ebae48db36a6ba2edce;hb=d9082639080b9de993742bd352f92e5183058cf5;hp=fe5c259a93786482c7f2c1f13e4868b276976233;hpb=2aa930bbe8f2bf07f665b5cda70842748add271a;p=lyx.git

diff --git a/src/mathed/MathStream.h b/src/mathed/MathStream.h
index fe5c259a93..153e7df3c5 100644
--- a/src/mathed/MathStream.h
+++ b/src/mathed/MathStream.h
@@ -13,26 +13,25 @@
 #define MATH_MATHMLSTREAM_H
 
 #include "InsetMath.h"
+
+#include "TexRow.h"
 #include "texstream.h"
 
 #include "support/Changer.h"
 #include "support/strfwd.h"
-#include "support/unique_ptr.h"
 
 
 namespace lyx {
 
 class Encoding;
-class InsetMath;
 class MathAtom;
 class MathData;
-struct RowEntry;
 
 //
 // LaTeX/LyX
 //
 
-class WriteStream {
+class TeXMathStream {
 public:
 	///
 	enum OutputType {
@@ -41,11 +40,17 @@ public:
 		wsPreview
 	};
 	///
-	explicit WriteStream(otexrowstream & os, bool fragile = false,
-	                     bool latex = false, OutputType output = wsDefault,
-	                     Encoding const * encoding = 0);
+	enum UlemCmdType {
+		NONE,
+		UNDERLINE,
+		STRIKEOUT
+	};
+	///
+	explicit TeXMathStream(otexrowstream & os, bool fragile = false,
+	                       bool latex = false, OutputType output = wsDefault,
+	                       Encoding const * encoding = nullptr);
 	///
-	~WriteStream();
+	~TeXMathStream();
 	///
 	int line() const { return line_; }
 	///
@@ -66,10 +71,22 @@ public:
 	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
@@ -86,11 +103,15 @@ public:
 	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(RowEntry 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();
@@ -98,55 +119,62 @@ private:
 	///
 	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_;
+	bool locked_ = false;
 	/// should we use only ascii chars when producing latex code?
-	bool ascii_;
+	bool ascii_ = false;
 	/// are we allowed to output an immediately following newline?
-	bool canbreakline_;
+	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_;
+	int line_ = 0;
 	///
-	Encoding const * encoding_;
+	Encoding const * encoding_ = nullptr;
 	/// Row entry we are in
-	/// (it is a pointer to allow forward-declaration)
-	unique_ptr<RowEntry> row_entry_;
+	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 correct mode, possibly by opening \ensuremath or \lyxmathsym
-bool ensureMath(WriteStream & os, bool needs_mathmode = true,
+bool ensureMath(TeXMathStream & os, bool needs_mathmode = true,
                 bool macro = false, bool textmode_macro = false);
 
 /// ensure the requested mode, possibly by closing \ensuremath or \lyxmathsym
-int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked, bool ascii);
+int ensureMode(TeXMathStream & os, InsetMath::mode_type mode, bool locked, bool ascii);
 
 
 /**
@@ -154,7 +182,7 @@ 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 MathMacro is always assumed needing a math mode environment, while
+ * 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:
@@ -184,7 +212,7 @@ int ensureMode(WriteStream & os, InsetMath::mode_type mode, bool locked, bool as
  * 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 MathMacro or a macro not tagged as textmode.
+ * 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.
@@ -200,14 +228,14 @@ class MathEnsurer
 {
 public:
 	///
-	explicit MathEnsurer(WriteStream & os, bool needs_mathmode = true,
+	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_;
 };
@@ -252,8 +280,8 @@ class ModeSpecifier
 {
 public:
 	///
-	explicit ModeSpecifier(WriteStream & os, InsetMath::mode_type mode,
-				bool locked = false, bool ascii = false)
+	explicit ModeSpecifier(TeXMathStream & os, InsetMath::mode_type mode,
+	                       bool locked = false, bool ascii = false)
 		: os_(os), oldmodes_(ensureMode(os, mode, locked, ascii)) {}
 	///
 	~ModeSpecifier()
@@ -264,7 +292,7 @@ public:
 	}
 private:
 	///
-	WriteStream & os_;
+	TeXMathStream & os_;
 	///
 	int oldmodes_;
 };
@@ -275,10 +303,12 @@ private:
 //  MathML
 //
 
+
+/// Start tag.
 class MTag {
 public:
 	///
-	MTag(char const * const tag, std::string attr = "") 
+	MTag(char const * const tag, std::string const & attr = std::string())
 		: tag_(tag), attr_(attr) {}
 	///
 	char const * const tag_;
@@ -286,12 +316,27 @@ public:
 	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_;
+};
+
+
+/// Compound tag (no content, directly closed).
+class CTag {
+public:
+	///
+	CTag(char const * const tag, std::string const & attr = "")
+            : tag_(tag), attr_(attr) {}
 	///
 	char const * const tag_;
+    ///
+    std::string attr_;
 };
 
 
@@ -302,10 +347,10 @@ public:
 class MathExportException : public std::exception {};
 
 
-class MathStream {
+class MathMLStream {
 public:
-	///
-	explicit MathStream(odocstream & os);
+	/// 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();
 	///
@@ -315,7 +360,7 @@ public:
 	///
 	int & tab() { return tab_; }
 	///
-	friend MathStream & operator<<(MathStream &, char const *);
+	friend MathMLStream & operator<<(MathMLStream &, char const *);
 	///
 	void defer(docstring const &);
 	///
@@ -324,6 +369,14 @@ public:
 	docstring deferred() const;
 	///
 	bool inText() const { return in_text_; }
+	///
+	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 setTextMode(bool t) { in_text_ = t; }
@@ -338,37 +391,43 @@ private:
 	///
 	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
 class SetMode {
 public:
 	///
-	explicit SetMode(MathStream & os, bool text);
+	explicit SetMode(MathMLStream & ms, bool text);
 	///
 	~SetMode();
 private:
 	///
-	MathStream & os_;
+	MathMLStream & ms_;
 	///
 	bool was_text_;
 };
@@ -603,7 +662,7 @@ OctaveStream & operator<<(OctaveStream &, char);
 OctaveStream & operator<<(OctaveStream &, int);
 
 
-docstring convertDelimToXMLEscape(docstring const & name);
+docstring convertDelimToXMLEscape(docstring const & name, bool xmlmode);
 
 } // namespace lyx