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