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 private:
  58         ///
  59         odocstream & os_;
  60         /// do we have to write \\protect sometimes
  61         bool fragile_;
  62         /// are we at the beginning of an MathData?
  63         bool firstitem_;
  64         /// are we writing to .tex?
  65         int latex_;
  66         /// is it for preview?
  67         bool dryrun_;
  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 &, MathData 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(char const * const tag) : tag_(tag) {}
  99         ///
 100         char const * const tag_;
 101 };
 102
 103 class ETag {
 104 public:
 105         ///
 106         ETag(char const * const tag) : tag_(tag) {}
 107         ///
 108         char const * const tag_;
 109 };
 110
 111 class MathStream {
 112 public:
 113         ///
 114         explicit MathStream(odocstream & os);
 115         ///
 116         void cr();
 117         ///
 118         odocstream & os() { return os_; }
 119         ///
 120         int line() const { return line_; }
 121         ///
 122         int & tab() { return tab_; }
 123         ///
 124         friend MathStream & operator<<(MathStream &, char const *);
 125 private:
 126         ///
 127         odocstream & os_;
 128         ///
 129         int tab_;
 130         ///
 131         int line_;
 132         ///
 133         char lastchar_;
 134 };
 135
 136 ///
 137 MathStream & operator<<(MathStream &, MathAtom const &);
 138 ///
 139 MathStream & operator<<(MathStream &, MathData const &);
 140 ///
 141 MathStream & operator<<(MathStream &, docstring const &);
 142 ///
 143 MathStream & operator<<(MathStream &, char const *);
 144 ///
 145 MathStream & operator<<(MathStream &, char);
 146 ///
 147 MathStream & operator<<(MathStream &, MTag const &);
 148 ///
 149 MathStream & operator<<(MathStream &, ETag const &);
 150
 151
 152
 153 //
 154 // Debugging
 155 //
 156
 157 class NormalStream {
 158 public:
 159         ///
 160         explicit NormalStream(odocstream & os) : os_(os) {}
 161         ///
 162         odocstream & os() { return os_; }
 163 private:
 164         ///
 165         odocstream & os_;
 166 };
 167
 168 ///
 169 NormalStream & operator<<(NormalStream &, MathAtom const &);
 170 ///
 171 NormalStream & operator<<(NormalStream &, MathData const &);
 172 ///
 173 NormalStream & operator<<(NormalStream &, docstring const &);
 174 ///
 175 NormalStream & operator<<(NormalStream &, char const *);
 176 ///
 177 NormalStream & operator<<(NormalStream &, char);
 178 ///
 179 NormalStream & operator<<(NormalStream &, int);
 180
 181
 182 //
 183 // Maple
 184 //
 185
 186
 187 class MapleStream {
 188 public:
 189         ///
 190         explicit MapleStream(odocstream & os) : os_(os) {}
 191         ///
 192         odocstream & os() { return os_; }
 193 private:
 194         ///
 195         odocstream & os_;
 196 };
 197
 198
 199 ///
 200 MapleStream & operator<<(MapleStream &, MathAtom const &);
 201 ///
 202 MapleStream & operator<<(MapleStream &, MathData const &);
 203 ///
 204 MapleStream & operator<<(MapleStream &, docstring const &);
 205 ///
 206 MapleStream & operator<<(MapleStream &, char_type);
 207 ///
 208 MapleStream & operator<<(MapleStream &, char const *);
 209 ///
 210 MapleStream & operator<<(MapleStream &, char);
 211 ///
 212 MapleStream & operator<<(MapleStream &, int);
 213
 214
 215 //
 216 // Maxima
 217 //
 218
 219
 220 class MaximaStream {
 221 public:
 222         ///
 223         explicit MaximaStream(odocstream & os) : os_(os) {}
 224         ///
 225         odocstream & os() { return os_; }
 226 private:
 227         ///
 228         odocstream & os_;
 229 };
 230
 231
 232 ///
 233 MaximaStream & operator<<(MaximaStream &, MathAtom const &);
 234 ///
 235 MaximaStream & operator<<(MaximaStream &, MathData const &);
 236 ///
 237 MaximaStream & operator<<(MaximaStream &, docstring const &);
 238 ///
 239 MaximaStream & operator<<(MaximaStream &, char_type);
 240 ///
 241 MaximaStream & operator<<(MaximaStream &, char const *);
 242 ///
 243 MaximaStream & operator<<(MaximaStream &, char);
 244 ///
 245 MaximaStream & operator<<(MaximaStream &, int);
 246
 247
 248 //
 249 // Mathematica
 250 //
 251
 252
 253 class MathematicaStream {
 254 public:
 255         ///
 256         explicit MathematicaStream(odocstream & os) : os_(os) {}
 257         ///
 258         odocstream & os() { return os_; }
 259 private:
 260         ///
 261         odocstream & os_;
 262 };
 263
 264
 265 ///
 266 MathematicaStream & operator<<(MathematicaStream &, MathAtom const &);
 267 ///
 268 MathematicaStream & operator<<(MathematicaStream &, MathData const &);
 269 ///
 270 MathematicaStream & operator<<(MathematicaStream &, docstring const &);
 271 ///
 272 MathematicaStream & operator<<(MathematicaStream &, char const *);
 273 ///
 274 MathematicaStream & operator<<(MathematicaStream &, char);
 275 ///
 276 MathematicaStream & operator<<(MathematicaStream &, int);
 277
 278
 279 //
 280 // Octave
 281 //
 282
 283
 284 class OctaveStream {
 285 public:
 286         ///
 287         explicit OctaveStream(odocstream & os) : os_(os) {}
 288         ///
 289         odocstream & os() { return os_; }
 290 private:
 291         ///
 292         odocstream & os_;
 293 };
 294
 295 ///
 296 OctaveStream & operator<<(OctaveStream &, MathAtom const &);
 297 ///
 298 OctaveStream & operator<<(OctaveStream &, MathData const &);
 299 ///
 300 OctaveStream & operator<<(OctaveStream &, docstring const &);
 301 ///
 302 OctaveStream & operator<<(OctaveStream &, char_type);
 303 ///
 304 OctaveStream & operator<<(OctaveStream &, char const *);
 305 ///
 306 OctaveStream & operator<<(OctaveStream &, char);
 307 ///
 308 OctaveStream & operator<<(OctaveStream &, int);
 309
 310 } // namespace lyx
 311
 312 #endif