make \newcommand{\bb}[1]{\mathbf{#1}} work for read/write/display.

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

diff --git a/src/mathed/math_mathmlstream.h b/src/mathed/math_mathmlstream.h
index 10d14301198c875dc9bccbb2ca1c69114e05ad06..4efd2c95e85dfe5621552334cf6ac48c6df6dd32 100644 (file)
--- a/src/mathed/math_mathmlstream.h
+++ b/src/mathed/math_mathmlstream.h
@@ -1,54 +1,196 @@
-#ifndef MATH_MATH_MLSTREAM
-#define MATH_MATH_MLSTREAM
+#ifndef MATH_MATHMLSTREAM_H
+#define MATH_MATHMLSTREAM_H
+
+
+// Please keep all four streams in one file until the interface has
+// settled.
+
 
 #include <iosfwd>
 
+class MathArray;
+class MathInset;
+
 
-struct MathMLStream {
+//
+//  MathML
+//
+
+struct MTag {
        ///
-       explicit MathMLStream(std::ostream & os) : os_(os) {}
+       MTag(char const * const tag) : tag_(tag) {}
        ///
-       std::ostream & os_;
+       char const * const tag_;
+};
+
+struct ETag {
+       ///
+       ETag(char const * const tag) : tag_(tag) {}
+       ///
+       char const * const tag_;
+};
+
+class MathMLStream {
+public:
+       ///
+       explicit MathMLStream(std::ostream & os);
        ///
-       MathMLStream & operator<<(MathInset const *);
+       void cr();
        ///
-       MathMLStream & operator<<(MathArray const &);
+       std::ostream & os() { return os_; }
        ///
-       MathMLStream & operator<<(char const *);
+       int & line() { return line_; }
        ///
-       MathMLStream & operator<<(char);
+       int & tab() { return tab_; }
+private:
+       ///
+       std::ostream & os_;
+       ///
+       int tab_;
+       ///
+       int line_;
+       ///
+       char lastchar_;
 };
 
+///
+MathMLStream & operator<<(MathMLStream &, MathInset const *);
+///
+MathMLStream & operator<<(MathMLStream &, MathArray const &);
+///
+MathMLStream & operator<<(MathMLStream &, char const *);
+///
+MathMLStream & operator<<(MathMLStream &, char);
+///
+MathMLStream & operator<<(MathMLStream &, MTag const &);
+///
+MathMLStream & operator<<(MathMLStream &, ETag const &);
+
+
 
-struct MapleStream {
+//
+// Debugging
+//
+
+class NormalStream {
+public:
        ///
-       explicit MapleStream(std::ostream & os) : os_(os) {}
+       explicit NormalStream(std::ostream & os) : os_(os) {}
        ///
-       std::ostream & os_;
+       std::ostream & os() { return os_; }
+private:
        ///
-       MapleStream & operator<<(MathInset const *);
+       std::ostream & os_;
+};
+
+///
+NormalStream & operator<<(NormalStream &, MathInset const *);
+///
+NormalStream & operator<<(NormalStream &, MathArray const &);
+///
+NormalStream & operator<<(NormalStream &, char const *);
+///
+NormalStream & operator<<(NormalStream &, char);
+
+
+
+
+//
+// Maple
+//
+
+
+class MapleStream {
+public:
        ///
-       MapleStream & operator<<(MathArray const &);
+       explicit MapleStream(std::ostream & os) : os_(os) {}
        ///
-       MapleStream & operator<<(char const *);
+       std::ostream & os() { return os_; }
+private:
        ///
-       MapleStream & operator<<(char);
+       std::ostream & os_;
 };
 
 
-struct OctaveStream {
+///
+MapleStream & operator<<(MapleStream &, MathInset const *);
+///
+MapleStream & operator<<(MapleStream &, MathArray const &);
+///
+MapleStream & operator<<(MapleStream &, char const *);
+///
+MapleStream & operator<<(MapleStream &, char);
+///
+MapleStream & operator<<(MapleStream &, int);
+
+
+//
+// Octave
+//
+
+
+class OctaveStream {
+public:
        ///
        explicit OctaveStream(std::ostream & os) : os_(os) {}
+       ///
+       std::ostream & os() { return os_; }
+private:
        ///
        std::ostream & os_;
+};
+
+///
+OctaveStream & operator<<(OctaveStream &, MathInset const *);
+///
+OctaveStream & operator<<(OctaveStream &, MathArray const &);
+///
+OctaveStream & operator<<(OctaveStream &, char const *);
+///
+OctaveStream & operator<<(OctaveStream &, char);
+
+
+
+//
+// LaTeX/LyX
+//
+
+class WriteStream {
+public:
        ///
-       OctaveStream & operator<<(MathInset const *);
+       WriteStream(std::ostream & os, bool fragile);
        ///
-       OctaveStream & operator<<(MathArray const &);
+       explicit WriteStream(std::ostream & os_);
+       /// yes... the references will be removed some day...
+       int & line() { return line_; }
        ///
-       OctaveStream & operator<<(char const *);
+       bool fragile() const { return fragile_; }
        ///
-       OctaveStream & operator<<(char);
+       std::ostream & os() { return os_; }
+       ///
+       bool & firstitem() { return firstitem_; }
+private:
+       ///
+       std::ostream & os_;
+       ///
+       bool fragile_;
+       /// are we at the beginning of an MathArray?
+       bool firstitem_;
+       ///
+       int line_;
 };
 
+///
+WriteStream & operator<<(WriteStream &, MathInset const *);
+///
+WriteStream & operator<<(WriteStream &, MathArray const &);
+///
+WriteStream & operator<<(WriteStream &, char const *);
+///
+WriteStream & operator<<(WriteStream &, char);
+///
+WriteStream & operator<<(WriteStream &, int);
+///
+WriteStream & operator<<(WriteStream &, unsigned int);
+
 #endif