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