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