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 "MathStream.h"
  14
  15 #include "MathData.h"
  16 #include "MathExtern.h"
  17
  18 #include "support/textutils.h"
  19 #include "support/docstring.h"
  20
  21 #include <algorithm>
  22 #include <cstring>
  23 #include <ostream>
  24
  25 using namespace std;
  26
  27 namespace lyx {
  28
  29
  30 //////////////////////////////////////////////////////////////////////
  31
  32
  33 NormalStream & operator<<(NormalStream & ns, MathAtom const & at)
  34 {
  35         at->normalize(ns);
  36         return ns;
  37 }
  38
  39
  40 NormalStream & operator<<(NormalStream & ns, MathData const & ar)
  41 {
  42         normalize(ar, ns);
  43         return ns;
  44 }
  45
  46
  47 NormalStream & operator<<(NormalStream & ns, docstring const & s)
  48 {
  49         ns.os() << s;
  50         return ns;
  51 }
  52
  53
  54 NormalStream & operator<<(NormalStream & ns, const string & s)
  55 {
  56         ns.os() << from_utf8(s);
  57         return ns;
  58 }
  59
  60
  61 NormalStream & operator<<(NormalStream & ns, char const * s)
  62 {
  63         ns.os() << s;
  64         return ns;
  65 }
  66
  67
  68 NormalStream & operator<<(NormalStream & ns, char c)
  69 {
  70         ns.os() << c;
  71         return ns;
  72 }
  73
  74
  75 NormalStream & operator<<(NormalStream & ns, int i)
  76 {
  77         ns.os() << i;
  78         return ns;
  79 }
  80
  81
  82
  83 /////////////////////////////////////////////////////////////////
  84
  85
  86 WriteStream & operator<<(WriteStream & ws, docstring const & s)
  87 {
  88         if (ws.pendingBrace()) {
  89                 ws.os() << '}';
  90                 ws.pendingBrace(false);
  91                 ws.pendingSpace(false);
  92                 ws.textMode(true);
  93         } else if (ws.pendingSpace() && s.length() > 0) {
  94                 if (isAlphaASCII(s[0]))
  95                         ws.os() << ' ';
  96                 else if (s[0] == ' ' && ws.textMode())
  97                         ws.os() << '\\';
  98                 ws.pendingSpace(false);
  99         }
 100         ws.os() << s;
 101         int lf = 0;
 102         docstring::const_iterator dit = s.begin();
 103         docstring::const_iterator end = s.end();
 104         for (; dit != end; ++dit)
 105                 if ((*dit) == '\n')
 106                         ++lf;
 107         ws.addlines(lf);
 108         return ws;
 109 }
 110
 111
 112 WriteStream::WriteStream(odocstream & os, bool fragile, bool latex, OutputType output,
 113                         Encoding const * encoding)
 114         : os_(os), fragile_(fragile), firstitem_(false), latex_(latex),
 115           output_(output), pendingspace_(false), pendingbrace_(false),
 116           textmode_(false), locked_(0), line_(0), encoding_(encoding)
 117 {}
 118
 119
 120 WriteStream::WriteStream(odocstream & os)
 121         : os_(os), fragile_(false), firstitem_(false), latex_(false),
 122           output_(wsDefault), pendingspace_(false), pendingbrace_(false),
 123           textmode_(false), locked_(0), line_(0), encoding_(0)
 124 {}
 125
 126
 127 WriteStream::~WriteStream()
 128 {
 129         if (pendingbrace_)
 130                 os_ << '}';
 131         else if (pendingspace_)
 132                 os_ << ' ';
 133 }
 134
 135
 136 void WriteStream::addlines(unsigned int n)
 137 {
 138         line_ += n;
 139 }
 140
 141
 142 void WriteStream::pendingSpace(bool how)
 143 {
 144         pendingspace_ = how;
 145 }
 146
 147
 148 void WriteStream::pendingBrace(bool brace)
 149 {
 150         pendingbrace_ = brace;
 151 }
 152
 153
 154 void WriteStream::textMode(bool textmode)
 155 {
 156         textmode_ = textmode;
 157 }
 158
 159
 160 void WriteStream::lockedMode(bool locked)
 161 {
 162         locked_ = locked;
 163 }
 164
 165
 166 WriteStream & operator<<(WriteStream & ws, MathAtom const & at)
 167 {
 168         at->write(ws);
 169         return ws;
 170 }
 171
 172
 173 WriteStream & operator<<(WriteStream & ws, MathData const & ar)
 174 {
 175         write(ar, ws);
 176         return ws;
 177 }
 178
 179
 180 WriteStream & operator<<(WriteStream & ws, char const * s)
 181 {
 182         if (ws.pendingBrace()) {
 183                 ws.os() << '}';
 184                 ws.pendingBrace(false);
 185                 ws.pendingSpace(false);
 186                 ws.textMode(true);
 187         } else if (ws.pendingSpace() && strlen(s) > 0) {
 188                 if (isAlphaASCII(s[0]))
 189                         ws.os() << ' ';
 190                 else if (s[0] == ' ' && ws.textMode())
 191                         ws.os() << '\\';
 192                 ws.pendingSpace(false);
 193         }
 194         ws.os() << s;
 195         ws.addlines(int(count(s, s + strlen(s), '\n')));
 196         return ws;
 197 }
 198
 199
 200 WriteStream & operator<<(WriteStream & ws, char c)
 201 {
 202         if (ws.pendingBrace()) {
 203                 ws.os() << '}';
 204                 ws.pendingBrace(false);
 205                 ws.pendingSpace(false);
 206                 ws.textMode(true);
 207         } else if (ws.pendingSpace()) {
 208                 if (isAlphaASCII(c))
 209                         ws.os() << ' ';
 210                 else if (c == ' ' && ws.textMode())
 211                         ws.os() << '\\';
 212                 ws.pendingSpace(false);
 213         }
 214         ws.os() << c;
 215         if (c == '\n')
 216                 ws.addlines(1);
 217         return ws;
 218 }
 219
 220
 221 WriteStream & operator<<(WriteStream & ws, int i)
 222 {
 223         if (ws.pendingBrace()) {
 224                 ws.os() << '}';
 225                 ws.pendingBrace(false);
 226                 ws.textMode(true);
 227         }
 228         ws.os() << i;
 229         return ws;
 230 }
 231
 232
 233 WriteStream & operator<<(WriteStream & ws, unsigned int i)
 234 {
 235         if (ws.pendingBrace()) {
 236                 ws.os() << '}';
 237                 ws.pendingBrace(false);
 238                 ws.textMode(true);
 239         }
 240         ws.os() << i;
 241         return ws;
 242 }
 243
 244
 245 //////////////////////////////////////////////////////////////////////
 246
 247
 248 MathStream::MathStream(odocstream & os)
 249         : os_(os), tab_(0), line_(0), lastchar_(0), in_text_(false)
 250 {}
 251
 252
 253 void MathStream::cr()
 254 {
 255         os() << '\n';
 256         for (int i = 0; i < tab(); ++i)
 257                 os() << ' ';
 258 }
 259
 260
 261 void MathStream::defer(docstring const & s)
 262 {
 263         deferred_ << s;
 264 }
 265
 266
 267 void MathStream::defer(string const & s)
 268 {
 269         deferred_ << from_utf8(s);
 270 }
 271
 272
 273 docstring MathStream::deferred() const
 274 {
 275         return deferred_.str();
 276 }
 277
 278
 279 MathStream & operator<<(MathStream & ms, MathAtom const & at)
 280 {
 281         at->mathmlize(ms);
 282         return ms;
 283 }
 284
 285
 286 MathStream & operator<<(MathStream & ms, MathData const & ar)
 287 {
 288         mathmlize(ar, ms);
 289         return ms;
 290 }
 291
 292
 293 MathStream & operator<<(MathStream & ms, char const * s)
 294 {
 295         ms.os() << s;
 296         return ms;
 297 }
 298
 299
 300 MathStream & operator<<(MathStream & ms, char c)
 301 {
 302         ms.os() << c;
 303         return ms;
 304 }
 305
 306
 307 MathStream & operator<<(MathStream & ms, char_type c)
 308 {
 309         ms.os().put(c);
 310         return ms;
 311 }
 312
 313
 314 MathStream & operator<<(MathStream & ms, MTag const & t)
 315 {
 316         ++ms.tab();
 317         ms.cr();
 318         ms.os() << '<' << from_ascii(t.tag_);
 319         if (!t.attr_.empty())
 320                 ms.os() << " " << from_ascii(t.attr_);
 321         ms << '>';
 322         return ms;
 323 }
 324
 325
 326 MathStream & operator<<(MathStream & ms, ETag const & t)
 327 {
 328         ms.cr();
 329         if (ms.tab() > 0)
 330                 --ms.tab();
 331         ms.os() << "</" << from_ascii(t.tag_) << '>';
 332         return ms;
 333 }
 334
 335
 336 MathStream & operator<<(MathStream & ms, docstring const & s)
 337 {
 338         ms.os() << s;
 339         return ms;
 340 }
 341
 342
 343 SetMode::SetMode(MathStream & os, bool text)
 344         : os_(os), opened_(false)
 345 {
 346         init(text, from_ascii(""));
 347 }
 348
 349
 350 SetMode::SetMode(MathStream & os, bool text, docstring attrs)
 351         : os_(os), opened_(false)
 352 {
 353         init(text, attrs);
 354 }
 355
 356
 357 void SetMode::init(bool text, docstring attrs)
 358 {
 359         was_text_ = os_.inText();
 360         if (was_text_)
 361                 os_ << "</mtext>";
 362         if (text) {
 363                 os_.setTextMode();
 364                 os_ << "<mtext";
 365                 if (!attrs.empty())
 366                         os_ << " " << attrs;
 367                 os_ << ">";
 368                 opened_ = true;
 369         } else {
 370                 if (!attrs.empty()) {
 371                         os_ << "<mstyle " << attrs << ">";
 372                         opened_ = true;
 373                 }
 374                 os_.setMathMode();
 375         }
 376 }
 377
 378
 379 SetMode::~SetMode()
 380 {
 381         if (opened_) {
 382                 if (os_.inText())
 383                         os_ << "</mtext>";
 384                 else
 385                         os_ << "</mstyle>";
 386         }
 387         if (was_text_) {
 388                 os_.setTextMode();
 389                 os_ << "<mtext>";
 390         } else {
 391                 os_.setMathMode();
 392         }
 393 }
 394
 395
 396 //////////////////////////////////////////////////////////////////////
 397
 398
 399 MapleStream & operator<<(MapleStream & ms, MathAtom const & at)
 400 {
 401         at->maple(ms);
 402         return ms;
 403 }
 404
 405
 406 MapleStream & operator<<(MapleStream & ms, MathData const & ar)
 407 {
 408         maple(ar, ms);
 409         return ms;
 410 }
 411
 412
 413 MapleStream & operator<<(MapleStream & ms, char const * s)
 414 {
 415         ms.os() << s;
 416         return ms;
 417 }
 418
 419
 420 MapleStream & operator<<(MapleStream & ms, char c)
 421 {
 422         ms.os() << c;
 423         return ms;
 424 }
 425
 426
 427 MapleStream & operator<<(MapleStream & ms, int i)
 428 {
 429         ms.os() << i;
 430         return ms;
 431 }
 432
 433
 434 MapleStream & operator<<(MapleStream & ms, char_type c)
 435 {
 436         ms.os().put(c);
 437         return ms;
 438 }
 439
 440
 441 MapleStream & operator<<(MapleStream & ms, docstring const & s)
 442 {
 443         ms.os() << s;
 444         return ms;
 445 }
 446
 447
 448 //////////////////////////////////////////////////////////////////////
 449
 450
 451 MaximaStream & operator<<(MaximaStream & ms, MathAtom const & at)
 452 {
 453         at->maxima(ms);
 454         return ms;
 455 }
 456
 457
 458 MaximaStream & operator<<(MaximaStream & ms, MathData const & ar)
 459 {
 460         maxima(ar, ms);
 461         return ms;
 462 }
 463
 464
 465 MaximaStream & operator<<(MaximaStream & ms, char const * s)
 466 {
 467         ms.os() << s;
 468         return ms;
 469 }
 470
 471
 472 MaximaStream & operator<<(MaximaStream & ms, char c)
 473 {
 474         ms.os() << c;
 475         return ms;
 476 }
 477
 478
 479 MaximaStream & operator<<(MaximaStream & ms, int i)
 480 {
 481         ms.os() << i;
 482         return ms;
 483 }
 484
 485
 486 MaximaStream & operator<<(MaximaStream & ms, docstring const & s)
 487 {
 488         ms.os() << s;
 489         return ms;
 490 }
 491
 492
 493 MaximaStream & operator<<(MaximaStream & ms, char_type c)
 494 {
 495         ms.os().put(c);
 496         return ms;
 497 }
 498
 499
 500 //////////////////////////////////////////////////////////////////////
 501
 502
 503 MathematicaStream & operator<<(MathematicaStream & ms, MathAtom const & at)
 504 {
 505         at->mathematica(ms);
 506         return ms;
 507 }
 508
 509
 510 MathematicaStream & operator<<(MathematicaStream & ms, MathData const & ar)
 511 {
 512         mathematica(ar, ms);
 513         return ms;
 514 }
 515
 516
 517 MathematicaStream & operator<<(MathematicaStream & ms, char const * s)
 518 {
 519         ms.os() << s;
 520         return ms;
 521 }
 522
 523
 524 MathematicaStream & operator<<(MathematicaStream & ms, char c)
 525 {
 526         ms.os() << c;
 527         return ms;
 528 }
 529
 530
 531 MathematicaStream & operator<<(MathematicaStream & ms, int i)
 532 {
 533         ms.os() << i;
 534         return ms;
 535 }
 536
 537
 538 MathematicaStream & operator<<(MathematicaStream & ms, docstring const & s)
 539 {
 540         ms.os() << s;
 541         return ms;
 542 }
 543
 544
 545 MathematicaStream & operator<<(MathematicaStream & ms, char_type c)
 546 {
 547         ms.os().put(c);
 548         return ms;
 549 }
 550
 551
 552 //////////////////////////////////////////////////////////////////////
 553
 554
 555 OctaveStream & operator<<(OctaveStream & ns, MathAtom const & at)
 556 {
 557         at->octave(ns);
 558         return ns;
 559 }
 560
 561
 562 OctaveStream & operator<<(OctaveStream & ns, MathData const & ar)
 563 {
 564         octave(ar, ns);
 565         return ns;
 566 }
 567
 568
 569 OctaveStream & operator<<(OctaveStream & ns, char const * s)
 570 {
 571         ns.os() << s;
 572         return ns;
 573 }
 574
 575
 576 OctaveStream & operator<<(OctaveStream & ns, char c)
 577 {
 578         ns.os() << c;
 579         return ns;
 580 }
 581
 582
 583 OctaveStream & operator<<(OctaveStream & ns, int i)
 584 {
 585         ns.os() << i;
 586         return ns;
 587 }
 588
 589
 590 OctaveStream & operator<<(OctaveStream & ns, docstring const & s)
 591 {
 592         ns.os() << s;
 593         return ns;
 594 }
 595
 596
 597 OctaveStream & operator<<(OctaveStream & ns, char_type c)
 598 {
 599         ns.os().put(c);
 600         return ns;
 601 }
 602
 603
 604 OctaveStream & operator<<(OctaveStream & os, string const & s)
 605 {
 606         os.os() << from_utf8(s);
 607         return os;
 608 }
 609
 610
 611 } // namespace lyx