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
 245
 246 void Paragraph::validate(LaTeXFeatures & features) const
 247 {
 248         pimpl_->validate(features, *layout());
 249 }
 250
 251
 252 // First few functions needed for cut and paste and paragraph breaking.
 253 void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const
 254 {
 255         BufferParams bparams = buffer.params;
 256
 257         minibuffer_char = getChar(pos);
 258         minibuffer_font = getFontSettings(bparams, pos);
 259         minibuffer_inset = 0;
 260         if (minibuffer_char == Paragraph::META_INSET) {
 261                 if (getInset(pos)) {
 262                         minibuffer_inset = static_cast<InsetOld *>(getInset(pos)->clone().release());
 263                 } else {
 264                         minibuffer_inset = 0;
 265                         minibuffer_char = ' ';
 266                         // This reflects what GetInset() does (ARRae)
 267                 }
 268         }
 269 }
 270
 271
 272 void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos)
 273 {
 274         minibuffer_char = getChar(pos);
 275         minibuffer_font = getFontSettings(bparams, pos);
 276         minibuffer_inset = 0;
 277         if (minibuffer_char == Paragraph::META_INSET) {
 278                 if (getInset(pos)) {
 279                         // the inset is not in a paragraph anymore
 280                         minibuffer_inset = insetlist.release(pos);
 281                         minibuffer_inset->parOwner(0);
 282                 } else {
 283                         minibuffer_inset = 0;
 284                         minibuffer_char = ' ';
 285                         // This reflects what GetInset() does (ARRae)
 286                 }
 287
 288         }
 289
 290         // Erase(pos); now the caller is responsible for that.
 291 }
 292
 293
 294 bool Paragraph::insertFromMinibuffer(pos_type pos)
 295 {
 296         if (minibuffer_char == Paragraph::META_INSET) {
 297                 if (!insetAllowed(minibuffer_inset->lyxCode())) {
 298                         return false;
 299                 }
 300                 insertInset(pos, minibuffer_inset, minibuffer_font);
 301         } else {
 302                 LyXFont f = minibuffer_font;
 303                 if (!checkInsertChar(f)) {
 304                         return false;
 305                 }
 306                 insertChar(pos, minibuffer_char, f);
 307         }
 308         return true;
 309 }
 310
 311 // end of minibuffer
 312
 313
 314 void Paragraph::eraseIntern(lyx::pos_type pos)
 315 {
 316         pimpl_->eraseIntern(pos);
 317 }
 318
 319
 320 bool Paragraph::erase(pos_type pos)
 321 {
 322         return pimpl_->erase(pos);
 323 }
 324
 325
 326 int Paragraph::erase(pos_type start, pos_type end)
 327 {
 328         return pimpl_->erase(start, end);
 329 }
 330
 331
 332 bool Paragraph::checkInsertChar(LyXFont & font)
 333 {
 334         if (pimpl_->inset_owner)
 335                 return pimpl_->inset_owner->checkInsertChar(font);
 336         return true;
 337 }
 338
 339
 340 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c)
 341 {
 342         LyXFont const f(LyXFont::ALL_INHERIT);
 343         insertChar(pos, c, f);
 344 }
 345
 346
 347 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
 348                            LyXFont const & font, Change change)
 349 {
 350         pimpl_->insertChar(pos, c, font, change);
 351 }
 352
 353
 354 void Paragraph::insertInset(pos_type pos, InsetOld * inset)
 355 {
 356         LyXFont const f(LyXFont::ALL_INHERIT);
 357         insertInset(pos, inset, f);
 358 }
 359
 360
 361 void Paragraph::insertInset(pos_type pos, InsetOld * inset, LyXFont const & font, Change change)
 362 {
 363         pimpl_->insertInset(pos, inset, font, change);
 364 }
 365
 366
 367 bool Paragraph::insetAllowed(InsetOld::Code code)
 368 {
 369         //lyxerr << "Paragraph::InsertInsetAllowed" << endl;
 370         if (pimpl_->inset_owner)
 371                 return pimpl_->inset_owner->insetAllowed(code);
 372         return true;
 373 }
 374
 375
 376 InsetOld * Paragraph::getInset(pos_type pos)
 377 {
 378         Assert(pos < size());
 379         return insetlist.get(pos);
 380 }
 381
 382
 383 InsetOld const * Paragraph::getInset(pos_type pos) const
 384 {
 385         Assert(pos < size());
 386         return insetlist.get(pos);
 387 }
 388
 389
 390 // Gets uninstantiated font setting at position.
 391 LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
 392                                          pos_type pos) const
 393 {
 394         Assert(pos <= size());
 395
 396         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 397         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 398         for (; cit != end; ++cit) {
 399                 if (cit->pos() >= pos)
 400                         break;
 401         }
 402
 403         LyXFont retfont;
 404         if (cit != end)
 405                 retfont = cit->font();
 406         else if (pos == size() && !empty())
 407                 retfont = getFontSettings(bparams, pos - 1);
 408         else
 409                 retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
 410
 411         return retfont;
 412 }
 413
 414 lyx::pos_type
 415 Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
 416 {
 417         Assert(pos <= size());
 418
 419         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 420         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 421         for (; cit != end; ++cit) {
 422                 if (cit->pos() >= pos)
 423                         return cit->pos();
 424         }
 425         // This should not happen, but if so, we take no chances.
 426         return pos;
 427 }
 428
 429
 430 // Gets uninstantiated font setting at position 0
 431 LyXFont const Paragraph::getFirstFontSettings() const
 432 {
 433         if (!empty() && !pimpl_->fontlist.empty())
 434                 return pimpl_->fontlist[0].font();
 435
 436         return LyXFont(LyXFont::ALL_INHERIT);
 437 }
 438
 439
 440 // Gets the fully instantiated font at a given position in a paragraph
 441 // This is basically the same function as LyXText::GetFont() in text2.C.
 442 // The difference is that this one is used for generating the LaTeX file,
 443 // and thus cosmetic "improvements" are disallowed: This has to deliver
 444 // the true picture of the buffer. (Asger)
 445 LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
 446                                  LyXFont const & outerfont) const
 447 {
 448         Assert(pos >= 0);
 449
 450         LyXLayout_ptr const & lout = layout();
 451
 452         pos_type const body_pos = beginningOfBody();
 453
 454         LyXFont layoutfont;
 455         if (pos < body_pos)
 456                 layoutfont = lout->labelfont;
 457         else
 458                 layoutfont = lout->font;
 459
 460         LyXFont tmpfont = getFontSettings(bparams, pos);
 461         tmpfont.realize(layoutfont);
 462         tmpfont.realize(outerfont);
 463
 464         return realizeFont(tmpfont, bparams);
 465 }
 466
 467
 468 LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
 469                                       LyXFont const & outerfont) const
 470 {
 471         LyXLayout_ptr const & lout = layout();
 472
 473         LyXFont tmpfont = lout->labelfont;
 474         tmpfont.setLanguage(getParLanguage(bparams));
 475         tmpfont.realize(outerfont);
 476
 477         return realizeFont(tmpfont, bparams);
 478 }
 479
 480
 481 LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
 482                                        LyXFont const & outerfont) const
 483 {
 484         LyXLayout_ptr const & lout = layout();
 485
 486         LyXFont tmpfont = lout->font;
 487         tmpfont.setLanguage(getParLanguage(bparams));
 488         tmpfont.realize(outerfont);
 489
 490         return realizeFont(tmpfont, bparams);
 491 }
 492
 493
 494 /// Returns the height of the highest font in range
 495 LyXFont::FONT_SIZE
 496 Paragraph::highestFontInRange(pos_type startpos, pos_type endpos,
 497                               LyXFont::FONT_SIZE const def_size) const
 498 {
 499         if (pimpl_->fontlist.empty())
 500                 return def_size;
 501
 502         Pimpl::FontList::const_iterator end_it = pimpl_->fontlist.begin();
 503         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 504         for (; end_it != end; ++end_it) {
 505                 if (end_it->pos() >= endpos)
 506                         break;
 507         }
 508
 509         if (end_it != end)
 510                 ++end_it;
 511
 512         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 513         for (; cit != end; ++cit) {
 514                 if (cit->pos() >= startpos)
 515                         break;
 516         }
 517
 518         LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY;
 519         for (; cit != end_it; ++cit) {
 520                 LyXFont::FONT_SIZE size = cit->font().size();
 521                 if (size == LyXFont::INHERIT_SIZE)
 522                         size = def_size;
 523                 if (size > maxsize && size <= LyXFont::SIZE_HUGER)
 524                         maxsize = size;
 525         }
 526         return maxsize;
 527 }
 528
 529
 530 Paragraph::value_type
 531 Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
 532 {
 533         value_type c = getChar(pos);
 534         if (!lyxrc.rtl_support)
 535                 return c;
 536
 537         value_type uc = c;
 538         switch (c) {
 539         case '(':
 540                 uc = ')';
 541                 break;
 542         case ')':
 543                 uc = '(';
 544                 break;
 545         case '[':
 546                 uc = ']';
 547                 break;
 548         case ']':
 549                 uc = '[';
 550                 break;
 551         case '{':
 552                 uc = '}';
 553                 break;
 554         case '}':
 555                 uc = '{';
 556                 break;
 557         case '<':
 558                 uc = '>';
 559                 break;
 560         case '>':
 561                 uc = '<';
 562                 break;
 563         }
 564         if (uc != c && getFontSettings(bparams, pos).isRightToLeft())
 565                 return uc;
 566         else
 567                 return c;
 568 }
 569
 570
 571 void Paragraph::setFont(pos_type pos, LyXFont const & font)
 572 {
 573         Assert(pos <= size());
 574
 575         // First, reduce font against layout/label font
 576         // Update: The SetCharFont() routine in text2.C already
 577         // reduces font, so we don't need to do that here. (Asger)
 578         // No need to simplify this because it will disappear
 579         // in a new kernel. (Asger)
 580         // Next search font table
 581
 582         Pimpl::FontList::iterator beg = pimpl_->fontlist.begin();
 583         Pimpl::FontList::iterator it = beg;
 584         Pimpl::FontList::iterator endit = pimpl_->fontlist.end();
 585         for (; it != endit; ++it) {
 586                 if (it->pos() >= pos)
 587                         break;
 588         }
 589         unsigned int i = std::distance(beg, it);
 590         bool notfound = (it == endit);
 591
 592         if (!notfound && pimpl_->fontlist[i].font() == font)
 593                 return;
 594
 595         bool begin = pos == 0 || notfound ||
 596                 (i > 0 && pimpl_->fontlist[i - 1].pos() == pos - 1);
 597         // Is position pos is a beginning of a font block?
 598         bool end = !notfound && pimpl_->fontlist[i].pos() == pos;
 599         // Is position pos is the end of a font block?
 600         if (begin && end) { // A single char block
 601                 if (i + 1 < pimpl_->fontlist.size() &&
 602                     pimpl_->fontlist[i + 1].font() == font) {
 603                         // Merge the singleton block with the next block
 604                         pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
 605                         if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
 606                                 pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i - 1);
 607                 } else if (i > 0 && pimpl_->fontlist[i - 1].font() == font) {
 608                         // Merge the singleton block with the previous block
 609                         pimpl_->fontlist[i - 1].pos(pos);
 610                         pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
 611                 } else
 612                         pimpl_->fontlist[i].font(font);
 613         } else if (begin) {
 614                 if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
 615                         pimpl_->fontlist[i - 1].pos(pos);
 616                 else
 617                         pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
 618                                         Pimpl::FontTable(pos, font));
 619         } else if (end) {
 620                 pimpl_->fontlist[i].pos(pos - 1);
 621                 if (!(i + 1 < pimpl_->fontlist.size() &&
 622                       pimpl_->fontlist[i + 1].font() == font))
 623                         pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
 624                                         Pimpl::FontTable(pos, font));
 625         } else { // The general case. The block is splitted into 3 blocks
 626                 pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
 627                                 Pimpl::FontTable(pos - 1, pimpl_->fontlist[i].font()));
 628                 pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
 629                                 Pimpl::FontTable(pos, font));
 630         }
 631 }
 632
 633
 634 void Paragraph::makeSameLayout(Paragraph const & par)
 635 {
 636         layout(par.layout());
 637         // move to pimpl?
 638         params() = par.params();
 639 }
 640
 641
 642 int Paragraph::stripLeadingSpaces()
 643 {
 644         if (isFreeSpacing())
 645                 return 0;
 646
 647         int i = 0;
 648         while (!empty() && (isNewline(0) || isLineSeparator(0))) {
 649                 pimpl_->eraseIntern(0);
 650                 ++i;
 651         }
 652
 653         return i;
 654 }
 655
 656
 657 bool Paragraph::hasSameLayout(Paragraph const & par) const
 658 {
 659         return
 660                 par.layout() == layout() &&
 661                 params().sameLayout(par.params());
 662 }
 663
 664
 665 Paragraph::depth_type Paragraph::getDepth() const
 666 {
 667         return params().depth();
 668 }
 669
 670
 671 Paragraph::depth_type Paragraph::getMaxDepthAfter() const
 672 {
 673         if (layout()->isEnvironment())
 674                 return params().depth() + 1;
 675         else
 676                 return params().depth();
 677 }
 678
 679
 680 char Paragraph::getAlign() const
 681 {
 682         return params().align();
 683 }
 684
 685
 686 string const & Paragraph::getLabelstring() const
 687 {
 688         return params().labelString();
 689 }
 690
 691
 692 // the next two functions are for the manual labels
 693 string const Paragraph::getLabelWidthString() const
 694 {
 695         if (!params().labelWidthString().empty())
 696                 return params().labelWidthString();
 697         else
 698                 return _("Senseless with this layout!");
 699 }
 700
 701
 702 void Paragraph::setLabelWidthString(string const & s)
 703 {
 704         params().labelWidthString(s);
 705 }
 706
 707
 708 void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
 709 {
 710         layout(new_layout);
 711         params().labelWidthString(string());
 712         params().align(LYX_ALIGN_LAYOUT);
 713         params().spaceTop(VSpace(VSpace::NONE));
 714         params().spaceBottom(VSpace(VSpace::NONE));
 715         params().spacing(Spacing(Spacing::Default));
 716 }
 717
 718
 719 int Paragraph::beginningOfBody() const
 720 {
 721         if (layout()->labeltype != LABEL_MANUAL)
 722                 return 0;
 723
 724         // Unroll the first two cycles of the loop
 725         // and remember the previous character to
 726         // remove unnecessary GetChar() calls
 727         pos_type i = 0;
 728         if (i < size() && !isNewline(i)) {
 729                 ++i;
 730                 char previous_char = 0;
 731                 char temp = 0;
 732                 if (i < size()) {
 733                         previous_char = getChar(i);
 734                         if (!isNewline(i)) {
 735                                 ++i;
 736                                 while (i < size() && previous_char != ' ') {
 737                                         temp = getChar(i);
 738                                         if (isNewline(i))
 739                                                 break;
 740
 741                                         ++i;
 742                                         previous_char = temp;
 743                                 }
 744                         }
 745                 }
 746         }
 747
 748         return i;
 749 }
 750
 751
 752 // returns -1 if inset not found
 753 int Paragraph::getPositionOfInset(InsetOld const * inset) const
 754 {
 755         // Find the entry.
 756         InsetList::const_iterator it = insetlist.begin();
 757         InsetList::const_iterator end = insetlist.end();
 758         for (; it != end; ++it)
 759                 if (it->inset == inset)
 760                         return it->pos;
 761         return -1;
 762 }
 763
 764
 765 InsetBibitem * Paragraph::bibitem() const
 766 {
 767         InsetList::const_iterator it = insetlist.begin();
 768         if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE)
 769                 return static_cast<InsetBibitem *>(it->inset);
 770         return 0;
 771 }
 772
 773
 774
 775 // This could go to ParagraphParameters if we want to
 776 int Paragraph::startTeXParParams(BufferParams const & bparams,
 777                                  ostream & os, bool moving_arg) const
 778 {
 779         int column = 0;
 780
 781         if (params().noindent()) {
 782                 os << "\\noindent ";
 783                 column += 10;
 784         }
 785
 786         switch (params().align()) {
 787         case LYX_ALIGN_NONE:
 788         case LYX_ALIGN_BLOCK:
 789         case LYX_ALIGN_LAYOUT:
 790         case LYX_ALIGN_SPECIAL:
 791                 break;
 792         case LYX_ALIGN_LEFT:
 793         case LYX_ALIGN_RIGHT:
 794         case LYX_ALIGN_CENTER:
 795                 if (moving_arg) {
 796                         os << "\\protect";
 797                         column = 8;
 798                 }
 799                 break;
 800         }
 801
 802         switch (params().align()) {
 803         case LYX_ALIGN_NONE:
 804         case LYX_ALIGN_BLOCK:
 805         case LYX_ALIGN_LAYOUT:
 806         case LYX_ALIGN_SPECIAL:
 807                 break;
 808         case LYX_ALIGN_LEFT:
 809                 if (getParLanguage(bparams)->babel() != "hebrew") {
 810                         os << "\\begin{flushleft}";
 811                         column += 17;
 812                 } else {
 813                         os << "\\begin{flushright}";
 814                         column += 18;
 815                 }
 816                 break;
 817         case LYX_ALIGN_RIGHT:
 818                 if (getParLanguage(bparams)->babel() != "hebrew") {
 819                         os << "\\begin{flushright}";
 820                         column += 18;
 821                 } else {
 822                         os << "\\begin{flushleft}";
 823                         column += 17;
 824                 }
 825                 break;
 826         case LYX_ALIGN_CENTER:
 827                 os << "\\begin{center}";
 828                 column += 14;
 829                 break;
 830         }
 831
 832         return column;
 833 }
 834
 835
 836 // This could go to ParagraphParameters if we want to
 837 int Paragraph::endTeXParParams(BufferParams const & bparams,
 838                                ostream & os, bool moving_arg) const
 839 {
 840         int column = 0;
 841
 842         switch (params().align()) {
 843         case LYX_ALIGN_NONE:
 844         case LYX_ALIGN_BLOCK:
 845         case LYX_ALIGN_LAYOUT:
 846         case LYX_ALIGN_SPECIAL:
 847                 break;
 848         case LYX_ALIGN_LEFT:
 849         case LYX_ALIGN_RIGHT:
 850         case LYX_ALIGN_CENTER:
 851                 if (moving_arg) {
 852                         os << "\\protect";
 853                         column = 8;
 854                 }
 855                 break;
 856         }
 857
 858         switch (params().align()) {
 859         case LYX_ALIGN_NONE:
 860         case LYX_ALIGN_BLOCK:
 861         case LYX_ALIGN_LAYOUT:
 862         case LYX_ALIGN_SPECIAL:
 863                 break;
 864         case LYX_ALIGN_LEFT:
 865                 if (getParLanguage(bparams)->babel() != "hebrew") {
 866                         os << "\\end{flushleft}";
 867                         column = 15;
 868                 } else {
 869                         os << "\\end{flushright}";
 870                         column = 16;
 871                 }
 872                 break;
 873         case LYX_ALIGN_RIGHT:
 874                 if (getParLanguage(bparams)->babel() != "hebrew") {
 875                         os << "\\end{flushright}";
 876                         column+= 16;
 877                 } else {
 878                         os << "\\end{flushleft}";
 879                         column = 15;
 880                 }
 881                 break;
 882         case LYX_ALIGN_CENTER:
 883                 os << "\\end{center}";
 884                 column = 12;
 885                 break;
 886         }
 887         return column;
 888 }
 889
 890
 891 // This one spits out the text of the paragraph
 892 bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 893                                 BufferParams const & bparams,
 894                                 LyXFont const & outerfont,
 895                                 ostream & os, TexRow & texrow,
 896                                 LatexRunParams const & runparams)
 897 {
 898         lyxerr[Debug::LATEX] << "SimpleTeXOnePar...     " << this << endl;
 899
 900         bool return_value = false;
 901
 902         LyXLayout_ptr style;
 903
 904         // well we have to check if we are in an inset with unlimited
 905         // lenght (all in one row) if that is true then we don't allow
 906         // any special options in the paragraph and also we don't allow
 907         // any environment other then "Standard" to be valid!
 908         bool asdefault =
 909                 (inInset() && inInset()->forceDefaultParagraphs(inInset()));
 910
 911         if (asdefault) {
 912                 style = bparams.getLyXTextClass().defaultLayout();
 913         } else {
 914                 style = layout();
 915         }
 916
 917         LyXFont basefont;
 918
 919         // Maybe we have to create a optional argument.
 920         pos_type body_pos;
 921
 922         // FIXME: can we actually skip this check and just call
 923         // beginningOfBody() ??
 924         if (style->labeltype != LABEL_MANUAL) {
 925                 body_pos = 0;
 926         } else {
 927                 body_pos = beginningOfBody();
 928         }
 929
 930         unsigned int column = 0;
 931
 932         if (body_pos > 0) {
 933                 os << '[';
 934                 ++column;
 935                 basefont = getLabelFont(bparams, outerfont);
 936         } else {
 937                 basefont = getLayoutFont(bparams, outerfont);
 938         }
 939
 940         bool moving_arg = runparams.moving_arg;
 941         moving_arg |= style->needprotect;
 942
 943         // Which font is currently active?
 944         LyXFont running_font(basefont);
 945         // Do we have an open font change?
 946         bool open_font = false;
 947
 948         Change::Type running_change = Change::UNCHANGED;
 949
 950         texrow.start(id(), 0);
 951
 952         // if the paragraph is empty, the loop will not be entered at all
 953         if (empty()) {
 954                 if (style->isCommand()) {
 955                         os << '{';
 956                         ++column;
 957                 }
 958                 if (!asdefault)
 959                         column += startTeXParParams(bparams, os, moving_arg);
 960
 961         }
 962
 963         for (pos_type i = 0; i < size(); ++i) {
 964                 ++column;
 965                 // First char in paragraph or after label?
 966                 if (i == body_pos) {
 967                         if (body_pos > 0) {
 968                                 if (open_font) {
 969                                         column += running_font.latexWriteEndChanges(os, basefont, basefont);
 970                                         open_font = false;
 971                                 }
 972                                 basefont = getLayoutFont(bparams, outerfont);
 973                                 running_font = basefont;
 974                                 os << ']';
 975                                 ++column;
 976                         }
 977                         if (style->isCommand()) {
 978                                 os << '{';
 979                                 ++column;
 980                         }
 981
 982                         if (!asdefault)
 983                                 column += startTeXParParams(bparams, os,
 984                                                             moving_arg);
 985                 }
 986
 987                 value_type c = getChar(i);
 988
 989                 // Fully instantiated font
 990                 LyXFont font = getFont(bparams, i, outerfont);
 991
 992                 LyXFont const last_font = running_font;
 993
 994                 // Spaces at end of font change are simulated to be
 995                 // outside font change, i.e. we write "\textXX{text} "
 996                 // rather than "\textXX{text }". (Asger)
 997                 if (open_font && c == ' ' && i <= size() - 2) {
 998                         LyXFont const & next_font = getFont(bparams, i + 1, outerfont);
 999                         if (next_font != running_font
1000                             && next_font != font) {
1001                                 font = next_font;
1002                         }
1003                 }
1004
1005                 // We end font definition before blanks
1006                 if (open_font &&
1007                     (font != running_font ||
1008                      font.language() != running_font.language()))
1009                 {
1010                         column += running_font.latexWriteEndChanges(os,
1011                                                                     basefont,
1012                                                                     (i == body_pos-1) ? basefont : font);
1013                         running_font = basefont;
1014                         open_font = false;
1015                 }
1016
1017                 // Blanks are printed before start of fontswitch
1018                 if (c == ' ') {
1019                         // Do not print the separation of the optional argument
1020                         if (i != body_pos - 1) {
1021                                 pimpl_->simpleTeXBlanks(os, texrow, i,
1022                                                        column, font, *style);
1023                         }
1024                 }
1025
1026                 // Do we need to change font?
1027                 if ((font != running_font ||
1028                      font.language() != running_font.language()) &&
1029                         i != body_pos - 1)
1030                 {
1031                         column += font.latexWriteStartChanges(os, basefont,
1032                                                               last_font);
1033                         running_font = font;
1034                         open_font = true;
1035                 }
1036
1037                 Change::Type change = pimpl_->lookupChange(i);
1038
1039                 column += Changes::latexMarkChange(os, running_change, change);
1040                 running_change = change;
1041
1042                 LatexRunParams rp = runparams;
1043                 rp.moving_arg = moving_arg;
1044                 rp.free_spacing = style->free_spacing;
1045                 pimpl_->simpleTeXSpecialChars(buf, bparams,
1046                                               os, texrow, runparams,
1047                                               font, running_font,
1048                                               basefont, outerfont, open_font,
1049                                               running_change,
1050                                               *style, i, column, c);
1051         }
1052
1053         column += Changes::latexMarkChange(os,
1054                         running_change, Change::UNCHANGED);
1055
1056         // If we have an open font definition, we have to close it
1057         if (open_font) {
1058 #ifdef FIXED_LANGUAGE_END_DETECTION
1059                 if (next_) {
1060                         running_font
1061                                 .latexWriteEndChanges(os, basefont,
1062                                                       next_->getFont(bparams,
1063                                                       0, outerfont));
1064                 } else {
1065                         running_font.latexWriteEndChanges(os, basefont,
1066                                                           basefont);
1067                 }
1068 #else
1069 #ifdef WITH_WARNINGS
1070 //#warning For now we ALWAYS have to close the foreign font settings if they are
1071 //#warning there as we start another \selectlanguage with the next paragraph if
1072 //#warning we are in need of this. This should be fixed sometime (Jug)
1073 #endif
1074                 running_font.latexWriteEndChanges(os, basefont,  basefont);
1075 #endif
1076         }
1077
1078         // Needed if there is an optional argument but no contents.
1079         if (body_pos > 0 && body_pos == size()) {
1080                 os << "]~";
1081                 return_value = false;
1082         }
1083
1084         if (!asdefault) {
1085                 column += endTeXParParams(bparams, os, moving_arg);
1086         }
1087
1088         lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl;
1089         return return_value;
1090 }
1091
1092
1093
1094
1095 bool Paragraph::isHfill(pos_type pos) const
1096 {
1097         return IsInsetChar(getChar(pos))
1098                && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE;
1099 }
1100
1101
1102 bool Paragraph::isInset(pos_type pos) const
1103 {
1104         return IsInsetChar(getChar(pos));
1105 }
1106
1107
1108 bool Paragraph::isNewline(pos_type pos) const
1109 {
1110         return IsInsetChar(getChar(pos))
1111                && getInset(pos)->lyxCode() == InsetOld::NEWLINE_CODE;
1112 }
1113
1114
1115 bool Paragraph::isSeparator(pos_type pos) const
1116 {
1117         return IsSeparatorChar(getChar(pos));
1118 }
1119
1120
1121 bool Paragraph::isLineSeparator(pos_type pos) const
1122 {
1123         value_type const c = getChar(pos);
1124         return IsLineSeparatorChar(c)
1125                 || (IsInsetChar(c) && getInset(pos) &&
1126                 getInset(pos)->isLineSeparator());
1127 }
1128
1129
1130 bool Paragraph::isKomma(pos_type pos) const
1131 {
1132         return IsKommaChar(getChar(pos));
1133 }
1134
1135
1136 /// Used by the spellchecker
1137 bool Paragraph::isLetter(pos_type pos) const
1138 {
1139         value_type const c = getChar(pos);
1140         if (IsLetterChar(c))
1141                 return true;
1142         if (isInset(pos))
1143                 return getInset(pos)->isLetter();
1144         // We want to pass the ' and escape chars to ispell
1145         string const extra = lyxrc.isp_esc_chars + '\'';
1146         return contains(extra, c);
1147 }
1148
1149
1150 bool Paragraph::isWord(pos_type pos) const
1151 {
1152         return IsWordChar(getChar(pos)) ;
1153 }
1154
1155
1156 Language const *
1157 Paragraph::getParLanguage(BufferParams const & bparams) const
1158 {
1159         if (!empty()) {
1160                 return getFirstFontSettings().language();
1161 #warning FIXME we should check the prev par as well (Lgb)
1162 #if 0
1163         } else if (previous_) {
1164                 return previous_->getParLanguage(bparams);
1165 #endif
1166         }else
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 }