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\\begin_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
 293 bool Paragraph::insertFromMinibuffer(pos_type pos)
 294 {
 295         if (minibuffer_char == Paragraph::META_INSET) {
 296                 if (!insetAllowed(minibuffer_inset->lyxCode()))
 297                         return false;
 298                 insertInset(pos, minibuffer_inset, minibuffer_font);
 299         } else {
 300                 LyXFont f = minibuffer_font;
 301                 if (!checkInsertChar(f))
 302                         return false;
 303                 insertChar(pos, minibuffer_char, f);
 304         }
 305         return true;
 306 }
 307
 308 // end of minibuffer
 309
 310
 311 void Paragraph::eraseIntern(lyx::pos_type pos)
 312 {
 313         pimpl_->eraseIntern(pos);
 314 }
 315
 316
 317 bool Paragraph::erase(pos_type pos)
 318 {
 319         return pimpl_->erase(pos);
 320 }
 321
 322
 323 int Paragraph::erase(pos_type start, pos_type end)
 324 {
 325         return pimpl_->erase(start, end);
 326 }
 327
 328
 329 bool Paragraph::checkInsertChar(LyXFont & font)
 330 {
 331         if (pimpl_->inset_owner)
 332                 return pimpl_->inset_owner->checkInsertChar(font);
 333         return true;
 334 }
 335
 336
 337 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c)
 338 {
 339         insertChar(pos, c, LyXFont(LyXFont::ALL_INHERIT));
 340 }
 341
 342
 343 void Paragraph::insertChar(pos_type pos, Paragraph::value_type c,
 344                            LyXFont const & font, Change change)
 345 {
 346         pimpl_->insertChar(pos, c, font, change);
 347 }
 348
 349
 350 void Paragraph::insertInset(pos_type pos, InsetOld * inset)
 351 {
 352         insertInset(pos, inset, LyXFont(LyXFont::ALL_INHERIT));
 353 }
 354
 355
 356 void Paragraph::insertInset(pos_type pos, InsetOld * inset, LyXFont const & font, Change change)
 357 {
 358         pimpl_->insertInset(pos, inset, font, change);
 359 }
 360
 361
 362 bool Paragraph::insetAllowed(InsetOld::Code code)
 363 {
 364         //lyxerr << "Paragraph::InsertInsetAllowed" << endl;
 365         if (pimpl_->inset_owner)
 366                 return pimpl_->inset_owner->insetAllowed(code);
 367         return true;
 368 }
 369
 370
 371 InsetOld * Paragraph::getInset(pos_type pos)
 372 {
 373         Assert(pos < size());
 374         return insetlist.get(pos);
 375 }
 376
 377
 378 InsetOld const * Paragraph::getInset(pos_type pos) const
 379 {
 380         Assert(pos < size());
 381         return insetlist.get(pos);
 382 }
 383
 384
 385 // Gets uninstantiated font setting at position.
 386 LyXFont const Paragraph::getFontSettings(BufferParams const & bparams,
 387                                          pos_type pos) const
 388 {
 389         Assert(pos <= size());
 390
 391         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 392         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 393         for (; cit != end; ++cit)
 394                 if (cit->pos() >= pos)
 395                         break;
 396
 397         if (cit != end)
 398                 return cit->font();
 399
 400         if (pos == size() && !empty())
 401                 return getFontSettings(bparams, pos - 1);
 402
 403         return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams));
 404 }
 405
 406
 407 lyx::pos_type
 408 Paragraph::getEndPosOfFontSpan(lyx::pos_type pos) const
 409 {
 410         Assert(pos <= size());
 411
 412         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 413         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 414         for (; cit != end; ++cit)
 415                 if (cit->pos() >= pos)
 416                         return cit->pos();
 417
 418         // This should not happen, but if so, we take no chances.
 419         lyxerr << "Pararaph::getEndPosOfFontSpan: This should not happen!\n";
 420         return pos;
 421 }
 422
 423
 424 // Gets uninstantiated font setting at position 0
 425 LyXFont const Paragraph::getFirstFontSettings() const
 426 {
 427         if (!empty() && !pimpl_->fontlist.empty())
 428                 return pimpl_->fontlist[0].font();
 429
 430         return LyXFont(LyXFont::ALL_INHERIT);
 431 }
 432
 433
 434 // Gets the fully instantiated font at a given position in a paragraph
 435 // This is basically the same function as LyXText::GetFont() in text2.C.
 436 // The difference is that this one is used for generating the LaTeX file,
 437 // and thus cosmetic "improvements" are disallowed: This has to deliver
 438 // the true picture of the buffer. (Asger)
 439 LyXFont const Paragraph::getFont(BufferParams const & bparams, pos_type pos,
 440                                  LyXFont const & outerfont) const
 441 {
 442         Assert(pos >= 0);
 443
 444         LyXLayout_ptr const & lout = layout();
 445
 446         pos_type const body_pos = beginningOfBody();
 447
 448         LyXFont layoutfont;
 449         if (pos < body_pos)
 450                 layoutfont = lout->labelfont;
 451         else
 452                 layoutfont = lout->font;
 453
 454         LyXFont tmpfont = getFontSettings(bparams, pos);
 455         tmpfont.realize(layoutfont);
 456         tmpfont.realize(outerfont);
 457         tmpfont.realize(bparams.getLyXTextClass().defaultfont());
 458
 459         return tmpfont;
 460 }
 461
 462
 463 LyXFont const Paragraph::getLabelFont(BufferParams const & bparams,
 464                                       LyXFont const & outerfont) const
 465 {
 466         LyXFont tmpfont = layout()->labelfont;
 467         tmpfont.setLanguage(getParLanguage(bparams));
 468         tmpfont.realize(outerfont);
 469         tmpfont.realize(bparams.getLyXTextClass().defaultfont());
 470         return tmpfont;
 471 }
 472
 473
 474 LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams,
 475                                        LyXFont const & outerfont) const
 476 {
 477         LyXFont tmpfont = layout()->font;
 478         tmpfont.setLanguage(getParLanguage(bparams));
 479         tmpfont.realize(outerfont);
 480         tmpfont.realize(bparams.getLyXTextClass().defaultfont());
 481         return tmpfont;
 482 }
 483
 484
 485 /// Returns the height of the highest font in range
 486 LyXFont::FONT_SIZE
 487 Paragraph::highestFontInRange(pos_type startpos, pos_type endpos,
 488                               LyXFont::FONT_SIZE const def_size) const
 489 {
 490         if (pimpl_->fontlist.empty())
 491                 return def_size;
 492
 493         Pimpl::FontList::const_iterator end_it = pimpl_->fontlist.begin();
 494         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
 495         for (; end_it != end; ++end_it) {
 496                 if (end_it->pos() >= endpos)
 497                         break;
 498         }
 499
 500         if (end_it != end)
 501                 ++end_it;
 502
 503         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
 504         for (; cit != end; ++cit) {
 505                 if (cit->pos() >= startpos)
 506                         break;
 507         }
 508
 509         LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY;
 510         for (; cit != end_it; ++cit) {
 511                 LyXFont::FONT_SIZE size = cit->font().size();
 512                 if (size == LyXFont::INHERIT_SIZE)
 513                         size = def_size;
 514                 if (size > maxsize && size <= LyXFont::SIZE_HUGER)
 515                         maxsize = size;
 516         }
 517         return maxsize;
 518 }
 519
 520
 521 Paragraph::value_type
 522 Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const
 523 {
 524         value_type c = getChar(pos);
 525         if (!lyxrc.rtl_support)
 526                 return c;
 527
 528         value_type uc = c;
 529         switch (c) {
 530         case '(':
 531                 uc = ')';
 532                 break;
 533         case ')':
 534                 uc = '(';
 535                 break;
 536         case '[':
 537                 uc = ']';
 538                 break;
 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         }
 555         if (uc != c && getFontSettings(bparams, pos).isRightToLeft())
 556                 return uc;
 557         else
 558                 return c;
 559 }
 560
 561
 562 void Paragraph::setFont(pos_type pos, LyXFont const & font)
 563 {
 564         Assert(pos <= size());
 565
 566         // First, reduce font against layout/label font
 567         // Update: The SetCharFont() routine in text2.C already
 568         // reduces font, so we don't need to do that here. (Asger)
 569         // No need to simplify this because it will disappear
 570         // in a new kernel. (Asger)
 571         // Next search font table
 572
 573         Pimpl::FontList::iterator beg = pimpl_->fontlist.begin();
 574         Pimpl::FontList::iterator it = beg;
 575         Pimpl::FontList::iterator endit = pimpl_->fontlist.end();
 576         for (; it != endit; ++it) {
 577                 if (it->pos() >= pos)
 578                         break;
 579         }
 580         unsigned int i = std::distance(beg, it);
 581         bool notfound = (it == endit);
 582
 583         if (!notfound && pimpl_->fontlist[i].font() == font)
 584                 return;
 585
 586         bool begin = pos == 0 || notfound ||
 587                 (i > 0 && pimpl_->fontlist[i - 1].pos() == pos - 1);
 588         // Is position pos is a beginning of a font block?
 589         bool end = !notfound && pimpl_->fontlist[i].pos() == pos;
 590         // Is position pos is the end of a font block?
 591         if (begin && end) { // A single char block
 592                 if (i + 1 < pimpl_->fontlist.size() &&
 593                     pimpl_->fontlist[i + 1].font() == font) {
 594                         // Merge the singleton block with the next block
 595                         pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
 596                         if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
 597                                 pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i - 1);
 598                 } else if (i > 0 && pimpl_->fontlist[i - 1].font() == font) {
 599                         // Merge the singleton block with the previous block
 600                         pimpl_->fontlist[i - 1].pos(pos);
 601                         pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i);
 602                 } else
 603                         pimpl_->fontlist[i].font(font);
 604         } else if (begin) {
 605                 if (i > 0 && pimpl_->fontlist[i - 1].font() == font)
 606                         pimpl_->fontlist[i - 1].pos(pos);
 607                 else
 608                         pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
 609                                         Pimpl::FontTable(pos, font));
 610         } else if (end) {
 611                 pimpl_->fontlist[i].pos(pos - 1);
 612                 if (!(i + 1 < pimpl_->fontlist.size() &&
 613                       pimpl_->fontlist[i + 1].font() == font))
 614                         pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
 615                                         Pimpl::FontTable(pos, font));
 616         } else { // The general case. The block is splitted into 3 blocks
 617                 pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i,
 618                                 Pimpl::FontTable(pos - 1, pimpl_->fontlist[i].font()));
 619                 pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1,
 620                                 Pimpl::FontTable(pos, font));
 621         }
 622 }
 623
 624
 625 void Paragraph::makeSameLayout(Paragraph const & par)
 626 {
 627         layout(par.layout());
 628         // move to pimpl?
 629         params() = par.params();
 630 }
 631
 632
 633 int Paragraph::stripLeadingSpaces()
 634 {
 635         if (isFreeSpacing())
 636                 return 0;
 637
 638         int i = 0;
 639         while (!empty() && (isNewline(0) || isLineSeparator(0))) {
 640                 pimpl_->eraseIntern(0);
 641                 ++i;
 642         }
 643
 644         return i;
 645 }
 646
 647
 648 bool Paragraph::hasSameLayout(Paragraph const & par) const
 649 {
 650         return
 651                 par.layout() == layout() &&
 652                 params().sameLayout(par.params());
 653 }
 654
 655
 656 Paragraph::depth_type Paragraph::getDepth() const
 657 {
 658         return params().depth();
 659 }
 660
 661
 662 Paragraph::depth_type Paragraph::getMaxDepthAfter() const
 663 {
 664         if (layout()->isEnvironment())
 665                 return params().depth() + 1;
 666         else
 667                 return params().depth();
 668 }
 669
 670
 671 char Paragraph::getAlign() const
 672 {
 673         return params().align();
 674 }
 675
 676
 677 string const & Paragraph::getLabelstring() const
 678 {
 679         return params().labelString();
 680 }
 681
 682
 683 // the next two functions are for the manual labels
 684 string const Paragraph::getLabelWidthString() const
 685 {
 686         if (!params().labelWidthString().empty())
 687                 return params().labelWidthString();
 688         else
 689                 return _("Senseless with this layout!");
 690 }
 691
 692
 693 void Paragraph::setLabelWidthString(string const & s)
 694 {
 695         params().labelWidthString(s);
 696 }
 697
 698
 699 void Paragraph::applyLayout(LyXLayout_ptr const & new_layout)
 700 {
 701         layout(new_layout);
 702         params().labelWidthString(string());
 703         params().align(LYX_ALIGN_LAYOUT);
 704         params().spaceTop(VSpace(VSpace::NONE));
 705         params().spaceBottom(VSpace(VSpace::NONE));
 706         params().spacing(Spacing(Spacing::Default));
 707 }
 708
 709
 710 int Paragraph::beginningOfBody() const
 711 {
 712         if (layout()->labeltype != LABEL_MANUAL)
 713                 return 0;
 714
 715         // Unroll the first two cycles of the loop
 716         // and remember the previous character to
 717         // remove unnecessary GetChar() calls
 718         pos_type i = 0;
 719         if (i < size() && !isNewline(i)) {
 720                 ++i;
 721                 char previous_char = 0;
 722                 char temp = 0;
 723                 if (i < size()) {
 724                         previous_char = getChar(i);
 725                         if (!isNewline(i)) {
 726                                 ++i;
 727                                 while (i < size() && previous_char != ' ') {
 728                                         temp = getChar(i);
 729                                         if (isNewline(i))
 730                                                 break;
 731
 732                                         ++i;
 733                                         previous_char = temp;
 734                                 }
 735                         }
 736                 }
 737         }
 738
 739         return i;
 740 }
 741
 742
 743 // returns -1 if inset not found
 744 int Paragraph::getPositionOfInset(InsetOld const * inset) const
 745 {
 746         // Find the entry.
 747         InsetList::const_iterator it = insetlist.begin();
 748         InsetList::const_iterator end = insetlist.end();
 749         for (; it != end; ++it)
 750                 if (it->inset == inset)
 751                         return it->pos;
 752         return -1;
 753 }
 754
 755
 756 InsetBibitem * Paragraph::bibitem() const
 757 {
 758         InsetList::const_iterator it = insetlist.begin();
 759         if (it != insetlist.end() && it->inset->lyxCode() == InsetOld::BIBTEX_CODE)
 760                 return static_cast<InsetBibitem *>(it->inset);
 761         return 0;
 762 }
 763
 764
 765
 766 // This could go to ParagraphParameters if we want to
 767 int Paragraph::startTeXParParams(BufferParams const & bparams,
 768                                  ostream & os, bool moving_arg) const
 769 {
 770         int column = 0;
 771
 772         if (params().noindent()) {
 773                 os << "\\noindent ";
 774                 column += 10;
 775         }
 776
 777         switch (params().align()) {
 778         case LYX_ALIGN_NONE:
 779         case LYX_ALIGN_BLOCK:
 780         case LYX_ALIGN_LAYOUT:
 781         case LYX_ALIGN_SPECIAL:
 782                 break;
 783         case LYX_ALIGN_LEFT:
 784         case LYX_ALIGN_RIGHT:
 785         case LYX_ALIGN_CENTER:
 786                 if (moving_arg) {
 787                         os << "\\protect";
 788                         column = 8;
 789                 }
 790                 break;
 791         }
 792
 793         switch (params().align()) {
 794         case LYX_ALIGN_NONE:
 795         case LYX_ALIGN_BLOCK:
 796         case LYX_ALIGN_LAYOUT:
 797         case LYX_ALIGN_SPECIAL:
 798                 break;
 799         case LYX_ALIGN_LEFT:
 800                 if (getParLanguage(bparams)->babel() != "hebrew") {
 801                         os << "\\begin{flushleft}";
 802                         column += 17;
 803                 } else {
 804                         os << "\\begin{flushright}";
 805                         column += 18;
 806                 }
 807                 break;
 808         case LYX_ALIGN_RIGHT:
 809                 if (getParLanguage(bparams)->babel() != "hebrew") {
 810                         os << "\\begin{flushright}";
 811                         column += 18;
 812                 } else {
 813                         os << "\\begin{flushleft}";
 814                         column += 17;
 815                 }
 816                 break;
 817         case LYX_ALIGN_CENTER:
 818                 os << "\\begin{center}";
 819                 column += 14;
 820                 break;
 821         }
 822
 823         return column;
 824 }
 825
 826
 827 // This could go to ParagraphParameters if we want to
 828 int Paragraph::endTeXParParams(BufferParams const & bparams,
 829                                ostream & os, bool moving_arg) const
 830 {
 831         int column = 0;
 832
 833         switch (params().align()) {
 834         case LYX_ALIGN_NONE:
 835         case LYX_ALIGN_BLOCK:
 836         case LYX_ALIGN_LAYOUT:
 837         case LYX_ALIGN_SPECIAL:
 838                 break;
 839         case LYX_ALIGN_LEFT:
 840         case LYX_ALIGN_RIGHT:
 841         case LYX_ALIGN_CENTER:
 842                 if (moving_arg) {
 843                         os << "\\protect";
 844                         column = 8;
 845                 }
 846                 break;
 847         }
 848
 849         switch (params().align()) {
 850         case LYX_ALIGN_NONE:
 851         case LYX_ALIGN_BLOCK:
 852         case LYX_ALIGN_LAYOUT:
 853         case LYX_ALIGN_SPECIAL:
 854                 break;
 855         case LYX_ALIGN_LEFT:
 856                 if (getParLanguage(bparams)->babel() != "hebrew") {
 857                         os << "\\end{flushleft}";
 858                         column = 15;
 859                 } else {
 860                         os << "\\end{flushright}";
 861                         column = 16;
 862                 }
 863                 break;
 864         case LYX_ALIGN_RIGHT:
 865                 if (getParLanguage(bparams)->babel() != "hebrew") {
 866                         os << "\\end{flushright}";
 867                         column+= 16;
 868                 } else {
 869                         os << "\\end{flushleft}";
 870                         column = 15;
 871                 }
 872                 break;
 873         case LYX_ALIGN_CENTER:
 874                 os << "\\end{center}";
 875                 column = 12;
 876                 break;
 877         }
 878         return column;
 879 }
 880
 881
 882 // This one spits out the text of the paragraph
 883 bool Paragraph::simpleTeXOnePar(Buffer const * buf,
 884                                 BufferParams const & bparams,
 885                                 LyXFont const & outerfont,
 886                                 ostream & os, TexRow & texrow,
 887                                 LatexRunParams const & runparams)
 888 {
 889         lyxerr[Debug::LATEX] << "SimpleTeXOnePar...     " << this << endl;
 890
 891         bool return_value = false;
 892
 893         LyXLayout_ptr style;
 894
 895         // well we have to check if we are in an inset with unlimited
 896         // lenght (all in one row) if that is true then we don't allow
 897         // any special options in the paragraph and also we don't allow
 898         // any environment other then "Standard" to be valid!
 899         bool asdefault =
 900                 (inInset() && inInset()->forceDefaultParagraphs(inInset()));
 901
 902         if (asdefault) {
 903                 style = bparams.getLyXTextClass().defaultLayout();
 904         } else {
 905                 style = layout();
 906         }
 907
 908         LyXFont basefont;
 909
 910         // Maybe we have to create a optional argument.
 911         pos_type body_pos;
 912
 913         // FIXME: can we actually skip this check and just call
 914         // beginningOfBody() ??
 915         if (style->labeltype != LABEL_MANUAL) {
 916                 body_pos = 0;
 917         } else {
 918                 body_pos = beginningOfBody();
 919         }
 920
 921         unsigned int column = 0;
 922
 923         if (body_pos > 0) {
 924                 os << '[';
 925                 ++column;
 926                 basefont = getLabelFont(bparams, outerfont);
 927         } else {
 928                 basefont = getLayoutFont(bparams, outerfont);
 929         }
 930
 931         bool moving_arg = runparams.moving_arg;
 932         moving_arg |= style->needprotect;
 933
 934         // Which font is currently active?
 935         LyXFont running_font(basefont);
 936         // Do we have an open font change?
 937         bool open_font = false;
 938
 939         Change::Type running_change = Change::UNCHANGED;
 940
 941         texrow.start(id(), 0);
 942
 943         // if the paragraph is empty, the loop will not be entered at all
 944         if (empty()) {
 945                 if (style->isCommand()) {
 946                         os << '{';
 947                         ++column;
 948                 }
 949                 if (!asdefault)
 950                         column += startTeXParParams(bparams, os, moving_arg);
 951
 952         }
 953
 954         for (pos_type i = 0; i < size(); ++i) {
 955                 ++column;
 956                 // First char in paragraph or after label?
 957                 if (i == body_pos) {
 958                         if (body_pos > 0) {
 959                                 if (open_font) {
 960                                         column += running_font.latexWriteEndChanges(os, basefont, basefont);
 961                                         open_font = false;
 962                                 }
 963                                 basefont = getLayoutFont(bparams, outerfont);
 964                                 running_font = basefont;
 965                                 os << ']';
 966                                 ++column;
 967                         }
 968                         if (style->isCommand()) {
 969                                 os << '{';
 970                                 ++column;
 971                         }
 972
 973                         if (!asdefault)
 974                                 column += startTeXParParams(bparams, os,
 975                                                             moving_arg);
 976                 }
 977
 978                 value_type c = getChar(i);
 979
 980                 // Fully instantiated font
 981                 LyXFont font = getFont(bparams, i, outerfont);
 982
 983                 LyXFont const last_font = running_font;
 984
 985                 // Spaces at end of font change are simulated to be
 986                 // outside font change, i.e. we write "\textXX{text} "
 987                 // rather than "\textXX{text }". (Asger)
 988                 if (open_font && c == ' ' && i <= size() - 2) {
 989                         LyXFont const & next_font = getFont(bparams, i + 1, outerfont);
 990                         if (next_font != running_font
 991                             && next_font != font) {
 992                                 font = next_font;
 993                         }
 994                 }
 995
 996                 // We end font definition before blanks
 997                 if (open_font &&
 998                     (font != running_font ||
 999                      font.language() != running_font.language()))
1000                 {
1001                         column += running_font.latexWriteEndChanges(os,
1002                                                                     basefont,
1003                                                                     (i == body_pos-1) ? basefont : font);
1004                         running_font = basefont;
1005                         open_font = false;
1006                 }
1007
1008                 // Blanks are printed before start of fontswitch
1009                 if (c == ' ') {
1010                         // Do not print the separation of the optional argument
1011                         if (i != body_pos - 1) {
1012                                 pimpl_->simpleTeXBlanks(os, texrow, i,
1013                                                        column, font, *style);
1014                         }
1015                 }
1016
1017                 // Do we need to change font?
1018                 if ((font != running_font ||
1019                      font.language() != running_font.language()) &&
1020                         i != body_pos - 1)
1021                 {
1022                         column += font.latexWriteStartChanges(os, basefont,
1023                                                               last_font);
1024                         running_font = font;
1025                         open_font = true;
1026                 }
1027
1028                 Change::Type change = pimpl_->lookupChange(i);
1029
1030                 column += Changes::latexMarkChange(os, running_change, change);
1031                 running_change = change;
1032
1033                 LatexRunParams rp = runparams;
1034                 rp.moving_arg = moving_arg;
1035                 rp.free_spacing = style->free_spacing;
1036                 pimpl_->simpleTeXSpecialChars(buf, bparams,
1037                                               os, texrow, runparams,
1038                                               font, running_font,
1039                                               basefont, outerfont, open_font,
1040                                               running_change,
1041                                               *style, i, column, c);
1042         }
1043
1044         column += Changes::latexMarkChange(os,
1045                         running_change, Change::UNCHANGED);
1046
1047         // If we have an open font definition, we have to close it
1048         if (open_font) {
1049 #ifdef FIXED_LANGUAGE_END_DETECTION
1050                 if (next_) {
1051                         running_font
1052                                 .latexWriteEndChanges(os, basefont,
1053                                                       next_->getFont(bparams,
1054                                                       0, outerfont));
1055                 } else {
1056                         running_font.latexWriteEndChanges(os, basefont,
1057                                                           basefont);
1058                 }
1059 #else
1060 #ifdef WITH_WARNINGS
1061 //#warning For now we ALWAYS have to close the foreign font settings if they are
1062 //#warning there as we start another \selectlanguage with the next paragraph if
1063 //#warning we are in need of this. This should be fixed sometime (Jug)
1064 #endif
1065                 running_font.latexWriteEndChanges(os, basefont,  basefont);
1066 #endif
1067         }
1068
1069         // Needed if there is an optional argument but no contents.
1070         if (body_pos > 0 && body_pos == size()) {
1071                 os << "]~";
1072                 return_value = false;
1073         }
1074
1075         if (!asdefault) {
1076                 column += endTeXParParams(bparams, os, moving_arg);
1077         }
1078
1079         lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl;
1080         return return_value;
1081 }
1082
1083
1084
1085
1086 bool Paragraph::isHfill(pos_type pos) const
1087 {
1088         return IsInsetChar(getChar(pos))
1089                && getInset(pos)->lyxCode() == InsetOld::HFILL_CODE;
1090 }
1091
1092
1093 bool Paragraph::isInset(pos_type pos) const
1094 {
1095         return IsInsetChar(getChar(pos));
1096 }
1097
1098
1099 bool Paragraph::isNewline(pos_type pos) const
1100 {
1101         return IsInsetChar(getChar(pos))
1102                && getInset(pos)->lyxCode() == InsetOld::NEWLINE_CODE;
1103 }
1104
1105
1106 bool Paragraph::isSeparator(pos_type pos) const
1107 {
1108         return IsSeparatorChar(getChar(pos));
1109 }
1110
1111
1112 bool Paragraph::isLineSeparator(pos_type pos) const
1113 {
1114         value_type const c = getChar(pos);
1115         return IsLineSeparatorChar(c)
1116                 || (IsInsetChar(c) && getInset(pos) &&
1117                 getInset(pos)->isLineSeparator());
1118 }
1119
1120
1121 bool Paragraph::isKomma(pos_type pos) const
1122 {
1123         return IsKommaChar(getChar(pos));
1124 }
1125
1126
1127 /// Used by the spellchecker
1128 bool Paragraph::isLetter(pos_type pos) const
1129 {
1130         value_type const c = getChar(pos);
1131         if (IsLetterChar(c))
1132                 return true;
1133         if (isInset(pos))
1134                 return getInset(pos)->isLetter();
1135         // We want to pass the ' and escape chars to ispell
1136         string const extra = lyxrc.isp_esc_chars + '\'';
1137         return contains(extra, c);
1138 }
1139
1140
1141 bool Paragraph::isWord(pos_type pos) const
1142 {
1143         return IsWordChar(getChar(pos)) ;
1144 }
1145
1146
1147 Language const *
1148 Paragraph::getParLanguage(BufferParams const & bparams) const
1149 {
1150         if (!empty())
1151                 return getFirstFontSettings().language();
1152 #warning FIXME we should check the prev par as well (Lgb)
1153         return bparams.language;
1154 }
1155
1156
1157 bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const
1158 {
1159         return lyxrc.rtl_support
1160                 && getParLanguage(bparams)->RightToLeft()
1161                 && !(inInset() && inInset()->owner() &&
1162                      inInset()->owner()->lyxCode() == InsetOld::ERT_CODE);
1163 }
1164
1165
1166 void Paragraph::changeLanguage(BufferParams const & bparams,
1167                                Language const * from, Language const * to)
1168 {
1169         for (pos_type i = 0; i < size(); ++i) {
1170                 LyXFont font = getFontSettings(bparams, i);
1171                 if (font.language() == from) {
1172                         font.setLanguage(to);
1173                         setFont(i, font);
1174                 }
1175         }
1176 }
1177
1178
1179 bool Paragraph::isMultiLingual(BufferParams const & bparams)
1180 {
1181         Language const * doc_language = bparams.language;
1182         Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin();
1183         Pimpl::FontList::const_iterator end = pimpl_->fontlist.end();
1184
1185         for (; cit != end; ++cit)
1186                 if (cit->font().language() != ignore_language &&
1187                     cit->font().language() != latex_language &&
1188                         cit->font().language() != doc_language)
1189                         return true;
1190         return false;
1191 }
1192
1193
1194 // Convert the paragraph to a string.
1195 // Used for building the table of contents
1196 string const Paragraph::asString(Buffer const * buffer, bool label) const
1197 {
1198 #if 0
1199         string s;
1200         if (label && !params().labelString().empty())
1201                 s += params().labelString() + ' ';
1202
1203         for (pos_type i = 0; i < size(); ++i) {
1204                 value_type c = getChar(i);
1205                 if (IsPrintable(c))
1206                         s += c;
1207                 else if (c == META_INSET &&
1208                          getInset(i)->lyxCode() == InsetOld::MATH_CODE) {
1209                         ostringstream ost;
1210                         getInset(i)->ascii(buffer, ost);
1211                         s += subst(STRCONV(ost.str()),'\n',' ');
1212                 }
1213         }
1214
1215         return s;
1216 #else
1217         // This should really be done by the caller and not here.
1218         string ret(asString(buffer, 0, size(), label));
1219         return subst(ret, '\n', ' ');
1220 #endif
1221 }
1222
1223
1224 string const Paragraph::asString(Buffer const * buffer,
1225                                  pos_type beg, pos_type end, bool label) const
1226 {
1227         ostringstream os;
1228
1229         if (beg == 0 && label && !params().labelString().empty())
1230                 os << params().labelString() << ' ';
1231
1232         for (pos_type i = beg; i < end; ++i) {
1233                 value_type const c = getUChar(buffer->params, i);
1234                 if (IsPrintable(c))
1235                         os << c;
1236                 else if (c == META_INSET)
1237                         getInset(i)->ascii(buffer, os);
1238         }
1239
1240         return STRCONV(os.str());
1241 }
1242
1243
1244 void Paragraph::setInsetOwner(UpdatableInset * inset)
1245 {
1246         pimpl_->inset_owner = inset;
1247         InsetList::iterator it = insetlist.begin();
1248         InsetList::iterator end = insetlist.end();
1249         for (; it != end; ++it)
1250                 if (it->inset)
1251                         it->inset->setOwner(inset);
1252 }
1253
1254
1255 void Paragraph::deleteInsetsLyXText(BufferView * bv)
1256 {
1257         insetlist.deleteInsetsLyXText(bv);
1258 }
1259
1260
1261 void Paragraph::resizeInsetsLyXText(BufferView * bv)
1262 {
1263         insetlist.resizeInsetsLyXText(bv);
1264 }
1265
1266
1267 void Paragraph::setContentsFromPar(Paragraph const & par)
1268 {
1269         pimpl_->setContentsFromPar(par);
1270 }
1271
1272
1273 void Paragraph::trackChanges(Change::Type type)
1274 {
1275         pimpl_->trackChanges(type);
1276 }
1277
1278
1279 void Paragraph::untrackChanges()
1280 {
1281         pimpl_->untrackChanges();
1282 }
1283
1284
1285 void Paragraph::cleanChanges()
1286 {
1287         pimpl_->cleanChanges();
1288 }
1289
1290
1291 Change::Type Paragraph::lookupChange(lyx::pos_type pos) const
1292 {
1293         Assert(!size() || pos < size());
1294         return pimpl_->lookupChange(pos);
1295 }
1296
1297
1298 Change const Paragraph::lookupChangeFull(lyx::pos_type pos) const
1299 {
1300         Assert(!size() || pos < size());
1301         return pimpl_->lookupChangeFull(pos);
1302 }
1303
1304
1305 bool Paragraph::isChanged(pos_type start, pos_type end) const
1306 {
1307         return pimpl_->isChanged(start, end);
1308 }
1309
1310
1311 bool Paragraph::isChangeEdited(pos_type start, pos_type end) const
1312 {
1313         return pimpl_->isChangeEdited(start, end);
1314 }
1315
1316
1317 void Paragraph::setChange(lyx::pos_type pos, Change::Type type)
1318 {
1319         pimpl_->setChange(pos, type);
1320
1321 }
1322
1323
1324 void Paragraph::markErased()
1325 {
1326         pimpl_->markErased();
1327 }
1328
1329
1330 void Paragraph::acceptChange(pos_type start, pos_type end)
1331 {
1332         return pimpl_->acceptChange(start, end);
1333 }
1334
1335
1336 void Paragraph::rejectChange(pos_type start, pos_type end)
1337 {
1338         return pimpl_->rejectChange(start, end);
1339 }
1340
1341
1342 lyx::pos_type Paragraph::size() const
1343 {
1344         return pimpl_->size();
1345 }
1346
1347
1348 bool Paragraph::empty() const
1349 {
1350         return pimpl_->empty();
1351 }
1352
1353
1354 Paragraph::value_type Paragraph::getChar(pos_type pos) const
1355 {
1356         return pimpl_->getChar(pos);
1357 }
1358
1359
1360 int Paragraph::id() const
1361 {
1362         return pimpl_->id_;
1363 }
1364
1365
1366 void Paragraph::id(int i)
1367 {
1368         pimpl_->id_ = i;
1369 }
1370
1371
1372 LyXLayout_ptr const & Paragraph::layout() const
1373 {
1374 /*
1375         InsetOld * inset = inInset();
1376         if (inset && inset->lyxCode() == InsetOld::ENVIRONMENT_CODE)
1377                 return static_cast<InsetEnvironment*>(inset)->layout();
1378 */
1379         return layout_;
1380 }
1381
1382
1383 void Paragraph::layout(LyXLayout_ptr const & new_layout)
1384 {
1385         layout_ = new_layout;
1386 }
1387
1388
1389 UpdatableInset * Paragraph::inInset() const
1390 {
1391         return pimpl_->inset_owner;
1392 }
1393
1394
1395 void Paragraph::clearContents()
1396 {
1397         pimpl_->clear();
1398 }
1399
1400 void Paragraph::setChar(pos_type pos, value_type c)
1401 {
1402         pimpl_->setChar(pos, c);
1403 }
1404
1405
1406 ParagraphParameters & Paragraph::params()
1407 {
1408         return pimpl_->params;
1409 }
1410
1411
1412 ParagraphParameters const & Paragraph::params() const
1413 {
1414         return pimpl_->params;
1415 }
1416
1417
1418 bool Paragraph::isFreeSpacing() const
1419 {
1420         if (layout()->free_spacing)
1421                 return true;
1422
1423         // for now we just need this, later should we need this in some
1424         // other way we can always add a function to InsetOld::() too.
1425         if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
1426                 return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE);
1427         return false;
1428 }
1429
1430
1431 bool Paragraph::allowEmpty() const
1432 {
1433         if (layout()->keepempty)
1434                 return true;
1435         if (pimpl_->inset_owner && pimpl_->inset_owner->owner())
1436                 return (pimpl_->inset_owner->owner()->lyxCode() == InsetOld::ERT_CODE);
1437         return false;
1438 }
1439
1440
1441 bool operator==(Paragraph const & lhs, Paragraph const & rhs)
1442 {
1443 #warning FIXME this implementatoin must be completely wrong...
1444         return &lhs == &rhs;
1445 }