src/paragraph.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 1995 Matthias Ettrich
   7  *           Copyright 1995-2001 The LyX Team.
   8  *
   9  * ====================================================== */
  10
  11 #include <config.h>
  12
  13 #include "paragraph.h"
  14 #include "paragraph_pimpl.h"
  15
  16 #include "buffer.h"
  17 #include "bufferparams.h"
  18 #include "BufferView.h"
  19 #include "changes.h"
  20 #include "encoding.h"
  21 #include "debug.h"
  22 #include "gettext.h"
  23 #include "language.h"
  24 #include "latexrunparams.h"
  25 #include "layout.h"
  26 #include "lyxrc.h"
  27 #include "paragraph_funcs.h"
  28 #include "ParameterStruct.h"
  29 #include "texrow.h"
  30
  31 #include "Lsstream.h"
  32
  33 #include "insets/insetbibitem.h"
  34 #include "insets/insetoptarg.h"
  35 #include "insets/insetenv.h"
  36
  37 #include "support/filetools.h"
  38 #include "support/lstrings.h"
  39 #include "support/lyxmanip.h"
  40 #include "support/FileInfo.h"
  41 #include "support/LAssert.h"
  42 #include "support/textutils.h"
  43
  44 #include <algorithm>
  45 #include <fstream>
  46 #include <csignal>
  47 #include <ctime>
  48
  49 using namespace lyx::support;
  50
  51 using std::ostream;
  52 using std::endl;
  53 using std::fstream;
  54 using std::ios;
  55 using std::lower_bound;
  56 using std::upper_bound;
  57
  58 using lyx::pos_type;
  59
  60
  61 // this is a minibuffer
  62
  63 namespace {
  64
  65 char minibuffer_char;
  66 LyXFont minibuffer_font;
  67 InsetOld * minibuffer_inset;
  68
  69 } // namespace anon
  70
  71
  72 Paragraph::Paragraph()
  73         : pimpl_(new Paragraph::Pimpl(this))
  74 {
  75         enumdepth = 0;
  76         itemdepth = 0;
  77         params().clear();
  78 }
  79
  80
  81 Paragraph::Paragraph(Paragraph const & lp)
  82         : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this))
  83 {
  84         enumdepth = 0;
  85         itemdepth = 0;
  86         // this is because of the dummy layout of the paragraphs that
  87         // follow footnotes
  88         layout_ = lp.layout();
  89
  90         // copy everything behind the break-position to the new paragraph
  91         insetlist = lp.insetlist;
  92         InsetList::iterator it = insetlist.begin();
  93         InsetList::iterator end = insetlist.end();
  94         for (; it != end; ++it) {
  95                 // currently we hold Inset*, not InsetBase*
  96                 it->inset = static_cast<InsetOld*>(it->inset->clone().release());
  97                 // tell the new inset who is the boss now
  98                 it->inset->parOwner(this);
  99         }
 100 }
 101
 102
 103 void Paragraph::operator=(Paragraph const & lp)
 104 {
 105         // needed as we will destroy the pimpl_ before copying it
 106         if (&lp != this)
 107                 return;
 108         lyxerr << "Paragraph::operator=()\n";
 109         delete pimpl_;
 110         pimpl_ = new Pimpl(*lp.pimpl_, this);
 111
 112         enumdepth = lp.enumdepth;
 113         itemdepth = lp.itemdepth;
 114         // this is because of the dummy layout of the paragraphs that
 115         // follow footnotes
 116         layout_ = lp.layout();
 117
 118         // copy everything behind the break-position to the new paragraph
 119         insetlist = lp.insetlist;
 120         InsetList::iterator it = insetlist.begin();
 121         InsetList::iterator end = insetlist.end();
 122         for (; it != end; ++it) {
 123                 it->inset = static_cast<InsetOld*>(it->inset->clone().release());
 124                 // tell the new inset who is the boss now
 125                 it->inset->parOwner(this);
 126         }
 127 }
 128
 129 // the destructor removes the new paragraph from the list
 130 Paragraph::~Paragraph()
 131 {
 132         delete pimpl_;
 133         //
 134         //lyxerr << "Paragraph::paragraph_id = "
 135         //       << Paragraph::paragraph_id << endl;
 136 }
 137
 138
 139 void Paragraph::write(Buffer const * buf, ostream & os,
 140                           BufferParams const & bparams,
 141                           depth_type & dth) const
 142 {
 143         // The beginning or end of a deeper (i.e. nested) area?
 144         if (dth != params().depth()) {
 145                 if (params().depth() > dth) {
 146                         while (params().depth() > dth) {
 147                                 os << "\n\\begin_deeper ";
 148                                 ++dth;
 149                         }
 150                 } else {
 151                         while (params().depth() < dth) {
 152                                 os << "\n\\end_deeper ";
 153                                 --dth;
 154                         }
 155                 }
 156         }
 157
 158         // First write the layout
 159         os << "\n\\layout " << layout()->name() << '\n';
 160
 161         params().write(os);
 162
 163         LyXFont font1(LyXFont::ALL_INHERIT, bparams.language);
 164
 165         Change running_change = Change(Change::UNCHANGED);
 166         lyx::time_type const curtime(lyx::current_time());
 167
 168         int column = 0;
 169         for (pos_type i = 0; i < size(); ++i) {
 170                 if (!i) {
 171                         os << '\n';
 172                         column = 0;
 173                 }
 174
 175                 Change change = pimpl_->lookupChangeFull(i);
 176                 Changes::lyxMarkChange(os, column, curtime, running_change, change);
 177                 running_change = change;
 178
 179                 // Write font changes
 180                 LyXFont font2 = getFontSettings(bparams, i);
 181                 if (font2 != font1) {
 182                         font2.lyxWriteChanges(font1, os);
 183                         column = 0;
 184                         font1 = font2;
 185                 }
 186
 187                 value_type const c = getChar(i);
 188                 switch (c) {
 189                 case META_INSET:
 190                 {
 191                         InsetOld const * inset = getInset(i);
 192                         if (inset)
 193                                 if (inset->directWrite()) {
 194                                         // international char, let it write
 195                                         // code directly so it's shorter in
 196                                         // the file
 197                                         inset->write(buf, os);
 198                                 } else {
 199                                         os << "\n\\begin_inset ";
 200                                         inset->write(buf, os);
 201                                         os << "\n\\end_inset \n\n";
 202                                         column = 0;
 203                                 }
 204                 }
 205                 break;
 206                 case '\\':
 207                         os << "\n\\backslash \n";
 208                         column = 0;
 209                         break;
 210                 case '.':
 211                         if (i + 1 < size() && getChar(i + 1) == ' ') {
 212                                 os << ".\n";
 213                                 column = 0;
 214                         } else
 215                                 os << '.';
 216                         break;
 217                 default:
 218                         if ((column > 70 && c == ' ')
 219                             || column > 79) {
 220                                 os << '\n';
 221                                 column = 0;
 222                         }
 223                         // this check is to amend a bug. LyX sometimes
 224                         // inserts '\0' this could cause problems.
 225                         if (c != '\0')
 226                                 os << c;
 227                         else
 228                                 lyxerr << "ERROR (Paragraph::writeFile):"
 229                                         " NULL char in structure." << endl;
 230                         ++column;
 231                         break;
 232                 }
 233         }
 234
 235         // to make reading work properly
 236         if (!size()) {
 237                 running_change = pimpl_->lookupChange(0);
 238                 Changes::lyxMarkChange(os, column, curtime,
 239                         Change(Change::UNCHANGED), running_change);
 240         }
 241         Changes::lyxMarkChange(os, column, curtime,
 242                 running_change, Change(Change::UNCHANGED));
 243
 244         os << "\n\\end_layout\n";
 245 }
 246
 247
 248 void Paragraph::validate(LaTeXFeatures & features) const
 249 {
 250         pimpl_->validate(features, *layout());
 251 }
 252
 253
 254 // First few functions needed for cut and paste and paragraph breaking.
 255 void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const
 256 {
 257         BufferParams bparams = buffer.params;
 258
 259         minibuffer_char = getChar(pos);
 260         minibuffer_font = getFontSettings(bparams, pos);
 261         minibuffer_inset = 0;
 262         if (minibuffer_char == Paragraph::META_INSET) {
 263                 if (getInset(pos)) {
 264                         minibuffer_inset = static_cast<InsetOld *>(getInset(pos)->clone().release());
 265                 } else {
 266                         minibuffer_inset = 0;
 267                         minibuffer_char = ' ';
 268                         // This reflects what GetInset() does (ARRae)
 269                 }
 270         }
 271 }
 272
 273
 274 void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos)
 275 {
 276         minibuffer_char = getChar(pos);
 277         minibuffer_font = getFontSettings(bparams, pos);
 278         minibuffer_inset = 0;
 279         if (minibuffer_char == Paragraph::META_INSET) {
 280                 if (getInset(pos)) {
 281                         // the inset is not in a paragraph anymore
 282                         minibuffer_inset = insetlist.release(pos);
 283                         minibuffer_inset->parOwner(0);
 284                 } else {
 285                         minibuffer_inset = 0;
 286                         minibuffer_char = ' ';
 287                         // This reflects what GetInset() does (ARRae)
 288                 }
 289
 290         }
 291
 292         // Erase(pos); now the caller is responsible for that.
 293 }
 294
 295
 296 bool Paragraph::insertFromMinibuffer(pos_type pos)
 297 {
 298         if (minibuffer_char == Paragraph::META_INSET) {
 299                 if (!insetAllowed(minibuffer_inset->lyxCode())) {
 300                         return false;
 301                 }
 302                 insertInset(pos, minibuffer_inset, minibuffer_font);
 303         } else {
 304                 LyXFont f = minibuffer_font;
 305                 if (!checkInsertChar(f)) {
 306                         return false;
 307                 }
 308                 insertChar(pos, minibuffer_char, f);
 309         }
 310         return true;
 311 }
 312
 313 // end of minibuffer
 314
 315
 316 void Paragraph::eraseIntern(lyx::pos_type pos)
 317 {
 318         pimpl_->eraseIntern(pos);
 319 }
 320
 321
 322 bool Paragraph::erase(pos_type pos)
 323 {
 324         return pimpl_->erase(pos);
 325 }
 326
 327
 328 int Paragraph::erase(pos_type start, pos_type end)
 329 {
 330         return pimpl_->erase(start, end);
 331 }
 332
 333
 334 bool Paragraph::checkInsertChar(LyXFont & font)
 335 {
 336         if (pimpl_->inset_owner)
 337                 return pimpl_->inset_owner->checkInsertChar(font);
 338         return true;
 339 }
 340
 341
 342 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c)
 343 {
 344         LyXFont const f(LyXFont::ALL_INHERIT);
 345         insertChar(pos, c, f);
 346 }
 347
 348
 349 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
 350                            LyXFont const & font, Change change)
 351 {
 352         pimpl_->insertChar(pos, c, font, change);
 353 }
 354
 355
 356 void Paragraph::insertInset(pos_type pos, InsetOld * inset)
 357 {
 358         LyXFont const f(LyXFont::ALL_INHERIT);
 359         insertInset(pos, inset, f);
 360 }
 361
 362
 363 void Paragraph::insertInset(pos_type pos, InsetOld * inset, LyXFont const & font, Change change)
 364 {
 365         pimpl_->insertInset(pos, inset, font, change);
 366 }
 367
 368
 369 bool Paragraph::insetAllowed(InsetOld::Code code)
 370 {
 371         //lyxerr << "Paragraph::InsertInsetAllowed" << endl;
 372         if (pimpl_->inset_owner)
 373                 return pimpl_->inset_owner->insetAllowed(code);
 374         return true;
 375 }
 376
 377
 378 InsetOld * Paragraph::getInset(pos_type pos)
 379 {
 380         Assert(pos < size());
 381         return insetlist.get(pos);
 382 }
 383
 384
 385 InsetOld const * Paragraph::getInset(pos_type pos) const
 386 {
 387         Assert(pos < size());
 388         return insetlist.get(pos);
 389 }
 390
 391
 392 // Gets uninstantiated font setting at position.
 393 LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
 394                                          pos_type pos) const
 395 {
 396         Assert(pos <= size());
 397
 398         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 399         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 400         for (; cit != end; ++cit) {
 401                 if (cit->pos() >= pos)
 402                         break;
 403         }
 404
 405         LyXFont retfont;
 406         if (cit != end)
 407                 retfont = cit->font();
 408         else if (pos == size() && !empty())
 409                 retfont = getFontSettings(bparams, pos - 1);
 410         else
 411                 retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
 412
 413         return retfont;
 414 }
 415
 416 lyx::pos_type
 417 Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
 418 {
 419         Assert(pos <= size());
 420
 421         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 422         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 423         for (; cit != end; ++cit) {
 424                 if (cit->pos() >= pos)
 425                         return cit->pos();
 426         }
 427         // This should not happen, but if so, we take no chances.
 428         return pos;
 429 }
 430
 431
 432 // Gets uninstantiated font setting at position 0
 433 LyXFont const Paragraph::getFirstFontSettings() const
 434 {
 435         if (!empty() && !pimpl_->fontlist.empty())
 436                 return pimpl_->fontlist[0].font();
 437
 438         return LyXFont(LyXFont::ALL_INHERIT);
 439 }
 440
 441
 442 // Gets the fully instantiated font at a given position in a paragraph
 443 // This is basically the same function as LyXText::GetFont() in text2.C.
 444 // The difference is that this one is used for generating the LaTeX file,
 445 // and thus cosmetic "improvements" are disallowed: This has to deliver
 446 // the true picture of the buffer. (Asger)
 447 LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
 448                                  LyXFont const & outerfont) const
 449 {
 450         Assert(pos >= 0);
 451
 452         LyXLayout_ptr const & lout = layout();
 453
 454         pos_type const body_pos = beginningOfBody();
 455
 456         LyXFont layoutfont;
 457         if (pos < body_pos)
 458                 layoutfont = lout->labelfont;
 459         else
 460                 layoutfont = lout->font;
 461
 462         LyXFont tmpfont = getFontSettings(bparams, pos);
 463         tmpfont.realize(layoutfont);
 464         tmpfont.realize(outerfont);
 465         tmpfont.realize(bparams.getLyXTextClass().defaultfont());
 466
 467         return tmpfont;
 468 }
 469
 470
 471 LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
 472                                       LyXFont const & outerfont) const
 473 {
 474         LyXLayout_ptr const & lout = layout();
 475
 476         LyXFont tmpfont = lout->labelfont;
 477         tmpfont.setLanguage(getParLanguage(bparams));
 478         tmpfont.realize(outerfont);
 479         tmpfont.realize(bparams.getLyXTextClass().defaultfont());
 480
 481         return tmpfont;
 482 }
 483
 484
 485 LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
 486                                        LyXFont const & outerfont) const
 487 {
 488         LyXLayout_ptr const & lout = layout();
 489
 490         LyXFont tmpfont = lout->font;
 491         tmpfont.setLanguage(getParLanguage(bparams));
 492         tmpfont.realize(outerfont);
 493         tmpfont.realize(bparams.getLyXTextClass().defaultfont());
 494
 495         return tmpfont;
 496 }
 497
 498
 499 /// Returns the height of the highest font in range
 500 LyXFont::FONT_SIZE
 501 Paragraph::highestFontInRange(pos_type startpos, pos_type endpos,
 502                               LyXFont::FONT_SIZE const def_size) const
 503 {
 504         if (pimpl_->fontlist.empty())
 505                 return def_size;
 506
 507         Pimpl::FontList::const_iterator end_it = pimpl_->fontlist.begin();
 508         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 509         for (; end_it != end; ++end_it) {
 510                 if (end_it->pos() >= endpos)
 511                         break;
 512         }
 513
 514         if (end_it != end)
 515                 ++end_it;
 516
 517         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 518         for (; cit != end; ++cit) {
 519                 if (cit->pos() >= startpos)
 520                         break;
 521         }
 522
 523         LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY;
 524         for (; cit != end_it; ++cit) {
 525                 LyXFont::FONT_SIZE size = cit->font().size();
 526                 if (size == LyXFont::INHERIT_SIZE)
 527                         size = def_size;
 528                 if (size > maxsize && size <= LyXFont::SIZE_HUGER)
 529                         maxsize = size;
 530         }
 531         return maxsize;
 532 }
 533
 534
 535 Paragraph::value_type
 536 Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
 537 {
 538         value_type c = getChar(pos);
 539         if (!lyxrc.rtl_support)
 540                 return c;
 541
 542         value_type uc = c;
 543         switch (c) {
 544         case '(':
 545                 uc = ')';
 546                 break;
 547         case ')':
 548                 uc = '(';
 549                 break;
 550         case '[':
 551                 uc = ']';
 552                 break;
 553         case ']':
 554                 uc = '[';
 555                 break;
 556         case '{':
 557                 uc = '}';
 558                 break;
 559         case '}':
 560                 uc = '{';
 561                 break;
 562         case '<':
 563                 uc = '>';
 564                 break;
 565         case '>':
 566                 uc = '<';
 567                 break;
 568         }
 569         if (uc != c && getFontSettings(bparams, pos).isRightToLeft())
 570                 return uc;
 571         else
 572                 return c;
 573 }
 574
 575
 576 void Paragraph::setFont(pos_type pos, LyXFont const & font)
 577 {
 578         Assert(pos <= size());
 579
 580         // First, reduce font against layout/label font
 581         // Update: The SetCharFont() routine in text2.C already
 582         // reduces font, so we don't need to do that here. (Asger)
 583         // No need to simplify this because it will disappear
 584         // in a new kernel. (Asger)
 585         // Next search font table
 586
 587         Pimpl::FontList::iterator beg = pimpl_->fontlist.begin();
 588         Pimpl::FontList::iterator it = beg;
 589         Pimpl::FontList::iterator endit = pimpl_->fontlist.end();
 590         for (; it != endit; ++it) {
 591                 if (it->pos() >= pos)
 592                         break;
 593         }
 594         unsigned int i = std::distance(beg, it);
 595         bool notfound = (it == endit);
 596
 597         if (!notfound && pimpl_->fontlist[i].font() == font)
 598                 return;
 599
 600         bool begin = pos == 0 || notfound ||
 601                 (i > 0 && pimpl_->fontlist[i - 1].pos() == pos - 1);
 602         // Is position pos is a beginning of a font block?
 603         bool end = !notfound && pimpl_->fontlist[i].pos() == pos;
 604         // Is position pos is the end of a font block?
 605         if (begin && end) { // A single char block
 606                 if (i + 1 < pimpl_->fontlist.size() &&
 607                     pimpl_->fontlist[i + 1].font() == font) {
 608                         // Merge the singleton block with the next block
 609                         pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
 610                         if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
 611                                 pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i - 1);
 612                 } else if (i > 0 && pimpl_->fontlist[i - 1].font() == font) {
 613                         // Merge the singleton block with the previous block
 614                         pimpl_->fontlist[i - 1].pos(pos);
 615                         pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
 616                 } else
 617                         pimpl_->fontlist[i].font(font);
 618         } else if (begin) {
 619                 if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
 620                         pimpl_->fontlist[i - 1].pos(pos);
 621                 else
 622                         pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
 623                                         Pimpl::FontTable(pos, font));
 624         } else if (end) {
 625                 pimpl_->fontlist[i].pos(pos - 1);
 626                 if (!(i + 1 < pimpl_->fontlist.size() &&
 627                       pimpl_->fontlist[i + 1].font() == font))
 628                         pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
 629                                         Pimpl::FontTable(pos, font));
 630         } else { // The general case. The block is splitted into 3 blocks
 631                 pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
 632                                 Pimpl::FontTable(pos - 1, pimpl_->fontlist[i].font()));
 633                 pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
 634                                 Pimpl::FontTable(pos, font));
 635         }
 636 }
 637
 638
 639 void Paragraph::makeSameLayout(Paragraph const & par)
 640 {
 641         layout(par.layout());
 642         // move to pimpl?
 643         params() = par.params();
 644 }
 645
 646
 647 int Paragraph::stripLeadingSpaces()
 648 {
 649         if (isFreeSpacing())
 650                 return 0;
 651
 652         int i = 0;
 653         while (!empty() && (isNewline(0) || isLineSeparator(0))) {
 654                 pimpl_->eraseIntern(0);
 655                 ++i;
 656         }
 657
 658         return i;
 659 }
 660
 661
 662 bool Paragraph::hasSameLayout(Paragraph const & par) const
 663 {
 664         return
 665                 par.layout() == layout() &&
 666                 params().sameLayout(par.params());
 667 }
 668
 669
 670 Paragraph::depth_type Paragraph::getDepth() const
 671 {
 672         return params().depth();
 673 }
 674
 675
 676 Paragraph::depth_type Paragraph::getMaxDepthAfter() const
 677 {
 678         if (layout()->isEnvironment())
 679                 return params().depth() + 1;
 680         else
 681                 return params().depth();
 682 }
 683
 684
 685 char Paragraph::getAlign() const
 686 {
 687         return params().align();
 688 }
 689
 690
 691 string const & Paragraph::getLabelstring() const
 692 {
 693         return params().labelString();
 694 }
 695
 696
 697 // the next two functions are for the manual labels
 698 string const Paragraph::getLabelWidthString() const
 699 {
 700         if (!params().labelWidthString().empty())
 701                 return params().labelWidthString();
 702         else
 703                 return _("Senseless with this layout!");
 704 }
 705
 706
 707 void Paragraph::setLabelWidthString(string const & s)
 708 {
 709         params().labelWidthString(s);
 710 }
 711
 712
 713 void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
 714 {
 715         layout(new_layout);
 716         params().labelWidthString(string());
 717         params().align(LYX_ALIGN_LAYOUT);
 718         params().spaceTop(VSpace(VSpace::NONE));
 719         params().spaceBottom(VSpace(VSpace::NONE));
 720         params().spacing(Spacing(Spacing::Default));
 721 }
 722
 723
 724 int Paragraph::beginningOfBody() const
 725 {
 726         if (layout()->labeltype != LABEL_MANUAL)
 727                 return 0;
 728
 729         // Unroll the first two cycles of the loop
 730         // and remember the previous character to
 731         // remove unnecessary GetChar() calls
 732         pos_type i = 0;
 733         if (i < size() && !isNewline(i)) {
 734                 ++i;
 735                 char previous_char = 0;
 736                 char temp = 0;
 737                 if (i < size()) {
 738                         previous_char = getChar(i);
 739                         if (!isNewline(i)) {
 740                                 ++i;
 741                                 while (i < size() && previous_char != ' ') {
 742                                         temp = getChar(i);
 743                                         if (isNewline(i))
 744                                                 break;
 745
 746                                         ++i;
 747                                         previous_char = temp;
 748                                 }
 749                         }
 750                 }
 751         }
 752
 753         return i;
 754 }
 755
 756
 757 // returns -1 if inset not found
 758 int Paragraph::getPositionOfInset(InsetOld const * inset) const
 759 {
 760         // Find the entry.
 761         InsetList::const_iterator it = insetlist.begin();
 762         InsetList::const_iterator end = insetlist.end();
 763         for (; it != end; ++it)
 764                 if (it->inset == inset)
 765                         return it->pos;
 766         return -1;
 767 }
 768
 769
 770 InsetBibitem * Paragraph::bibitem() const
 771 {
 772         InsetList::const_iterator it = insetlist.begin();
 773         if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE)
 774                 return static_cast<InsetBibitem *>(it->inset);
 775         return 0;
 776 }
 777
 778
 779
 780 // This could go to ParagraphParameters if we want to
 781 int Paragraph::startTeXParParams(BufferParams const & bparams,
 782                                  ostream & os, bool moving_arg) const
 783 {
 784         int column = 0;
 785
 786         if (params().noindent()) {
 787                 os << "\\noindent ";
 788                 column += 10;
 789         }
 790
 791         switch (params().align()) {
 792         case LYX_ALIGN_NONE:
 793         case LYX_ALIGN_BLOCK:
 794         case LYX_ALIGN_LAYOUT:
 795         case LYX_ALIGN_SPECIAL:
 796                 break;
 797         case LYX_ALIGN_LEFT:
 798         case LYX_ALIGN_RIGHT:
 799         case LYX_ALIGN_CENTER:
 800                 if (moving_arg) {
 801                         os << "\\protect";
 802                         column = 8;
 803                 }
 804                 break;
 805         }
 806
 807         switch (params().align()) {
 808         case LYX_ALIGN_NONE:
 809         case LYX_ALIGN_BLOCK:
 810         case LYX_ALIGN_LAYOUT:
 811         case LYX_ALIGN_SPECIAL:
 812                 break;
 813         case LYX_ALIGN_LEFT:
 814                 if (getParLanguage(bparams)->babel() != "hebrew") {
 815                         os << "\\begin{flushleft}";
 816                         column += 17;
 817                 } else {
 818                         os << "\\begin{flushright}";
 819                         column += 18;
 820                 }
 821                 break;
 822         case LYX_ALIGN_RIGHT:
 823                 if (getParLanguage(bparams)->babel() != "hebrew") {
 824                         os << "\\begin{flushright}";
 825                         column += 18;
 826                 } else {
 827                         os << "\\begin{flushleft}";
 828                         column += 17;
 829                 }
 830                 break;
 831         case LYX_ALIGN_CENTER:
 832                 os << "\\begin{center}";
 833                 column += 14;
 834                 break;
 835         }
 836
 837         return column;
 838 }
 839
 840
 841 // This could go to ParagraphParameters if we want to
 842 int Paragraph::endTeXParParams(BufferParams const & bparams,
 843                                ostream & os, bool moving_arg) const
 844 {
 845         int column = 0;
 846
 847         switch (params().align()) {
 848         case LYX_ALIGN_NONE:
 849         case LYX_ALIGN_BLOCK:
 850         case LYX_ALIGN_LAYOUT:
 851         case LYX_ALIGN_SPECIAL:
 852                 break;
 853         case LYX_ALIGN_LEFT:
 854         case LYX_ALIGN_RIGHT:
 855         case LYX_ALIGN_CENTER:
 856                 if (moving_arg) {
 857                         os << "\\protect";
 858                         column = 8;
 859                 }
 860                 break;
 861         }
 862
 863         switch (params().align()) {
 864         case LYX_ALIGN_NONE:
 865         case LYX_ALIGN_BLOCK:
 866         case LYX_ALIGN_LAYOUT:
 867         case LYX_ALIGN_SPECIAL:
 868                 break;
 869         case LYX_ALIGN_LEFT:
 870                 if (getParLanguage(bparams)->babel() != "hebrew") {
 871                         os << "\\end{flushleft}";
 872                         column = 15;
 873                 } else {
 874                         os << "\\end{flushright}";
 875                         column = 16;
 876                 }
 877                 break;
 878         case LYX_ALIGN_RIGHT:
 879                 if (getParLanguage(bparams)->babel() != "hebrew") {
 880                         os << "\\end{flushright}";
 881                         column+= 16;
 882                 } else {
 883                         os << "\\end{flushleft}";
 884                         column = 15;
 885                 }
 886                 break;
 887         case LYX_ALIGN_CENTER:
 888                 os << "\\end{center}";
 889                 column = 12;
 890                 break;
 891         }
 892         return column;
 893 }
 894
 895
 896 // This one spits out the text of the paragraph
 897 bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 898                                 BufferParams const & bparams,
 899                                 LyXFont const & outerfont,
 900                                 ostream & os, TexRow & texrow,
 901                                 LatexRunParams const & runparams)
 902 {
 903         lyxerr[Debug::LATEX] << "SimpleTeXOnePar...     " << this << endl;
 904
 905         bool return_value = false;
 906
 907         LyXLayout_ptr style;
 908
 909         // well we have to check if we are in an inset with unlimited
 910         // lenght (all in one row) if that is true then we don't allow
 911         // any special options in the paragraph and also we don't allow
 912         // any environment other then "Standard" to be valid!
 913         bool asdefault =
 914                 (inInset() && inInset()->forceDefaultParagraphs(inInset()));
 915
 916         if (asdefault) {
 917                 style = bparams.getLyXTextClass().defaultLayout();
 918         } else {
 919                 style = layout();
 920         }
 921
 922         LyXFont basefont;
 923
 924         // Maybe we have to create a optional argument.
 925         pos_type body_pos;
 926
 927         // FIXME: can we actually skip this check and just call
 928         // beginningOfBody() ??
 929         if (style->labeltype != LABEL_MANUAL) {
 930                 body_pos = 0;
 931         } else {
 932                 body_pos = beginningOfBody();
 933         }
 934
 935         unsigned int column = 0;
 936
 937         if (body_pos > 0) {
 938                 os << '[';
 939                 ++column;
 940                 basefont = getLabelFont(bparams, outerfont);
 941         } else {
 942                 basefont = getLayoutFont(bparams, outerfont);
 943         }
 944
 945         bool moving_arg = runparams.moving_arg;
 946         moving_arg |= style->needprotect;
 947
 948         // Which font is currently active?
 949         LyXFont running_font(basefont);
 950         // Do we have an open font change?
 951         bool open_font = false;
 952
 953         Change::Type running_change = Change::UNCHANGED;
 954
 955         texrow.start(id(), 0);
 956
 957         // if the paragraph is empty, the loop will not be entered at all
 958         if (empty()) {
 959                 if (style->isCommand()) {
 960                         os << '{';
 961                         ++column;
 962                 }
 963                 if (!asdefault)
 964                         column += startTeXParParams(bparams, os, moving_arg);
 965
 966         }
 967
 968         for (pos_type i = 0; i < size(); ++i) {
 969                 ++column;
 970                 // First char in paragraph or after label?
 971                 if (i == body_pos) {
 972                         if (body_pos > 0) {
 973                                 if (open_font) {
 974                                         column += running_font.latexWriteEndChanges(os, basefont, basefont);
 975                                         open_font = false;
 976                                 }
 977                                 basefont = getLayoutFont(bparams, outerfont);
 978                                 running_font = basefont;
 979                                 os << ']';
 980                                 ++column;
 981                         }
 982                         if (style->isCommand()) {
 983                                 os << '{';
 984                                 ++column;
 985                         }
 986
 987                         if (!asdefault)
 988                                 column += startTeXParParams(bparams, os,
 989                                                             moving_arg);
 990                 }
 991
 992                 value_type c = getChar(i);
 993
 994                 // Fully instantiated font
 995                 LyXFont font = getFont(bparams, i, outerfont);
 996
 997                 LyXFont const last_font = running_font;
 998
 999                 // Spaces at end of font change are simulated to be
1000                 // outside font change, i.e. we write "\textXX{text} "
1001                 // rather than "\textXX{text }". (Asger)
1002                 if (open_font && c == ' ' && i <= size() - 2) {
1003                         LyXFont const & next_font = getFont(bparams, i + 1, outerfont);
1004                         if (next_font != running_font
1005                             && next_font != font) {
1006                                 font = next_font;
1007                         }
1008                 }
1009
1010                 // We end font definition before blanks
1011                 if (open_font &&
1012                     (font != running_font ||
1013                      font.language() != running_font.language()))
1014                 {
1015                         column += running_font.latexWriteEndChanges(os,
1016                                                                     basefont,
1017                                                                     (i == body_pos-1) ? basefont : font);
1018                         running_font = basefont;
1019                         open_font = false;
1020                 }
1021
1022                 // Blanks are printed before start of fontswitch
1023                 if (c == ' ') {
1024                         // Do not print the separation of the optional argument
1025                         if (i != body_pos - 1) {
1026                                 pimpl_->simpleTeXBlanks(os, texrow, i,
1027                                                        column, font, *style);
1028                         }
1029                 }
1030
1031                 // Do we need to change font?
1032                 if ((font != running_font ||
1033                      font.language() != running_font.language()) &&
1034                         i != body_pos - 1)
1035                 {
1036                         column += font.latexWriteStartChanges(os, basefont,
1037                                                               last_font);
1038                         running_font = font;
1039                         open_font = true;
1040                 }
1041
1042                 Change::Type change = pimpl_->lookupChange(i);
1043
1044                 column += Changes::latexMarkChange(os, running_change, change);
1045                 running_change = change;
1046
1047                 LatexRunParams rp = runparams;
1048                 rp.moving_arg = moving_arg;
1049                 rp.free_spacing = style->free_spacing;
1050                 pimpl_->simpleTeXSpecialChars(buf, bparams,
1051                                               os, texrow, runparams,
1052                                               font, running_font,
1053                                               basefont, outerfont, open_font,
1054                                               running_change,
1055                                               *style, i, column, c);
1056         }
1057
1058         column += Changes::latexMarkChange(os,
1059                         running_change, Change::UNCHANGED);
1060
1061         // If we have an open font definition, we have to close it
1062         if (open_font) {
1063 #ifdef FIXED_LANGUAGE_END_DETECTION
1064                 if (next_) {
1065                         running_font
1066                                 .latexWriteEndChanges(os, basefont,
1067                                                       next_->getFont(bparams,
1068                                                       0, outerfont));
1069                 } else {
1070                         running_font.latexWriteEndChanges(os, basefont,
1071                                                           basefont);
1072                 }
1073 #else
1074 #ifdef WITH_WARNINGS
1075 //#warning For now we ALWAYS have to close the foreign font settings if they are
1076 //#warning there as we start another \selectlanguage with the next paragraph if
1077 //#warning we are in need of this. This should be fixed sometime (Jug)
1078 #endif
1079                 running_font.latexWriteEndChanges(os, basefont,  basefont);
1080 #endif
1081         }
1082
1083         // Needed if there is an optional argument but no contents.
1084         if (body_pos > 0 && body_pos == size()) {
1085                 os << "]~";
1086                 return_value = false;
1087         }
1088
1089         if (!asdefault) {
1090                 column += endTeXParParams(bparams, os, moving_arg);
1091         }
1092
1093         lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl;
1094         return return_value;
1095 }
1096
1097
1098
1099
1100 bool Paragraph::isHfill(pos_type pos) const
1101 {
1102         return IsInsetChar(getChar(pos))
1103                && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE;
1104 }
1105
1106
1107 bool Paragraph::isInset(pos_type pos) const
1108 {
1109         return IsInsetChar(getChar(pos));
1110 }
1111
1112
1113 bool Paragraph::isNewline(pos_type pos) const
1114 {
1115         return IsInsetChar(getChar(pos))
1116                && getInset(pos)->lyxCode() == InsetOld::NEWLINE_CODE;
1117 }
1118
1119
1120 bool Paragraph::isSeparator(pos_type pos) const
1121 {
1122         return IsSeparatorChar(getChar(pos));
1123 }
1124
1125
1126 bool Paragraph::isLineSeparator(pos_type pos) const
1127 {
1128         value_type const c = getChar(pos);
1129         return IsLineSeparatorChar(c)
1130                 || (IsInsetChar(c) && getInset(pos) &&
1131                 getInset(pos)->isLineSeparator());
1132 }
1133
1134
1135 bool Paragraph::isKomma(pos_type pos) const
1136 {
1137         return IsKommaChar(getChar(pos));
1138 }
1139
1140
1141 /// Used by the spellchecker
1142 bool Paragraph::isLetter(pos_type pos) const
1143 {
1144         value_type const c = getChar(pos);
1145         if (IsLetterChar(c))
1146                 return true;
1147         if (isInset(pos))
1148                 return getInset(pos)->isLetter();
1149         // We want to pass the ' and escape chars to ispell
1150         string const extra = lyxrc.isp_esc_chars + '\'';
1151         return contains(extra, c);
1152 }
1153
1154
1155 bool Paragraph::isWord(pos_type pos) const
1156 {
1157         return IsWordChar(getChar(pos)) ;
1158 }
1159
1160
1161 Language const *
1162 Paragraph::getParLanguage(BufferParams const & bparams) const
1163 {
1164         if (!empty())
1165                 return getFirstFontSettings().language();
1166 #warning FIXME we should check the prev par as well (Lgb)
1167         return bparams.language;
1168 }
1169
1170
1171 bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const
1172 {
1173         return lyxrc.rtl_support
1174                 && getParLanguage(bparams)->RightToLeft()
1175                 && !(inInset() && inInset()->owner() &&
1176                      inInset()->owner()->lyxCode() == InsetOld::ERT_CODE);
1177 }
1178
1179
1180 void Paragraph::changeLanguage(BufferParams const & bparams,
1181                                Language const * from, Language const * to)
1182 {
1183         for (pos_type i = 0; i < size(); ++i) {
1184                 LyXFont font = getFontSettings(bparams, i);
1185                 if (font.language() == from) {
1186                         font.setLanguage(to);
1187                         setFont(i, font);
1188                 }
1189         }
1190 }
1191
1192
1193 bool Paragraph::isMultiLingual(BufferParams const & bparams)
1194 {
1195         Language const * doc_language = bparams.language;
1196         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
1197         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
1198
1199         for (; cit != end; ++cit)
1200                 if (cit->font().language() != ignore_language &&
1201                     cit->font().language() != latex_language &&
1202                         cit->font().language() != doc_language)
1203                         return true;
1204         return false;
1205 }
1206
1207
1208 // Convert the paragraph to a string.
1209 // Used for building the table of contents
1210 string const Paragraph::asString(Buffer const * buffer, bool label) const
1211 {
1212 #if 0
1213         string s;
1214         if (label && !params().labelString().empty())
1215                 s += params().labelString() + ' ';
1216
1217         for (pos_type i = 0; i < size(); ++i) {
1218                 value_type c = getChar(i);
1219                 if (IsPrintable(c))
1220                         s += c;
1221                 else if (c == META_INSET &&
1222                          getInset(i)->lyxCode() == InsetOld::MATH_CODE) {
1223                         ostringstream ost;
1224                         getInset(i)->ascii(buffer, ost);
1225                         s += subst(STRCONV(ost.str()),'\n',' ');
1226                 }
1227         }
1228
1229         return s;
1230 #else
1231         // This should really be done by the caller and not here.
1232         string ret(asString(buffer, 0, size(), label));
1233         return subst(ret, '\n', ' ');
1234 #endif
1235 }
1236
1237
1238 string const Paragraph::asString(Buffer const * buffer,
1239                                  pos_type beg, pos_type end, bool label) const
1240 {
1241         ostringstream os;
1242
1243         if (beg == 0 && label && !params().labelString().empty())
1244                 os << params().labelString() << ' ';
1245
1246         for (pos_type i = beg; i < end; ++i) {
1247                 value_type const c = getUChar(buffer->params, i);
1248                 if (IsPrintable(c))
1249                         os << c;
1250                 else if (c == META_INSET)
1251                         getInset(i)->ascii(buffer, os);
1252         }
1253
1254         return STRCONV(os.str());
1255 }
1256
1257
1258 void Paragraph::setInsetOwner(UpdatableInset * inset)
1259 {
1260         pimpl_->inset_owner = inset;
1261         InsetList::iterator it = insetlist.begin();
1262         InsetList::iterator end = insetlist.end();
1263         for (; it != end; ++it)
1264                 if (it->inset)
1265                         it->inset->setOwner(inset);
1266 }
1267
1268
1269 void Paragraph::deleteInsetsLyXText(BufferView * bv)
1270 {
1271         insetlist.deleteInsetsLyXText(bv);
1272 }
1273
1274
1275 void Paragraph::resizeInsetsLyXText(BufferView * bv)
1276 {
1277         insetlist.resizeInsetsLyXText(bv);
1278 }
1279
1280
1281 void Paragraph::setContentsFromPar(Paragraph const & par)
1282 {
1283         pimpl_->setContentsFromPar(par);
1284 }
1285
1286
1287 void Paragraph::trackChanges(Change::Type type)
1288 {
1289         pimpl_->trackChanges(type);
1290 }
1291
1292
1293 void Paragraph::untrackChanges()
1294 {
1295         pimpl_->untrackChanges();
1296 }
1297
1298
1299 void Paragraph::cleanChanges()
1300 {
1301         pimpl_->cleanChanges();
1302 }
1303
1304
1305 Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
1306 {
1307         Assert(!size() || pos < size());
1308         return pimpl_->lookupChange(pos);
1309 }
1310
1311
1312 Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
1313 {
1314         Assert(!size() || pos < size());
1315         return pimpl_->lookupChangeFull(pos);
1316 }
1317
1318
1319 bool Paragraph::isChanged(pos_type start, pos_type end) const
1320 {
1321         return pimpl_->isChanged(start, end);
1322 }
1323
1324
1325 bool Paragraph::isChangeEdited(pos_type start, pos_type end) const
1326 {
1327         return pimpl_->isChangeEdited(start, end);
1328 }
1329
1330
1331 void Paragraph::setChange(lyx::pos_type pos, Change::Type type)
1332 {
1333         pimpl_->setChange(pos, type);
1334
1335 }
1336
1337
1338 void Paragraph::markErased()
1339 {
1340         pimpl_->markErased();
1341 }
1342
1343
1344 void Paragraph::acceptChange(pos_type start, pos_type end)
1345 {
1346         return pimpl_->acceptChange(start, end);
1347 }
1348
1349
1350 void Paragraph::rejectChange(pos_type start, pos_type end)
1351 {
1352         return pimpl_->rejectChange(start, end);
1353 }
1354
1355
1356 lyx::pos_type Paragraph::size() const
1357 {
1358         return pimpl_->size();
1359 }
1360
1361
1362 bool Paragraph::empty() const
1363 {
1364         return pimpl_->empty();
1365 }
1366
1367
1368 Paragraph::value_type Paragraph::getChar(pos_type pos) const
1369 {
1370         return pimpl_->getChar(pos);
1371 }
1372
1373
1374 int Paragraph::id() const
1375 {
1376         return pimpl_->id_;
1377 }
1378
1379
1380 void Paragraph::id(int i)
1381 {
1382         pimpl_->id_ = i;
1383 }
1384
1385
1386 LyXLayout_ptr const & Paragraph::layout() const
1387 {
1388 /*
1389         InsetOld * inset = inInset();
1390         if (inset && inset->lyxCode() == InsetOld::ENVIRONMENT_CODE)
1391                 return static_cast<InsetEnvironment*>(inset)->layout();
1392 */
1393         return layout_;
1394 }
1395
1396
1397 void Paragraph::layout(LyXLayout_ptr const & new_layout)
1398 {
1399         layout_ = new_layout;
1400 }
1401
1402
1403 UpdatableInset * Paragraph::inInset() const
1404 {
1405         return pimpl_->inset_owner;
1406 }
1407
1408
1409 void Paragraph::clearContents()
1410 {
1411         pimpl_->clear();
1412 }
1413
1414 void Paragraph::setChar(pos_type pos, value_type c)
1415 {
1416         pimpl_->setChar(pos, c);
1417 }
1418
1419
1420 ParagraphParameters & Paragraph::params()
1421 {
1422         return pimpl_->params;
1423 }
1424
1425
1426 ParagraphParameters const & Paragraph::params() const
1427 {
1428         return pimpl_->params;
1429 }
1430
1431
1432 bool Paragraph::isFreeSpacing() const
1433 {
1434         if (layout()->free_spacing)
1435                 return true;
1436
1437         // for now we just need this, later should we need this in some
1438         // other way we can always add a function to InsetOld::() too.
1439         if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
1440                 return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE);
1441         return false;
1442 }
1443
1444
1445 bool Paragraph::allowEmpty() const
1446 {
1447         if (layout()->keepempty)
1448                 return true;
1449         if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
1450                 return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE);
1451         return false;
1452 }
1453
1454
1455 bool operator==(Paragraph const & lhs, Paragraph const & rhs)
1456 {
1457 #warning FIXME this implementatoin must be completely wrong...
1458         return &lhs == &rhs;
1459 }