src/mathed/MathStream.cpp

   1 /**
   2  * \file MathStream.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author André Pönitz
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "InsetMath.h"
  14 #include "MathData.h"
  15 #include "MathExtern.h"
  16 #include "MathStream.h"
  17
  18 #include "support/textutils.h"
  19
  20 #include <algorithm>
  21
  22 namespace lyx {
  23
  24 using std::strlen;
  25
  26
  27 //////////////////////////////////////////////////////////////////////
  28
  29
  30 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
  31 {
  32         at->normalize(ns);
  33         return ns;
  34 }
  35
  36
  37 NormalStream & operator<<(NormalStream & ns, MathData const & ar)
  38 {
  39         normalize(ar, ns);
  40         return ns;
  41 }
  42
  43
  44 NormalStream & operator<<(NormalStream & ns, docstring const & s)
  45 {
  46         ns.os() << s;
  47         return ns;
  48 }
  49
  50
  51 NormalStream & operator<<(NormalStream & ns, const std::string & s)
  52 {
  53         ns.os() << from_utf8(s);
  54         return ns;
  55 }
  56
  57
  58 NormalStream & operator<<(NormalStream & ns, char const * s)
  59 {
  60         ns.os() << s;
  61         return ns;
  62 }
  63
  64
  65 NormalStream & operator<<(NormalStream & ns, char c)
  66 {
  67         ns.os() << c;
  68         return ns;
  69 }
  70
  71
  72 NormalStream & operator<<(NormalStream & ns, int i)
  73 {
  74         ns.os() << i;
  75         return ns;
  76 }
  77
  78
  79
  80 /////////////////////////////////////////////////////////////////
  81
  82
  83 WriteStream & operator<<(WriteStream & ws, docstring const & s)
  84 {
  85         if (ws.pendingSpace() && s.length() > 0) {
  86                 if (isAlphaASCII(s[0]))
  87                         ws.os() << ' ';
  88                 ws.pendingSpace(false);
  89         }
  90         ws.os() << s;
  91         int lf = 0;
  92         docstring::const_iterator dit = s.begin();
  93         docstring::const_iterator end = s.end();
  94         for (; dit != end; ++dit)
  95                 if ((*dit) == '\n')
  96                         ++lf;
  97         ws.addlines(lf);
  98         return ws;
  99 }
 100
 101
 102 WriteStream::WriteStream(odocstream & os, bool fragile, bool latex)
 103         : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
 104           pendingspace_(false), line_(0)
 105 {}
 106
 107
 108 WriteStream::WriteStream(odocstream & os)
 109         : os_(os), fragile_(false), firstitem_(false), latex_(false),
 110           pendingspace_(false), line_(0)
 111 {}
 112
 113
 114 WriteStream::~WriteStream()
 115 {
 116         if (pendingspace_)
 117                 os_ << ' ';
 118 }
 119
 120
 121 void WriteStream::addlines(unsigned int n)
 122 {
 123         line_ += n;
 124 }
 125
 126
 127 void WriteStream::pendingSpace(bool how)
 128 {
 129         pendingspace_ = how;
 130 }
 131
 132
 133 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
 134 {
 135         at->write(ws);
 136         return ws;
 137 }
 138
 139
 140 WriteStream & operator<<(WriteStream & ws, MathData const & ar)
 141 {
 142         write(ar, ws);
 143         return ws;
 144 }
 145
 146
 147 WriteStream & operator<<(WriteStream & ws, char const * s)
 148 {
 149         if (ws.pendingSpace() && strlen(s) > 0) {
 150                 if (isAlphaASCII(s[0]))
 151                         ws.os() << ' ';
 152                 ws.pendingSpace(false);
 153         }
 154         ws.os() << s;
 155         ws.addlines(int(std::count(s, s + strlen(s), '\n')));
 156         return ws;
 157 }
 158
 159
 160 WriteStream & operator<<(WriteStream & ws, char c)
 161 {
 162         if (ws.pendingSpace()) {
 163                 if (isAlphaASCII(c))
 164                         ws.os() << ' ';
 165                 ws.pendingSpace(false);
 166         }
 167         ws.os() << c;
 168         if (c == '\n')
 169                 ws.addlines(1);
 170         return ws;
 171 }
 172
 173
 174 WriteStream & operator<<(WriteStream & ws, int i)
 175 {
 176         ws.os() << i;
 177         return ws;
 178 }
 179
 180
 181 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 182 {
 183         ws.os() << i;
 184         return ws;
 185 }
 186
 187
 188 //////////////////////////////////////////////////////////////////////
 189
 190
 191 MathStream::MathStream(odocstream & os)
 192         : os_(os), tab_(0), line_(0), lastchar_(0)
 193 {}
 194
 195
 196 MathStream & operator<<(MathStream & ms, MathAtom const & at)
 197 {
 198         at->mathmlize(ms);
 199         return ms;
 200 }
 201
 202
 203 MathStream & operator<<(MathStream & ms, MathData const & ar)
 204 {
 205         mathmlize(ar, ms);
 206         return ms;
 207 }
 208
 209
 210 MathStream & operator<<(MathStream & ms, char const * s)
 211 {
 212         ms.os() << s;
 213         return ms;
 214 }
 215
 216
 217 MathStream & operator<<(MathStream & ms, char c)
 218 {
 219         ms.os() << c;
 220         return ms;
 221 }
 222
 223
 224 MathStream & operator<<(MathStream & ms, MTag const & t)
 225 {
 226         ++ms.tab();
 227         ms.cr();
 228         ms.os() << '<' << t.tag_ << '>';
 229         return ms;
 230 }
 231
 232
 233 MathStream & operator<<(MathStream & ms, ETag const & t)
 234 {
 235         ms.cr();
 236         if (ms.tab() > 0)
 237                 --ms.tab();
 238         ms.os() << "</" << t.tag_ << '>';
 239         return ms;
 240 }
 241
 242
 243 void MathStream::cr()
 244 {
 245         os() << '\n';
 246         for (int i = 0; i < tab(); ++i)
 247                 os() << ' ';
 248 }
 249
 250
 251 MathStream & operator<<(MathStream & ms, docstring const & s)
 252 {
 253         ms.os() << s;
 254         return ms;
 255 }
 256
 257 //////////////////////////////////////////////////////////////////////
 258
 259
 260 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 261 {
 262         at->maple(ms);
 263         return ms;
 264 }
 265
 266
 267 MapleStream & operator<<(MapleStream & ms, MathData const & ar)
 268 {
 269         maple(ar, ms);
 270         return ms;
 271 }
 272
 273
 274 MapleStream & operator<<(MapleStream & ms, char const * s)
 275 {
 276         ms.os() << s;
 277         return ms;
 278 }
 279
 280
 281 MapleStream & operator<<(MapleStream & ms, char c)
 282 {
 283         ms.os() << c;
 284         return ms;
 285 }
 286
 287
 288 MapleStream & operator<<(MapleStream & ms, int i)
 289 {
 290         ms.os() << i;
 291         return ms;
 292 }
 293
 294
 295 MapleStream & operator<<(MapleStream & ms, char_type c)
 296 {
 297         ms.os().put(c);
 298         return ms;
 299 }
 300
 301
 302 MapleStream & operator<<(MapleStream & ms, docstring const & s)
 303 {
 304         ms.os() << s;
 305         return ms;
 306 }
 307
 308
 309 //////////////////////////////////////////////////////////////////////
 310
 311
 312 MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 313 {
 314         at->maxima(ms);
 315         return ms;
 316 }
 317
 318
 319 MaximaStream & operator<<(MaximaStream & ms, MathData const & ar)
 320 {
 321         maxima(ar, ms);
 322         return ms;
 323 }
 324
 325
 326 MaximaStream & operator<<(MaximaStream & ms, char const * s)
 327 {
 328         ms.os() << s;
 329         return ms;
 330 }
 331
 332
 333 MaximaStream & operator<<(MaximaStream & ms, char c)
 334 {
 335         ms.os() << c;
 336         return ms;
 337 }
 338
 339
 340 MaximaStream & operator<<(MaximaStream & ms, int i)
 341 {
 342         ms.os() << i;
 343         return ms;
 344 }
 345
 346
 347 MaximaStream & operator<<(MaximaStream & ms, docstring const & s)
 348 {
 349         ms.os() << s;
 350         return ms;
 351 }
 352
 353
 354 MaximaStream & operator<<(MaximaStream & ms, char_type c)
 355 {
 356         ms.os().put(c);
 357         return ms;
 358 }
 359
 360
 361 //////////////////////////////////////////////////////////////////////
 362
 363
 364 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 365 {
 366         at->mathematica(ms);
 367         return ms;
 368 }
 369
 370
 371 MathematicaStream & operator<<(MathematicaStream & ms, MathData const & ar)
 372 {
 373         mathematica(ar, ms);
 374         return ms;
 375 }
 376
 377
 378 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 379 {
 380         ms.os() << s;
 381         return ms;
 382 }
 383
 384
 385 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 386 {
 387         ms.os() << c;
 388         return ms;
 389 }
 390
 391
 392 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 393 {
 394         ms.os() << i;
 395         return ms;
 396 }
 397
 398
 399 MathematicaStream & operator<<(MathematicaStream & ms, docstring const & s)
 400 {
 401         ms.os() << s;
 402         return ms;
 403 }
 404
 405
 406 MathematicaStream & operator<<(MathematicaStream & ms, char_type c)
 407 {
 408         ms.os().put(c);
 409         return ms;
 410 }
 411
 412
 413 //////////////////////////////////////////////////////////////////////
 414
 415
 416 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 417 {
 418         at->octave(ns);
 419         return ns;
 420 }
 421
 422
 423 OctaveStream & operator<<(OctaveStream & ns, MathData const & ar)
 424 {
 425         octave(ar, ns);
 426         return ns;
 427 }
 428
 429
 430 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 431 {
 432         ns.os() << s;
 433         return ns;
 434 }
 435
 436
 437 OctaveStream & operator<<(OctaveStream & ns, char c)
 438 {
 439         ns.os() << c;
 440         return ns;
 441 }
 442
 443
 444 OctaveStream & operator<<(OctaveStream & ns, int i)
 445 {
 446         ns.os() << i;
 447         return ns;
 448 }
 449
 450
 451 OctaveStream & operator<<(OctaveStream & ns, docstring const & s)
 452 {
 453         ns.os() << s;
 454         return ns;
 455 }
 456
 457
 458 OctaveStream & operator<<(OctaveStream & ns, char_type c)
 459 {
 460         ns.os().put(c);
 461         return ns;
 462 }
 463
 464
 465 OctaveStream & operator<<(OctaveStream & os, std::string const & s)
 466 {
 467         os.os() << from_utf8(s);
 468         return os;
 469 }
 470
 471
 472 } // namespace lyx