src/mathed/MathStream.h

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