src/mathed/math_mathmlstream.C

   1 #include <config.h>
   2
   3 #include "math_mathmlstream.h"
   4 #include "math_inset.h"
   5 #include "math_extern.h"
   6 #include "support/lyxalgo.h"
   7 #include "support/LOstream.h"
   8
   9
  10 using std::ostream;
  11 using std::strlen;
  12
  13
  14 MathMLStream::MathMLStream(ostream & os)
  15         : os_(os), tab_(0), line_(0), lastchar_(0)
  16 {}
  17
  18
  19 MathMLStream & operator<<(MathMLStream & ms, MathAtom const & at)
  20 {
  21         at->mathmlize(ms);
  22         return ms;
  23 }
  24
  25
  26 MathMLStream & operator<<(MathMLStream & ms, MathArray const & ar)
  27 {
  28         mathmlize(ar, ms);
  29         return ms;
  30 }
  31
  32
  33 MathMLStream & operator<<(MathMLStream & ms, char const * s)
  34 {
  35         ms.os() << s;
  36         return ms;
  37 }
  38
  39
  40 MathMLStream & operator<<(MathMLStream & ms, char c)
  41 {
  42         ms.os() << c;
  43         return ms;
  44 }
  45
  46
  47 MathMLStream & operator<<(MathMLStream & ms, MTag const & t)
  48 {
  49         ++ms.tab();
  50         ms.cr();
  51         ms.os() << '<' << t.tag_ << '>';
  52         return ms;
  53 }
  54
  55
  56 MathMLStream & operator<<(MathMLStream & ms, ETag const & t)
  57 {
  58         ms.cr();
  59         if (ms.tab() > 0)
  60                 --ms.tab();
  61         ms.os() << "</" << t.tag_ << '>';
  62         return ms;
  63 }
  64
  65
  66 void MathMLStream::cr()
  67 {
  68         os() << '\n';
  69         for (int i = 0; i < tab(); ++i)
  70                 os() << ' ';
  71 }
  72
  73
  74
  75 //////////////////////////////////////////////////////////////////////
  76
  77
  78 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
  79 {
  80         at->maplize(ms);
  81         return ms;
  82 }
  83
  84
  85 MapleStream & operator<<(MapleStream & ms, MathArray const & ar)
  86 {
  87         maplize(ar, ms);
  88         return ms;
  89 }
  90
  91
  92 MapleStream & operator<<(MapleStream & ms, char const * s)
  93 {
  94         ms.os() << s;
  95         return ms;
  96 }
  97
  98
  99 MapleStream & operator<<(MapleStream & ms, char c)
 100 {
 101         ms.os() << c;
 102         return ms;
 103 }
 104
 105
 106 MapleStream & operator<<(MapleStream & ms, int i)
 107 {
 108         ms.os() << i;
 109         return ms;
 110 }
 111
 112
 113 //////////////////////////////////////////////////////////////////////
 114
 115
 116 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 117 {
 118         at->mathematicize(ms);
 119         return ms;
 120 }
 121
 122
 123 MathematicaStream & operator<<(MathematicaStream & ms, MathArray const & ar)
 124 {
 125         mathematicize(ar, ms);
 126         return ms;
 127 }
 128
 129
 130 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 131 {
 132         ms.os() << s;
 133         return ms;
 134 }
 135
 136
 137 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 138 {
 139         ms.os() << c;
 140         return ms;
 141 }
 142
 143
 144 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 145 {
 146         ms.os() << i;
 147         return ms;
 148 }
 149
 150
 151
 152 //////////////////////////////////////////////////////////////////////
 153
 154
 155 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 156 {
 157         at->octavize(ns);
 158         return ns;
 159 }
 160
 161
 162 OctaveStream & operator<<(OctaveStream & ns, MathArray const & ar)
 163 {
 164         octavize(ar, ns);
 165         return ns;
 166 }
 167
 168
 169 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 170 {
 171         ns.os() << s;
 172         return ns;
 173 }
 174
 175
 176 OctaveStream & operator<<(OctaveStream & ns, char c)
 177 {
 178         ns.os() << c;
 179         return ns;
 180 }
 181
 182
 183 OctaveStream & operator<<(OctaveStream & ns, int i)
 184 {
 185         ns.os() << i;
 186         return ns;
 187 }
 188
 189
 190 //////////////////////////////////////////////////////////////////////
 191
 192
 193 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
 194 {
 195         at->normalize(ns);
 196         return ns;
 197 }
 198
 199
 200 NormalStream & operator<<(NormalStream & ns, MathArray const & ar)
 201 {
 202         normalize(ar, ns);
 203         return ns;
 204 }
 205
 206
 207 NormalStream & operator<<(NormalStream & ns, char const * s)
 208 {
 209         ns.os() << s;
 210         return ns;
 211 }
 212
 213
 214 NormalStream & operator<<(NormalStream & ns, char c)
 215 {
 216         ns.os() << c;
 217         return ns;
 218 }
 219
 220
 221 NormalStream & operator<<(NormalStream & ns, int i)
 222 {
 223         ns.os() << i;
 224         return ns;
 225 }
 226
 227
 228
 229 //////////////////////////////////////////////////////////////////////
 230
 231
 232 WriteStream::WriteStream(ostream & os, bool fragile, bool latex)
 233         : os_(os), fragile_(fragile), latex_(latex), firstitem_(false), line_(0)
 234 {}
 235
 236
 237 WriteStream::WriteStream(ostream & os)
 238         : os_(os), fragile_(false), latex_(false), firstitem_(false), line_(0)
 239 {}
 240
 241
 242 void WriteStream::addlines(unsigned int n)
 243 {
 244         line_ += n;
 245 }
 246
 247
 248 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
 249 {
 250         at->write(ws);
 251         return ws;
 252 }
 253
 254
 255 WriteStream & operator<<(WriteStream & ws, MathArray const & ar)
 256 {
 257         write(ar, ws);
 258         return ws;
 259 }
 260
 261
 262 WriteStream & operator<<(WriteStream & ws, char const * s)
 263 {
 264         ws.os() << s;
 265         ws.addlines(int(lyx::count(s, s + strlen(s), '\n')));
 266         return ws;
 267 }
 268
 269
 270 WriteStream & operator<<(WriteStream & ws, char c)
 271 {
 272         ws.os() << c;
 273         if (c == '\n')
 274                 ws.addlines(1);
 275         return ws;
 276 }
 277
 278
 279 WriteStream & operator<<(WriteStream & ws, int i)
 280 {
 281         ws.os() << i;
 282         return ws;
 283 }
 284
 285
 286 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 287 {
 288         ws.os() << i;
 289         return ws;
 290 }