src/mathed/MathMLStream.h

   1 // -*- C++ -*-
   2 /**
   3  * \file MathMLStream.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author André Pönitz
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #ifndef MATH_MATHMLSTREAM_H
  13 #define MATH_MATHMLSTREAM_H
  14
  15
  16 // Please keep all four streams in one file until the interface has
  17 // settled.
  18
  19
  20 #include "metricsinfo.h"
  21 #include "support/docstream.h"
  22
  23 #include "support/docstream.h"
  24
  25
  26 namespace lyx {
  27
  28 class MathArray;
  29 class InsetMath;
  30 class MathAtom;
  31
  32 //
  33 // LaTeX/LyX
  34 //
  35
  36 class WriteStream {
  37 public:
  38         ///
  39         WriteStream(odocstream & os, bool fragile, bool latex);
  40         ///
  41         explicit WriteStream(odocstream & os);
  42         ///
  43         ~WriteStream();
  44         ///
  45         int line() const { return line_; }
  46         ///
  47         bool fragile() const { return fragile_; }
  48         ///
  49         bool latex() const { return latex_; }
  50         ///
  51         odocstream & os() { return os_; }
  52         ///
  53         bool & firstitem() { return firstitem_; }
  54         ///
  55         void addlines(unsigned int);
  56         /// writes space if next thing is isalpha()
  57         void pendingSpace(bool how);
  58         /// writes space if next thing is isalpha()
  59         bool pendingSpace() const { return pendingspace_; }
  60 private:
  61         ///
  62         odocstream & os_;
  63         /// do we have to write \\protect sometimes
  64         bool fragile_;
  65         /// are we at the beginning of an MathArray?
  66         bool firstitem_;
  67         /// are we writing to .tex?
  68         int latex_;
  69         /// do we have a space pending?
  70         bool pendingspace_;
  71         ///
  72         int line_;
  73 };
  74
  75 ///
  76 WriteStream & operator<<(WriteStream &, MathAtom const &);
  77 ///
  78 WriteStream & operator<<(WriteStream &, MathArray const &);
  79 ///
  80 WriteStream & operator<<(WriteStream &, char const *);
  81 ///
  82 WriteStream & operator<<(WriteStream &, char);
  83 ///
  84 WriteStream & operator<<(WriteStream &, int);
  85 ///
  86 WriteStream & operator<<(WriteStream &, unsigned int);
  87
  88
  89
  90 //
  91 //  MathML
  92 //
  93
  94 class MTag {
  95 public:
  96         ///
  97         MTag(char const * const tag) : tag_(tag) {}
  98         ///
  99         char const * const tag_;
 100 };
 101
 102 class ETag {
 103 public:
 104         ///
 105         ETag(char const * const tag) : tag_(tag) {}
 106         ///
 107         char const * const tag_;
 108 };
 109
 110 class MathMLStream {
 111 public:
 112         ///
 113         explicit MathMLStream(odocstream & os);
 114         ///
 115         void cr();
 116         ///
 117         odocstream & os() { return os_; }
 118         ///
 119         int line() const { return line_; }
 120         ///
 121         int & tab() { return tab_; }
 122         ///
 123         friend MathMLStream & operator<<(MathMLStream &, char const *);
 124         ///
 125         friend MathMLStream & operator<<(MathMLStream &, docstring const &);
 126 private:
 127         ///
 128         odocstream & os_;
 129         ///
 130         int tab_;
 131         ///
 132         int line_;
 133         ///
 134         char lastchar_;
 135 };
 136
 137 ///
 138 MathMLStream & operator<<(MathMLStream &, MathAtom const &);
 139 ///
 140 MathMLStream & operator<<(MathMLStream &, MathArray const &);
 141 ///
 142 MathMLStream & operator<<(MathMLStream &, char const *);
 143 ///
 144 MathMLStream & operator<<(MathMLStream &, char);
 145 ///
 146 MathMLStream & operator<<(MathMLStream &, MTag const &);
 147 ///
 148 MathMLStream & operator<<(MathMLStream &, ETag const &);
 149
 150
 151
 152 //
 153 // Debugging
 154 //
 155
 156 class NormalStream {
 157 public:
 158         ///
 159         explicit NormalStream(odocstream & os) : os_(os) {}
 160         ///
 161         odocstream & os() { return os_; }
 162 private:
 163         ///
 164         odocstream & os_;
 165 };
 166
 167 ///
 168 NormalStream & operator<<(NormalStream &, MathAtom const &);
 169 ///
 170 NormalStream & operator<<(NormalStream &, MathArray const &);
 171 ///
 172 NormalStream & operator<<(NormalStream &, char const *);
 173 ///
 174 NormalStream & operator<<(NormalStream &, char);
 175 ///
 176 NormalStream & operator<<(NormalStream &, int);
 177
 178
 179 //
 180 // Maple
 181 //
 182
 183
 184 class MapleStream {
 185 public:
 186         ///
 187         explicit MapleStream(odocstream & os) : os_(os) {}
 188         ///
 189         odocstream & os() { return os_; }
 190 private:
 191         ///
 192         odocstream & os_;
 193 };
 194
 195
 196 ///
 197 MapleStream & operator<<(MapleStream &, MathAtom const &);
 198 ///
 199 MapleStream & operator<<(MapleStream &, MathArray const &);
 200 ///
 201 MapleStream & operator<<(MapleStream &, char const *);
 202 ///
 203 MapleStream & operator<<(MapleStream &, char);
 204 ///
 205 MapleStream & operator<<(MapleStream &, int);
 206
 207
 208 //
 209 // Maxima
 210 //
 211
 212
 213 class MaximaStream {
 214 public:
 215         ///
 216         explicit MaximaStream(odocstream & os) : os_(os) {}
 217         ///
 218         odocstream & os() { return os_; }
 219 private:
 220         ///
 221         odocstream & os_;
 222 };
 223
 224
 225 ///
 226 MaximaStream & operator<<(MaximaStream &, MathAtom const &);
 227 ///
 228 MaximaStream & operator<<(MaximaStream &, MathArray const &);
 229 ///
 230 MaximaStream & operator<<(MaximaStream &, char const *);
 231 ///
 232 MaximaStream & operator<<(MaximaStream &, char);
 233 ///
 234 MaximaStream & operator<<(MaximaStream &, int);
 235
 236
 237 //
 238 // Mathematica
 239 //
 240
 241
 242 class MathematicaStream {
 243 public:
 244         ///
 245         explicit MathematicaStream(odocstream & os) : os_(os) {}
 246         ///
 247         odocstream & os() { return os_; }
 248 private:
 249         ///
 250         odocstream & os_;
 251 };
 252
 253
 254 ///
 255 MathematicaStream & operator<<(MathematicaStream &, MathAtom const &);
 256 ///
 257 MathematicaStream & operator<<(MathematicaStream &, MathArray const &);
 258 ///
 259 MathematicaStream & operator<<(MathematicaStream &, char const *);
 260 ///
 261 MathematicaStream & operator<<(MathematicaStream &, char);
 262 ///
 263 MathematicaStream & operator<<(MathematicaStream &, int);
 264
 265
 266 //
 267 // Octave
 268 //
 269
 270
 271 class OctaveStream {
 272 public:
 273         ///
 274         explicit OctaveStream(odocstream & os) : os_(os) {}
 275         ///
 276         odocstream & os() { return os_; }
 277 private:
 278         ///
 279         odocstream & os_;
 280 };
 281
 282 ///
 283 OctaveStream & operator<<(OctaveStream &, MathAtom const &);
 284 ///
 285 OctaveStream & operator<<(OctaveStream &, MathArray const &);
 286 ///
 287 OctaveStream & operator<<(OctaveStream &, char const *);
 288 ///
 289 OctaveStream & operator<<(OctaveStream &, char);
 290 ///
 291 OctaveStream & operator<<(OctaveStream &, int);
 292
 293
 294
 295
 296 } // namespace lyx
 297
 298 #endif