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