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