Fix bug 5802 (http://bugzilla.lyx.org/show_bug.cgi?id=5802)

[lyx.git] / src / mathed / MathStream.h

diff --git a/src/mathed/MathStream.h b/src/mathed/MathStream.h
index 87868890859dd10c06af32203c9ad97bd4a18a71..81449cf76d4dce8e36dfe6cb6c3b8f408c1dff55 100644 (file)
--- 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.
  */
@@ -14,15 +14,17 @@
 
 #include "support/strfwd.h"
 
+#include "InsetMath.h"
 // FIXME: Move to individual insets
 #include "MetricsInfo.h"
 
 
 namespace lyx {
 
-class MathData;
+class Encoding;
 class InsetMath;
 class MathAtom;
+class MathData;
 
 //
 // LaTeX/LyX
@@ -31,7 +33,8 @@ class MathAtom;
 class WriteStream {
 public:
        ///
-       WriteStream(odocstream & os, bool fragile, bool latex, bool dryrun);
+       WriteStream(odocstream & os, bool fragile, bool latex, bool dryrun,
+               Encoding const * encoding = 0);
        ///
        explicit WriteStream(odocstream & os);
        ///
@@ -54,6 +57,16 @@ public:
        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_; }
+       /// LaTeX encoding
+       Encoding const * encoding() const { return encoding_; }
 private:
        ///
        odocstream & os_;
@@ -67,8 +80,14 @@ private:
        bool dryrun_;
        /// 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_;
        ///
        int line_;
+       ///
+       Encoding const * encoding_;
 };
 
 ///
@@ -86,6 +105,94 @@ 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
+bool ensureMode(WriteStream & os, InsetMath::mode_type mode);
+
+
+/**
+ * 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.
+ *
+ * Example:
+ *
+ *      ModeSpecifier specifier(os, TEXT_MODE);
+ *
+ * Sets the current mode to text mode.
+ *
+ * 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)
+               : os_(os), textmode_(ensureMode(os, mode)) {}
+       ///
+       ~ModeSpecifier() { os_.textMode(textmode_); }
+private:
+       ///
+       WriteStream & os_;
+       ///
+       bool textmode_;
+};
+
 
 
 //