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