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-2000 The LyX Team.
   8  *
   9  * ====================================================== */
  10
  11 #include <config.h>
  12
  13 #ifdef __GNUG__
  14 #pragma implementation "lyxparagraph.h"
  15 #endif
  16
  17 #include <algorithm>
  18 #include <fstream>
  19
  20 #include "lyxparagraph.h"
  21 #include "support/textutils.h"
  22 #include "lyxrc.h"
  23 #include "layout.h"
  24 #include "tex-strings.h"
  25 #include "bufferparams.h"
  26 #include "support/FileInfo.h"
  27 #include "support/LAssert.h"
  28 #include "debug.h"
  29 #include "LaTeXFeatures.h"
  30 #include "insets/insetinclude.h"
  31 #include "insets/insetbib.h"
  32 #include "support/filetools.h"
  33 #include "lyx_gui_misc.h"
  34 #include "texrow.h"
  35 #include "support/lyxmanip.h"
  36
  37 using std::ostream;
  38 using std::endl;
  39 using std::fstream;
  40 using std::ios;
  41 using std::lower_bound;
  42 using std::upper_bound;
  43
  44 int tex_code_break_column = 72;  // needs non-zero initialization. set later.
  45 // this is a bad idea, but how can LyXParagraph find its buffer to get
  46 // parameters? (JMarc)
  47 extern BufferView * current_view;
  48
  49
  50 // ale970405
  51 extern string bibitemWidthest(Painter &);
  52
  53 // this is a minibuffer
  54 static char minibuffer_char;
  55 static LyXFont minibuffer_font;
  56 static Inset * minibuffer_inset;
  57
  58
  59 // Initialization of the counter for the paragraph id's,
  60 // declared in lyxparagraph.h
  61 unsigned int LyXParagraph::paragraph_id = 0;
  62
  63
  64 LyXParagraph::LyXParagraph()
  65 {
  66         text.reserve(500); // is this number too big?
  67
  68         for (int i = 0; i < 10; ++i) setCounter(i , 0);
  69         appendix = false;
  70         enumdepth = 0;
  71         itemdepth = 0;
  72         next = 0;
  73         previous = 0;
  74         footnoteflag = LyXParagraph::NO_FOOTNOTE;
  75         footnotekind = LyXParagraph::FOOTNOTE; // should not be needed
  76
  77         align = LYX_ALIGN_BLOCK;
  78
  79         /* table stuff -- begin*/
  80         table = 0;
  81         /* table stuff -- end*/
  82         inset_owner = 0;
  83         id_ = paragraph_id++;
  84         bibkey = 0; // ale970302
  85         Clear();
  86 }
  87
  88
  89 // This konstruktor inserts the new paragraph in a list.
  90 LyXParagraph::LyXParagraph(LyXParagraph * par)
  91 {
  92         text.reserve(500);
  93         par->text.resize(par->text.size());
  94
  95         for (int i = 0; i < 10; ++i) setCounter(i, 0);
  96         appendix = false;
  97         enumdepth = 0;
  98         itemdepth = 0;
  99         // double linked list begin
 100         next = par->next;
 101         if (next)
 102                 next->previous = this;
 103         previous = par;
 104         previous->next = this;
 105         // end
 106         footnoteflag = LyXParagraph::NO_FOOTNOTE;
 107         footnotekind = LyXParagraph::FOOTNOTE;
 108
 109         /* table stuff -- begin*/
 110         table = 0;
 111         /* table stuff -- end*/
 112         inset_owner = 0;
 113         id_ = paragraph_id++;
 114
 115         bibkey = 0; // ale970302
 116
 117         Clear();
 118 }
 119
 120
 121 void LyXParagraph::writeFile(ostream & os, BufferParams const & params,
 122                              char footflag, char dth) const
 123 {
 124         LyXFont font1, font2;
 125         int column = 0;
 126         int h = 0;
 127         char c = 0;
 128
 129         if (footnoteflag != LyXParagraph::NO_FOOTNOTE
 130             || !previous
 131             || previous->footnoteflag == LyXParagraph::NO_FOOTNOTE){
 132
 133                 // The beginning or the end of a footnote environment?
 134                 if (footflag != footnoteflag) {
 135                         footflag = footnoteflag;
 136                         if (footflag) {
 137                                 os << "\n\\begin_float "
 138                                    << string_footnotekinds[footnotekind]
 139                                    << " ";
 140                         } else {
 141                                 os << "\n\\end_float ";
 142                         }
 143                 }
 144
 145                 // The beginning or end of a deeper (i.e. nested) area?
 146                 if (dth != depth) {
 147                         if (depth > dth) {
 148                                 while (depth > dth) {
 149                                         os << "\n\\begin_deeper ";
 150                                         ++dth;
 151                                 }
 152                         } else {
 153                                 while (depth < dth) {
 154                                         os << "\n\\end_deeper ";
 155                                         --dth;
 156                                 }
 157                         }
 158                 }
 159
 160                 // First write the layout
 161                 os << "\n\\layout "
 162                    << textclasslist.NameOfLayout(params.textclass, layout)
 163                    << "\n";
 164
 165                 // Maybe some vertical spaces.
 166                 if (added_space_top.kind() != VSpace::NONE)
 167                         os << "\\added_space_top "
 168                            << added_space_top.asLyXCommand() << " ";
 169                 if (added_space_bottom.kind() != VSpace::NONE)
 170                         os << "\\added_space_bottom "
 171                            << added_space_bottom.asLyXCommand() << " ";
 172
 173                 // Maybe the paragraph has special spacing
 174                 spacing.writeFile(os, true);
 175
 176                 // The labelwidth string used in lists.
 177                 if (!labelwidthstring.empty())
 178                         os << "\\labelwidthstring "
 179                            << labelwidthstring << '\n';
 180
 181                 // Lines above or below?
 182                 if (line_top)
 183                         os << "\\line_top ";
 184                 if (line_bottom)
 185                         os << "\\line_bottom ";
 186
 187                 // Pagebreaks above or below?
 188                 if (pagebreak_top)
 189                         os << "\\pagebreak_top ";
 190                 if (pagebreak_bottom)
 191                         os << "\\pagebreak_bottom ";
 192
 193                 // Start of appendix?
 194                 if (start_of_appendix)
 195                         os << "\\start_of_appendix ";
 196
 197                 // Noindent?
 198                 if (noindent)
 199                         os << "\\noindent ";
 200
 201                 // Alignment?
 202                 if (align != LYX_ALIGN_LAYOUT) {
 203                         switch (align) {
 204                         case LYX_ALIGN_LEFT: h = 1; break;
 205                         case LYX_ALIGN_RIGHT: h = 2; break;
 206                         case LYX_ALIGN_CENTER: h = 3; break;
 207                         default: h = 0; break;
 208                         }
 209                         os << "\\align " << string_align[h] << " ";
 210                 }
 211                 if (pextra_type != PEXTRA_NONE) {
 212                         os << "\\pextra_type " << pextra_type;
 213                         if (pextra_type == PEXTRA_MINIPAGE) {
 214                                 os << " \\pextra_alignment "
 215                                    << pextra_alignment;
 216                                 if (pextra_hfill)
 217                                         os << " \\pextra_hfill "
 218                                            << pextra_hfill;
 219                                 if (pextra_start_minipage)
 220                                         os << " \\pextra_start_minipage "
 221                                            << pextra_start_minipage;
 222                         }
 223                         if (!pextra_width.empty()) {
 224                                 os << " \\pextra_width "
 225                                    << VSpace(pextra_width).asLyXCommand();
 226                         } else if (!pextra_widthp.empty()) {
 227                                 os << " \\pextra_widthp "
 228                                    << pextra_widthp;
 229                         }
 230                         os << '\n';
 231                 }
 232         } else {
 233                 // Dummy layout. This means that a footnote ended.
 234                 os << "\n\\end_float ";
 235                 footflag = LyXParagraph::NO_FOOTNOTE;
 236         }
 237
 238         // It might be a table.
 239         if (table){
 240                 os << "\\LyXTable\n";
 241                 table->Write(os);
 242         }
 243
 244         // bibitem  ale970302
 245         if (bibkey)
 246                 bibkey->Write(os);
 247
 248         font1 = LyXFont(LyXFont::ALL_INHERIT,params.language_info);
 249
 250         column = 0;
 251         for (size_type i = 0; i < size(); ++i) {
 252                 if (!i) {
 253                         os << "\n";
 254                         column = 0;
 255                 }
 256
 257                 // Write font changes
 258                 font2 = GetFontSettings(i);
 259                 if (font2 != font1) {
 260                         font2.lyxWriteChanges(font1, os);
 261                         column = 0;
 262                         font1 = font2;
 263                 }
 264
 265                 c = GetChar(i);
 266                 switch (c) {
 267                 case META_INSET:
 268                 {
 269                         Inset const * inset = GetInset(i);
 270                         if (inset)
 271                                 if (inset->DirectWrite()) {
 272                                         // international char, let it write
 273                                         // code directly so it's shorter in
 274                                         // the file
 275                                         inset->Write(os);
 276                                 } else {
 277                                         os << "\n\\begin_inset ";
 278                                         inset->Write(os);
 279                                         os << "\n\\end_inset \n\n";
 280                                         column = 0;
 281                                 }
 282                 }
 283                 break;
 284                 case META_NEWLINE:
 285                         os << "\n\\newline \n";
 286                         column = 0;
 287                         break;
 288                 case META_HFILL:
 289                         os << "\n\\hfill \n";
 290                         column = 0;
 291                         break;
 292                 case '\\':
 293                         os << "\n\\backslash \n";
 294                         column = 0;
 295                         break;
 296                 case '.':
 297                         if (i + 1 < size() && GetChar(i + 1) == ' ') {
 298                                 os << ".\n";
 299                                 column = 0;
 300                         } else
 301                                 os << ".";
 302                         break;
 303                 default:
 304                         if ((column > 70 && c == ' ')
 305                             || column > 79) {
 306                                 os << "\n";
 307                                 column = 0;
 308                         }
 309                         // this check is to amend a bug. LyX sometimes
 310                         // inserts '\0' this could cause problems.
 311                         if (c != '\0')
 312                                 os << c;
 313                         else
 314                                 lyxerr << "ERROR (LyXParagraph::writeFile):"
 315                                         " NULL char in structure." << endl;
 316                         ++column;
 317                         break;
 318                 }
 319         }
 320
 321         // now write the next paragraph
 322         if (next)
 323                 next->writeFile(os, params, footflag, dth);
 324 }
 325
 326
 327 void LyXParagraph::validate(LaTeXFeatures & features) const
 328 {
 329         BufferParams const & params = features.bufferParams();
 330
 331         // this will be useful later
 332         LyXLayout const & layout =
 333                 textclasslist.Style(params.textclass,
 334                                     GetLayout());
 335
 336         // check the params.
 337         if (line_top || line_bottom)
 338                 features.lyxline = true;
 339         if (!spacing.isDefault())
 340                 features.setspace = true;
 341
 342         // then the layouts
 343         features.layout[GetLayout()] = true;
 344
 345         // then the fonts
 346         Language const * doc_language = params.language_info;
 347
 348         for (FontList::const_iterator cit = fontlist.begin();
 349              cit != fontlist.end(); ++cit) {
 350                 if ((*cit).font.noun() == LyXFont::ON) {
 351                         lyxerr[Debug::LATEX] << "font.noun: "
 352                                              << (*cit).font.noun()
 353                                              << endl;
 354                         features.noun = true;
 355                         lyxerr[Debug::LATEX] << "Noun enabled. Font: "
 356                                              << (*cit).font.stateText()
 357                                              << endl;
 358                 }
 359                 switch ((*cit).font.color()) {
 360                 case LColor::none:
 361                 case LColor::inherit:
 362                 case LColor::ignore:
 363                         break;
 364                 default:
 365                         features.color = true;
 366                         lyxerr[Debug::LATEX] << "Color enabled. Font: "
 367                                              << (*cit).font.stateText()
 368                                              << endl;
 369                 }
 370 #if 0
 371                 Language const * language = (*cit).font.language();
 372                 if (language != doc_language) {
 373                         features.UsedLanguages.insert(language);
 374                         lyxerr[Debug::LATEX] << "Found language "
 375                                              << language->lang << endl;
 376                 }
 377 #endif
 378         }
 379
 380         // This is not efficient. I plan to use the code above, after I
 381         // change the fontlist handling.
 382         for (size_type i = 0; i < size(); ++i) {
 383                 Language const * language = GetFontSettings(i).language();
 384                 if (language != doc_language)
 385                         features.UsedLanguages.insert(language);
 386         }
 387
 388         // then the insets
 389         for (InsetList::const_iterator cit = insetlist.begin();
 390              cit != insetlist.end(); ++cit) {
 391                 if ((*cit).inset)
 392                         (*cit).inset->Validate(features);
 393         }
 394
 395         if (table && table->IsLongTable())
 396                 features.longtable = true;
 397         if (pextra_type == PEXTRA_INDENT)
 398                 features.LyXParagraphIndent = true;
 399         if (pextra_type == PEXTRA_FLOATFLT)
 400                 features.floatflt = true;
 401         if (layout.needprotect
 402             && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
 403                 features.NeedLyXFootnoteCode = true;
 404         if (params.paragraph_separation == BufferParams::PARSEP_INDENT
 405             && pextra_type == LyXParagraph::PEXTRA_MINIPAGE)
 406                 features.NeedLyXMinipageIndent = true;
 407         if (table && table->NeedRotating())
 408                 features.rotating = true;
 409         if (footnoteflag != NO_FOOTNOTE && footnotekind == ALGORITHM)
 410                 features.algorithm = true;
 411 }
 412
 413
 414 // First few functions needed for cut and paste and paragraph breaking.
 415 void LyXParagraph::CopyIntoMinibuffer(LyXParagraph::size_type pos) const
 416 {
 417         minibuffer_char = GetChar(pos);
 418         minibuffer_font = GetFontSettings(pos);
 419         minibuffer_inset = 0;
 420         if (minibuffer_char == LyXParagraph::META_INSET) {
 421                 if (GetInset(pos)) {
 422                         minibuffer_inset = GetInset(pos)->Clone();
 423                 } else {
 424                         minibuffer_inset = 0;
 425                         minibuffer_char = ' ';
 426                         // This reflects what GetInset() does (ARRae)
 427                 }
 428         }
 429 }
 430
 431
 432 void LyXParagraph::CutIntoMinibuffer(LyXParagraph::size_type pos)
 433 {
 434         minibuffer_char = GetChar(pos);
 435         minibuffer_font = GetFontSettings(pos);
 436         minibuffer_inset = 0;
 437         if (minibuffer_char == LyXParagraph::META_INSET) {
 438                 if (GetInset(pos)) {
 439                         minibuffer_inset = GetInset(pos);
 440                         // This is a little hack since I want exactly
 441                         // the inset, not just a clone. Otherwise
 442                         // the inset would be deleted when calling Erase(pos)
 443                         // find the entry
 444                         InsetList::iterator it = lower_bound(insetlist.begin(),
 445                                                              insetlist.end(),
 446                                                              pos, matchIT());
 447                         if (it != insetlist.end() && (*it).pos == pos)
 448                                 (*it).inset = 0;
 449                 } else {
 450                         minibuffer_inset = 0;
 451                         minibuffer_char = ' ';
 452                         // This reflects what GetInset() does (ARRae)
 453                 }
 454
 455         }
 456
 457         // Erase(pos); now the caller is responsible for that.
 458 }
 459
 460
 461 bool LyXParagraph::InsertFromMinibuffer(LyXParagraph::size_type pos)
 462 {
 463         if ((minibuffer_char == LyXParagraph::META_INSET) &&
 464             !InsertInsetAllowed(minibuffer_inset))
 465                 return false;
 466         InsertChar(pos, minibuffer_char);
 467         SetFont(pos, minibuffer_font);
 468         if (minibuffer_char == LyXParagraph::META_INSET)
 469                 InsertInset(pos, minibuffer_inset);
 470         return true;
 471 }
 472
 473 // end of minibuffer
 474
 475
 476
 477 void LyXParagraph::Clear()
 478 {
 479         line_top = false;
 480         line_bottom = false;
 481
 482         pagebreak_top = false;
 483         pagebreak_bottom = false;
 484
 485         added_space_top = VSpace(VSpace::NONE);
 486         added_space_bottom = VSpace(VSpace::NONE);
 487         spacing.set(Spacing::Default);
 488
 489         align = LYX_ALIGN_LAYOUT;
 490         depth = 0;
 491         noindent = false;
 492
 493         pextra_type = PEXTRA_NONE;
 494         pextra_width.erase();
 495         pextra_widthp.erase();
 496         pextra_alignment = MINIPAGE_ALIGN_TOP;
 497         pextra_hfill = false;
 498         pextra_start_minipage = false;
 499
 500         labelstring.erase();
 501         labelwidthstring.erase();
 502         layout = 0;
 503         bibkey = 0;
 504
 505         start_of_appendix = false;
 506 }
 507
 508
 509 // the destructor removes the new paragraph from the list
 510 LyXParagraph::~LyXParagraph()
 511 {
 512         if (previous)
 513                 previous->next = next;
 514         if (next)
 515                 next->previous = previous;
 516
 517         for (InsetList::iterator it = insetlist.begin();
 518              it != insetlist.end(); ++it) {
 519                 delete (*it).inset;
 520         }
 521
 522         /* table stuff -- begin*/
 523         delete table;
 524         /* table stuff -- end*/
 525
 526         // ale970302
 527         delete bibkey;
 528         //
 529         //lyxerr << "LyXParagraph::paragraph_id = "
 530         //       << LyXParagraph::paragraph_id << endl;
 531 }
 532
 533
 534 void LyXParagraph::Erase(LyXParagraph::size_type pos)
 535 {
 536         // > because last is the next unused position, and you can
 537         // use it if you want
 538         if (pos > size()) {
 539                 if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
 540                         NextAfterFootnote()->Erase(pos - text.size() - 1);
 541                 else
 542                         lyxerr.debug() << "ERROR (LyXParagraph::Erase): "
 543                                 "position does not exist." << endl;
 544                 return;
 545         }
 546         if (pos < size()) { // last is free for insertation, but should be empty
 547                 // if it is an inset, delete the inset entry
 548                 if (text[pos] == LyXParagraph::META_INSET) {
 549                         // find the entry
 550                         InsetList::iterator it = lower_bound(insetlist.begin(),
 551                                                              insetlist.end(),
 552                                                              pos, matchIT());
 553                         if (it != insetlist.end() && (*it).pos == pos) {
 554                                 delete (*it).inset;
 555                                 insetlist.erase(it);
 556                         }
 557                 }
 558                 text.erase(text.begin() + pos);
 559                 // Erase entries in the tables.
 560                 for (FontList::iterator it = fontlist.begin();
 561                      it != fontlist.end(); ++it) {
 562                         if (pos >= (*it).pos && pos <= (*it).pos_end) {
 563                                 if ((*it).pos == (*it).pos_end) {
 564                                         // If it is a multi-character font
 565                                         // entry, we just make it smaller
 566                                         // (see update below), otherwise we
 567                                         // should delete it.
 568                                         fontlist.erase(it);
 569                                         break;
 570                                 }
 571                         }
 572                 }
 573                 // Update all other entries.
 574                 for (FontList::iterator it = fontlist.begin();
 575                      it != fontlist.end(); ++it) {
 576                         if ((*it).pos > pos)
 577                                 (*it).pos--;
 578                         if ((*it).pos_end >= pos)
 579                                 (*it).pos_end--;
 580                 }
 581
 582                 // Update the inset table.
 583                 for (InsetList::iterator it = upper_bound(insetlist.begin(),
 584                                                           insetlist.end(),
 585                                                           pos, matchIT());
 586                      it != insetlist.end(); ++it)
 587                         --(*it).pos;
 588         } else {
 589                 lyxerr << "ERROR (LyXParagraph::Erase): "
 590                         "can't erase non-existant char." << endl;
 591         }
 592 }
 593
 594
 595 void LyXParagraph::InsertChar(LyXParagraph::size_type pos, char c)
 596 {
 597         // > because last is the next unused position, and you can
 598         // use it if you want
 599         if (pos > size()) {
 600                 if (next
 601                     && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
 602                         NextAfterFootnote()->InsertChar(pos - text.size() - 1,
 603                                                         c);
 604                 else
 605                         lyxerr.debug() << "ERROR (LyXParagraph::InsertChar): "
 606                                 "position does not exist." << endl;
 607                 return;
 608         }
 609         text.insert(text.begin() + pos, c);
 610         // Update the font table.
 611         for (FontList::iterator it = fontlist.begin();
 612              it != fontlist.end(); ++it) {
 613                 if ((*it).pos >= pos)
 614                         (*it).pos++;
 615                 if ((*it).pos_end >= pos)
 616                         (*it).pos_end++;
 617         }
 618
 619         // Update the inset table.
 620         for (InsetList::iterator it = lower_bound(insetlist.begin(),
 621                                                   insetlist.end(),
 622                                                   pos, matchIT());
 623              it != insetlist.end(); ++it)
 624                 ++(*it).pos;
 625 }
 626
 627
 628 void LyXParagraph::InsertInset(LyXParagraph::size_type pos,
 629                                Inset * inset)
 630 {
 631         // > because last is the next unused position, and you can
 632         // use it if you want
 633         if (pos > size()) {
 634                 if (next
 635                     && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
 636                         NextAfterFootnote()
 637                                 ->InsertInset(pos - text.size() - 1, inset);
 638                 else
 639                         lyxerr << "ERROR (LyXParagraph::InsertInset): "
 640                                 "position does not exist: " << pos << endl;
 641                 return;
 642         }
 643         if (text[pos] != LyXParagraph::META_INSET) {
 644                 lyxerr << "ERROR (LyXParagraph::InsertInset): "
 645                         "there is no LyXParagraph::META_INSET" << endl;
 646                 return;
 647         }
 648
 649         if (inset) {
 650                 // Add a new entry in the inset table.
 651                 InsetList::iterator it = lower_bound(insetlist.begin(),
 652                                                      insetlist.end(),
 653                                                      pos, matchIT());
 654                 if (it != insetlist.end() && (*it).pos == pos)
 655                         lyxerr << "ERROR (LyXParagraph::InsertInset): "
 656                                 "there is an inset in position: " << pos << endl;
 657                 else
 658                         insetlist.insert(it, InsetTable(pos,inset));
 659                 if (inset_owner)
 660                         inset->setOwner(inset_owner);
 661         }
 662 }
 663
 664
 665 bool LyXParagraph::InsertInsetAllowed(Inset *inset)
 666 {
 667         if (inset_owner) {
 668                 printf("CODE:%d\n",inset->LyxCode());
 669                 return inset_owner->InsertInsetAllowed(inset);
 670         }
 671         return true;
 672 }
 673
 674 Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos)
 675 {
 676         if (pos >= size()) {
 677                 if (next
 678                     && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
 679                         return NextAfterFootnote()
 680                                 ->GetInset(pos - text.size() - 1);
 681                 else {
 682                         lyxerr << "ERROR (LyXParagraph::GetInset): "
 683                                 "position does not exist: "
 684                                << pos << endl;
 685                 }
 686                 return 0;
 687         }
 688         // Find the inset.
 689         InsetList::iterator it = lower_bound(insetlist.begin(),
 690                                              insetlist.end(),
 691                                              pos, matchIT());
 692         if (it != insetlist.end() && (*it).pos == pos)
 693                 return (*it).inset;
 694
 695         lyxerr << "ERROR (LyXParagraph::GetInset): "
 696                 "Inset does not exist: " << pos << endl;
 697         // text[pos] = ' '; // WHY!!! does this set the pos to ' '????
 698         // Did this commenting out introduce a bug? So far I have not
 699         // see any, please enlighten me. (Lgb)
 700         // My guess is that since the inset does not exist, we might
 701         // as well replace it with a space to prevent craches. (Asger)
 702         return 0;
 703 }
 704
 705
 706 Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const
 707 {
 708         if (pos >= size()) {
 709                 if (next
 710                     && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
 711                         return NextAfterFootnote()
 712                                 ->GetInset(pos - text.size() - 1);
 713                 else {
 714                         lyxerr << "ERROR (LyXParagraph::GetInset): "
 715                                 "position does not exist: "
 716                                << pos << endl;
 717                 }
 718                 return 0;
 719         }
 720         // Find the inset.
 721         InsetList::const_iterator cit = lower_bound(insetlist.begin(),
 722                                                     insetlist.end(),
 723                                                     pos, matchIT());
 724         if (cit != insetlist.end() && (*cit).pos == pos)
 725                 return (*cit).inset;
 726
 727         lyxerr << "ERROR (LyXParagraph::GetInset): "
 728                 "Inset does not exist: " << pos << endl;
 729         //text[pos] = ' '; // WHY!!! does this set the pos to ' '????
 730         // Did this commenting out introduce a bug? So far I have not
 731         // see any, please enlighten me. (Lgb)
 732         // My guess is that since the inset does not exist, we might
 733         // as well replace it with a space to prevent craches. (Asger)
 734         return 0;
 735 }
 736
 737
 738 // Gets uninstantiated font setting at position.
 739 // Optimized after profiling. (Asger)
 740 LyXFont LyXParagraph::GetFontSettings(LyXParagraph::size_type pos) const
 741 {
 742         if (pos < size()) {
 743 #ifdef SORTED_FONT_LIST
 744                 for (FontList::const_iterator cit = fontlist.begin();
 745                      cit != fontlist.end() && pos <= (*cit).pos_end; ++cit)
 746                         if (pos >= (*cit).pos)
 747                                 return (*cit).font;
 748 #else
 749                 for (FontList::const_iterator cit = fontlist.begin();
 750                      cit != fontlist.end(); ++cit)
 751                         if (pos >= (*cit).pos && pos <= (*cit).pos_end)
 752                                 return (*cit).font;
 753 #endif
 754         }
 755         // > because last is the next unused position, and you can
 756         // use it if you want
 757         else if (pos > size()) {
 758                 if (next
 759                     && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
 760                         return NextAfterFootnote()
 761                                 ->GetFontSettings(pos - text.size() - 1);
 762                 else {
 763                         // Why is it an error to ask for the font of a
 764                         // position that does not exist? Would it be
 765                         // enough for this to be enabled on debug?
 766                         // We want strict error checking, but it's ok to only
 767                         // have it when debugging. (Asger)
 768                         lyxerr << "ERROR (LyXParagraph::GetFontSettings): "
 769                                 "position does not exist. "
 770                                << pos << " (" << static_cast<int>(pos)
 771                                << ")" << endl;
 772                 }
 773         } else if (pos > 0) {
 774                 return GetFontSettings(pos - 1);
 775         } else // pos = size() = 0
 776                 return LyXFont(LyXFont::ALL_INHERIT,getParLanguage());
 777
 778         return LyXFont(LyXFont::ALL_INHERIT);
 779 }
 780
 781 // Gets uninstantiated font setting at position 0
 782 LyXFont LyXParagraph::GetFirstFontSettings() const
 783 {
 784         if (size() > 0) {
 785 #ifdef SORTED_FONT_LIST
 786                 if (!fontlist.empty() && fontlist.front().pos == 0)
 787                         return fontlist.front().font;
 788 #else
 789                 for (FontList::const_iterator cit = fontlist.begin();
 790                      cit != fontlist.end(); ++cit)
 791                         if (0 >= (*cit).pos && 0 <= (*cit).pos_end)
 792                                 return (*cit).font;
 793 #endif
 794         } else if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
 795                 return NextAfterFootnote()->GetFirstFontSettings();
 796         return LyXFont(LyXFont::ALL_INHERIT);
 797 }
 798
 799 // Gets the fully instantiated font at a given position in a paragraph
 800 // This is basically the same function as LyXText::GetFont() in text2.C.
 801 // The difference is that this one is used for generating the LaTeX file,
 802 // and thus cosmetic "improvements" are disallowed: This has to deliver
 803 // the true picture of the buffer. (Asger)
 804 // If position is -1, we get the layout font of the paragraph.
 805 // If position is -2, we get the font of the manual label of the paragraph.
 806 LyXFont LyXParagraph::getFont(LyXParagraph::size_type pos) const
 807 {
 808         LyXFont tmpfont;
 809         LyXLayout const & layout =
 810                 textclasslist.Style(current_view->buffer()->params.textclass,
 811                                     GetLayout());
 812         LyXParagraph::size_type main_body = 0;
 813         if (layout.labeltype == LABEL_MANUAL)
 814                 main_body = BeginningOfMainBody();
 815
 816         if (pos >= 0){
 817                 LyXFont layoutfont;
 818                 if (pos < main_body)
 819                         layoutfont = layout.labelfont;
 820                 else
 821                         layoutfont = layout.font;
 822                 tmpfont = GetFontSettings(pos);
 823                 tmpfont.realize(layoutfont);
 824         } else {
 825                 // process layoutfont for pos == -1 and labelfont for pos < -1
 826                 if (pos == -1)
 827                         tmpfont = layout.font;
 828                 else
 829                         tmpfont = layout.labelfont;
 830                 tmpfont.setLanguage(getParLanguage());
 831         }
 832
 833         // check for environment font information
 834         char par_depth = GetDepth();
 835         LyXParagraph const * par = this;
 836         while (par && par_depth && !tmpfont.resolved()) {
 837                 par = par->DepthHook(par_depth - 1);
 838                 if (par) {
 839                         tmpfont.realize(textclasslist.
 840                                         Style(current_view->buffer()->params.textclass,
 841                                               par->GetLayout()).font);
 842                         par_depth = par->GetDepth();
 843                 }
 844         }
 845
 846         tmpfont.realize(textclasslist
 847                         .TextClass(current_view->buffer()->params.textclass)
 848                         .defaultfont());
 849         return tmpfont;
 850 }
 851
 852
 853 /// Returns the height of the highest font in range
 854 LyXFont::FONT_SIZE
 855 LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos,
 856                                  LyXParagraph::size_type endpos) const
 857 {
 858         LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY;
 859         for (FontList::const_iterator cit = fontlist.begin();
 860              cit != fontlist.end(); ++cit) {
 861                 if (startpos <= (*cit).pos_end && endpos >= (*cit).pos) {
 862                         LyXFont::FONT_SIZE size = (*cit).font.size();
 863                         if (size > maxsize && size <= LyXFont::SIZE_HUGER)
 864                                 maxsize = size;
 865                 }
 866         }
 867         return maxsize;
 868 }
 869
 870
 871 char LyXParagraph::GetChar(LyXParagraph::size_type pos)
 872 {
 873         Assert(pos >= 0);
 874
 875         if (pos < size()) {
 876                 return text[pos];
 877         }
 878         // > because last is the next unused position, and you can
 879         // use it if you want
 880         else if (pos > size()) {
 881                 if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
 882                         return NextAfterFootnote()
 883                                 ->GetChar(pos - text.size() - 1);
 884                 else {
 885                         lyxerr << "ERROR (LyXParagraph::GetChar): "
 886                                 "position does not exist."
 887                                << pos << " (" << static_cast<int>(pos)
 888                                << ")\n";
 889                         // Assert(false); // This triggers sometimes...
 890                         // Why?
 891                 }
 892                 return '\0';
 893         } else {
 894                 // We should have a footnote environment.
 895                 if (!next || next->footnoteflag == LyXParagraph::NO_FOOTNOTE) {
 896                         // Notice that LyX does request the
 897                         // last char from time to time. (Asger)
 898                         //lyxerr << "ERROR (LyXParagraph::GetChar): "
 899                         //      "expected footnote." << endl;
 900                         return '\0';
 901                 }
 902                 switch (next->footnotekind) {
 903                 case LyXParagraph::FOOTNOTE:
 904                         return LyXParagraph::META_FOOTNOTE;
 905                 case LyXParagraph::MARGIN:
 906                         return LyXParagraph::META_MARGIN;
 907                 case LyXParagraph::FIG:
 908                 case LyXParagraph::WIDE_FIG:
 909                         return LyXParagraph::META_FIG;
 910                 case LyXParagraph::TAB:
 911                 case LyXParagraph::WIDE_TAB:
 912                         return LyXParagraph::META_TAB;
 913                 case LyXParagraph::ALGORITHM:
 914                         return LyXParagraph::META_ALGORITHM;
 915                 }
 916                 return '\0'; // to shut up gcc
 917         }
 918 }
 919
 920
 921 char LyXParagraph::GetChar(LyXParagraph::size_type pos) const
 922 {
 923         Assert(pos >= 0);
 924
 925         if (pos < size()) {
 926                 return text[pos];
 927         }
 928         // > because last is the next unused position, and you can
 929         // use it if you want
 930         else if (pos > size()) {
 931                 if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
 932                         return NextAfterFootnote()
 933                                 ->GetChar(pos - text.size() - 1);
 934                 else {
 935                         lyxerr << "ERROR (LyXParagraph::GetChar const): "
 936                                 "position does not exist."
 937                                << pos << " (" << static_cast<int>(pos)
 938                                << ")\n";
 939                         Assert(false);
 940                 }
 941                 return '\0';
 942         } else {
 943                 // We should have a footnote environment.
 944                 if (!next || next->footnoteflag == LyXParagraph::NO_FOOTNOTE) {
 945                         // Notice that LyX does request the
 946                         // last char from time to time. (Asger)
 947                         //lyxerr << "ERROR (LyXParagraph::GetChar): "
 948                         //      "expected footnote." << endl;
 949                         return '\0';
 950                 }
 951                 switch (next->footnotekind) {
 952                 case LyXParagraph::FOOTNOTE:
 953                         return LyXParagraph::META_FOOTNOTE;
 954                 case LyXParagraph::MARGIN:
 955                         return LyXParagraph::META_MARGIN;
 956                 case LyXParagraph::FIG:
 957                 case LyXParagraph::WIDE_FIG:
 958                         return LyXParagraph::META_FIG;
 959                 case LyXParagraph::TAB:
 960                 case LyXParagraph::WIDE_TAB:
 961                         return LyXParagraph::META_TAB;
 962                 case LyXParagraph::ALGORITHM:
 963                         return LyXParagraph::META_ALGORITHM;
 964                 }
 965                 return '\0'; // to shut up gcc
 966         }
 967 }
 968
 969
 970 // return an string of the current word, and the end of the word in lastpos.
 971 string LyXParagraph::GetWord(LyXParagraph::size_type & lastpos) const
 972 {
 973         Assert(lastpos>=0);
 974
 975         // the current word is defined as starting at the first character
 976         // from the immediate left of lastpospos which meets the definition
 977         // of IsLetter(), continuing to the last character to the right
 978         // of this meeting IsLetter.
 979
 980         string theword;
 981
 982         // grab a word
 983
 984         // move back until we have a letter
 985
 986         //there's no real reason to have firstpos & lastpos as
 987         //separate variables as this is written, but maybe someon
 988         // will want to return firstpos in the future.
 989
 990         //since someone might have typed a punctuation first
 991         int firstpos = lastpos;
 992
 993         while ((firstpos >= 0) && !IsLetter(firstpos))
 994                 --firstpos;
 995
 996         // now find the beginning by looking for a nonletter
 997
 998         while ((firstpos>= 0) && IsLetter(firstpos))
 999                 --firstpos;
1000
1001         // the above is now pointing to the preceeding non-letter
1002         ++firstpos;
1003         lastpos = firstpos;
1004
1005         // so copy characters into theword  until we get a nonletter
1006         // note that this can easily exceed lastpos, wich means
1007         // that if used in the middle of a word, the whole word
1008         // is included
1009
1010         while (IsLetter(lastpos)) theword += GetChar(lastpos++);
1011
1012         return theword;
1013
1014 }
1015
1016
1017 LyXParagraph::size_type LyXParagraph::Last() const
1018 {
1019         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
1020                 return text.size() + NextAfterFootnote()->Last() + 1;
1021         // the 1 is the symbol
1022         // for the footnote
1023         else
1024                 return text.size();
1025 }
1026
1027
1028 LyXParagraph * LyXParagraph::ParFromPos(LyXParagraph::size_type pos)
1029 {
1030         // > because last is the next unused position, and you can
1031         // use it if you want
1032         if (pos > size()) {
1033                 if (next
1034                     && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
1035                         return NextAfterFootnote()
1036                                 ->ParFromPos(pos - text.size() - 1);
1037                 else
1038                         lyxerr << "ERROR (LyXParagraph::ParFromPos): "
1039                                 "position does not exist." << endl;
1040                 return this;
1041         } else
1042                 return this;
1043 }
1044
1045
1046 int LyXParagraph::PositionInParFromPos(LyXParagraph::size_type pos) const
1047 {
1048         // > because last is the next unused position, and you can
1049         // use it if you want
1050         if (pos > size()) {
1051                 if (next
1052                     && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
1053                         return NextAfterFootnote()
1054                                 ->PositionInParFromPos(pos - text.size() - 1);
1055                 else
1056                         lyxerr <<
1057                                 "ERROR (LyXParagraph::PositionInParFromPos): "
1058                                 "position does not exist." << endl;
1059                 return pos;
1060         }
1061         else
1062                 return pos;
1063 }
1064
1065
1066 void LyXParagraph::SetFont(LyXParagraph::size_type pos,
1067                            LyXFont const & font)
1068 {
1069         // > because last is the next unused position, and you can
1070         // use it if you want
1071         if (pos > size()) {
1072                 if (next &&
1073                     next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
1074                         NextAfterFootnote()->SetFont(pos - text.size() - 1,
1075                                                      font);
1076                 } else {
1077                         lyxerr << "ERROR (LyXParagraph::SetFont): "
1078                                 "position does not exist." << endl;
1079                 }
1080                 return;
1081         }
1082         LyXFont patternfont(LyXFont::ALL_INHERIT);
1083
1084         // First, reduce font against layout/label font
1085         // Update: The SetCharFont() routine in text2.C already
1086         // reduces font, so we don't need to do that here. (Asger)
1087         // No need to simplify this because it will disappear
1088         // in a new kernel. (Asger)
1089         // Next search font table
1090         FontList::iterator tmp = fontlist.begin();
1091         for (; tmp != fontlist.end(); ++tmp) {
1092                 if (pos >= (*tmp).pos && pos <= (*tmp).pos_end) {
1093                         break;
1094                 }
1095         }
1096         if (tmp == fontlist.end()) { // !found
1097                 // if we did not find a font entry, but if the font at hand
1098                 // is the same as default, we just forget it
1099                 if (font == patternfont) return;
1100
1101                 // ok, we did not find a font entry. But maybe there is exactly
1102                 // the needed font ientry one position left
1103                 FontList::iterator tmp2 = fontlist.begin();
1104                 for (; tmp2 != fontlist.end(); ++tmp2) {
1105                         if (pos - 1 >= (*tmp2).pos
1106                             && pos - 1 <= (*tmp2).pos_end)
1107                                 break;
1108                 }
1109                 if (tmp2 != fontlist.end()) {
1110                         // ok there is one, maybe it is exactly
1111                         // the needed font
1112                         if ((*tmp2).font == font) {
1113                                 // put the position under the font
1114                                 (*tmp2).pos_end++;
1115                                 return;
1116                         }
1117                 }
1118                 // Add a new entry in the
1119                 // fontlist for the position
1120                 FontTable ft;
1121                 ft.pos = pos;
1122                 ft.pos_end = pos;
1123                 ft.font = font; // or patternfont
1124                 // It seems that using font instead of patternfont here
1125                 // fixes all the problems. This also surfaces a "bug" in
1126                 // the old code.
1127                 fontlist.insert(fontlist.begin(), ft);
1128         } else if ((*tmp).pos != (*tmp).pos_end) { // we found a font entry. maybe we have to split it and create a new one.
1129
1130 // more than one character
1131                 if (pos == (*tmp).pos) {
1132                         // maybe we should enlarge the left fonttable
1133                         FontList::iterator tmp2 = fontlist.begin();
1134                         for (; tmp2 != fontlist.end(); ++tmp2) {
1135                                 if (pos - 1 >= (*tmp2).pos
1136                                     && pos - 1 <= (*tmp2).pos_end)
1137                                         break;
1138                         }
1139                         // Is there is one, and is it exactly
1140                         // the needed font?
1141                         if (tmp2 != fontlist.end() &&
1142                             (*tmp2).font == font) {
1143                                 // Put the position under the font
1144                                 (*tmp2).pos_end++;
1145                                 (*tmp).pos++;
1146                                 return;
1147                         }
1148
1149                         // Add a new entry in the
1150                         // fontlist for the position
1151                         FontTable ft;
1152                         ft.pos = pos + 1;
1153                         ft.pos_end = (*tmp).pos_end;
1154                         ft.font = (*tmp).font;
1155                         (*tmp).pos_end = pos;
1156                         (*tmp).font = font;
1157                         fontlist.insert(fontlist.begin(), ft);
1158                 } else if (pos == (*tmp).pos_end) {
1159                         // Add a new entry in the
1160                         // fontlist for the position
1161                         FontTable ft;
1162                         ft.pos = (*tmp).pos;
1163                         ft.pos_end = (*tmp).pos_end - 1;
1164                         ft.font = (*tmp).font;
1165                         (*tmp).pos = (*tmp).pos_end;
1166                         (*tmp).font = font;
1167                         fontlist.insert(fontlist.begin(), ft);
1168                 } else {
1169                         // Add a new entry in the
1170                         // fontlist for the position
1171                         FontTable ft;
1172                         ft.pos = (*tmp).pos;
1173                         ft.pos_end = pos - 1;
1174                         ft.font = (*tmp).font;
1175
1176                         FontTable ft2;
1177                         ft2.pos = pos + 1;
1178                         ft2.pos_end = (*tmp).pos_end;
1179                         ft2.font = (*tmp).font;
1180
1181                         (*tmp).pos = pos;
1182                         (*tmp).pos_end = pos;
1183                         (*tmp).font = font;
1184
1185                         fontlist.insert(fontlist.begin(), ft);
1186                         fontlist.insert(fontlist.begin(), ft2);
1187                 }
1188         } else {
1189                 (*tmp).font = font;
1190         }
1191 }
1192
1193
1194 // This function is able to hide closed footnotes.
1195 LyXParagraph * LyXParagraph::Next()
1196 {
1197         if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
1198                 LyXParagraph * tmp = next;
1199                 while (tmp
1200                        && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
1201                         tmp = tmp->next;
1202                 if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
1203                         return tmp->Next(); /* there can be more than one
1204                                                footnote in a logical
1205                                                paragraph */
1206                 else
1207                         return next;  // This should never happen!
1208         } else
1209                 return next;
1210 }
1211
1212
1213 LyXParagraph * LyXParagraph::NextAfterFootnote()
1214 {
1215         if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
1216                 LyXParagraph * tmp = next;
1217                 while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
1218                         tmp = tmp->next;
1219                 if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
1220                         return tmp;   /* there can be more than one footnote
1221                                          in a logical paragraph */
1222                 else
1223                         return next;  // This should never happen!
1224         } else
1225                 return next;
1226 }
1227
1228
1229 LyXParagraph const * LyXParagraph::NextAfterFootnote() const
1230 {
1231         if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
1232                 LyXParagraph * tmp = next;
1233                 while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
1234                         tmp = tmp->next;
1235                 if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
1236                         return tmp;   /* there can be more than one footnote
1237                                          in a logical paragraph */
1238                 else
1239                         return next;  // This should never happen!
1240         } else
1241                 return next;
1242 }
1243
1244
1245 LyXParagraph * LyXParagraph::PreviousBeforeFootnote()
1246 {
1247         LyXParagraph * tmp;
1248         if (previous && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
1249                 tmp = previous;
1250                 while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE)
1251                         tmp = tmp->previous;
1252                 if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
1253                         return tmp;    /* there can be more than one footnote
1254                                           in a logical paragraph */
1255                 else
1256                         return previous;  // This should never happen!
1257         } else
1258                 return previous;
1259 }
1260
1261
1262 LyXParagraph * LyXParagraph::LastPhysicalPar()
1263 {
1264         if (footnoteflag != LyXParagraph::NO_FOOTNOTE)
1265                 return this;
1266
1267         LyXParagraph * tmp = this;
1268         while (tmp->next
1269                && tmp->next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
1270                 tmp = tmp->NextAfterFootnote();
1271
1272         return tmp;
1273 }
1274
1275 LyXParagraph const * LyXParagraph::LastPhysicalPar() const
1276 {
1277         if (footnoteflag != LyXParagraph::NO_FOOTNOTE)
1278                 return this;
1279
1280         LyXParagraph const * tmp = this;
1281         while (tmp->next
1282                && tmp->next->footnoteflag != LyXParagraph::NO_FOOTNOTE)
1283                 tmp = tmp->NextAfterFootnote();
1284
1285         return tmp;
1286 }
1287
1288 LyXParagraph * LyXParagraph::FirstPhysicalPar()
1289 {
1290         if (!IsDummy())
1291                 return this;
1292         LyXParagraph * tmppar = this;
1293
1294         while (tmppar &&
1295                (tmppar->IsDummy()
1296                 || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE))
1297                 tmppar = tmppar->previous;
1298
1299         if (!tmppar) {
1300                 return this;
1301         } else
1302                 return tmppar;
1303 }
1304
1305
1306 LyXParagraph const * LyXParagraph::FirstPhysicalPar() const
1307 {
1308         if (!IsDummy())
1309                 return this;
1310         LyXParagraph const * tmppar = this;
1311
1312         while (tmppar &&
1313                (tmppar->IsDummy()
1314                 || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE))
1315                 tmppar = tmppar->previous;
1316
1317         if (!tmppar) {
1318                 return this;
1319         } else
1320                 return tmppar;
1321 }
1322
1323
1324 // This function is able to hide closed footnotes.
1325 LyXParagraph * LyXParagraph::Previous()
1326 {
1327         LyXParagraph * tmp = previous;
1328         if (!tmp)
1329                 return tmp;
1330
1331         if (tmp->previous
1332             && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
1333                 tmp = tmp->previous;
1334                 while (tmp
1335                        && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
1336                         tmp = tmp->previous;
1337                 if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
1338                         return tmp->next->Previous();
1339
1340                 else
1341                         return previous;
1342         } else
1343                 return previous;
1344 }
1345
1346
1347 // This function is able to hide closed footnotes.
1348 LyXParagraph const * LyXParagraph::Previous() const
1349 {
1350         LyXParagraph * tmp = previous;
1351         if (!tmp)
1352                 return tmp;
1353
1354         if (tmp->previous
1355             && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
1356                 tmp = tmp->previous;
1357                 while (tmp
1358                        && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)
1359                         tmp = tmp->previous;
1360                 if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE)
1361                         return tmp->next->Previous();
1362
1363                 else
1364                         return previous;
1365         } else
1366                 return previous;
1367 }
1368
1369
1370 void LyXParagraph::BreakParagraph(LyXParagraph::size_type pos,
1371                                   int flag)
1372 {
1373         size_type i, j, pos_end, pos_first;
1374         // create a new paragraph
1375         LyXParagraph * par = ParFromPos(pos);
1376         LyXParagraph * firstpar = FirstPhysicalPar();
1377
1378         LyXParagraph * tmp = new LyXParagraph(par);
1379
1380         tmp->footnoteflag = footnoteflag;
1381         tmp->footnotekind = footnotekind;
1382
1383         // this is an idea for a more userfriendly layout handling, I will
1384         // see what the users say
1385
1386         // layout stays the same with latex-environments
1387         if (flag) {
1388                 tmp->SetOnlyLayout(firstpar->layout);
1389                 tmp->SetLabelWidthString(firstpar->labelwidthstring);
1390         }
1391
1392         if (Last() > pos || !Last() || flag == 2) {
1393                 tmp->SetOnlyLayout(firstpar->layout);
1394                 tmp->align = firstpar->align;
1395                 tmp->SetLabelWidthString(firstpar->labelwidthstring);
1396
1397                 tmp->line_bottom = firstpar->line_bottom;
1398                 firstpar->line_bottom = false;
1399                 tmp->pagebreak_bottom = firstpar->pagebreak_bottom;
1400                 firstpar->pagebreak_bottom = false;
1401                 tmp->added_space_bottom = firstpar->added_space_bottom;
1402                 firstpar->added_space_bottom = VSpace(VSpace::NONE);
1403
1404                 tmp->depth = firstpar->depth;
1405                 tmp->noindent = firstpar->noindent;
1406
1407                 // copy everything behind the break-position
1408                 // to the new paragraph
1409                 pos_first = 0;
1410                 while (ParFromPos(pos_first) != par)
1411                         ++pos_first;
1412
1413                 pos_end = pos_first + par->text.size() - 1;
1414
1415                 for (i = j = pos; i <= pos_end; ++i) {
1416                         par->CutIntoMinibuffer(i - pos_first);
1417                         if (tmp->InsertFromMinibuffer(j - pos))
1418                                 ++j;
1419                 }
1420                 tmp->text.resize(tmp->text.size());
1421                 for (i = pos_end; i >= pos; --i)
1422                         par->Erase(i - pos_first);
1423
1424                 par->text.resize(par->text.size());
1425         }
1426
1427         // just an idea of me
1428         if (!pos) {
1429                 tmp->line_top = firstpar->line_top;
1430                 tmp->pagebreak_top = firstpar->pagebreak_top;
1431                 tmp->added_space_top = firstpar->added_space_top;
1432                 tmp->bibkey = firstpar->bibkey;
1433                 firstpar->Clear();
1434                 // layout stays the same with latex-environments
1435                 if (flag) {
1436                         firstpar->SetOnlyLayout(tmp->layout);
1437                         firstpar->SetLabelWidthString(tmp->labelwidthstring);
1438                         firstpar->depth = tmp->depth;
1439                 }
1440         }
1441 }
1442
1443
1444 void LyXParagraph::MakeSameLayout(LyXParagraph const * par)
1445 {
1446         par = par->FirstPhysicalPar();
1447         footnoteflag = par->footnoteflag;
1448         footnotekind = par->footnotekind;
1449
1450         layout = par->layout;
1451         align = par-> align;
1452         SetLabelWidthString(par->labelwidthstring);
1453
1454         line_bottom = par->line_bottom;
1455         pagebreak_bottom = par->pagebreak_bottom;
1456         added_space_bottom = par->added_space_bottom;
1457
1458         line_top = par->line_top;
1459         pagebreak_top = par->pagebreak_top;
1460         added_space_top = par->added_space_top;
1461
1462         spacing = par->spacing;
1463
1464         pextra_type = par->pextra_type;
1465         pextra_width = par->pextra_width;
1466         pextra_widthp = par->pextra_widthp;
1467         pextra_alignment = par->pextra_alignment;
1468         pextra_hfill = par->pextra_hfill;
1469         pextra_start_minipage = par->pextra_start_minipage;
1470
1471         noindent = par->noindent;
1472         depth = par->depth;
1473 }
1474
1475
1476 LyXParagraph * LyXParagraph::FirstSelfrowPar()
1477 {
1478         LyXParagraph * tmppar = this;
1479         while (tmppar && (
1480                 (tmppar->IsDummy()
1481                  && tmppar->previous->footnoteflag ==
1482                  LyXParagraph::CLOSED_FOOTNOTE)
1483                 || tmppar->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE))
1484                 tmppar = tmppar->previous;
1485
1486         if (!tmppar)
1487                 return this;  // This should never happen!
1488         else
1489                 return tmppar;
1490 }
1491
1492
1493 LyXParagraph * LyXParagraph::Clone() const
1494 {
1495         // create a new paragraph
1496         LyXParagraph * result = new LyXParagraph;
1497
1498         result->MakeSameLayout(this);
1499
1500         // this is because of the dummy layout of the paragraphs that
1501         // follow footnotes
1502         result->layout = layout;
1503
1504         /* table stuff -- begin*/
1505         if (table)
1506                 result->table = table->Clone();
1507         else
1508                 result->table = 0;
1509         /* table stuff -- end*/
1510
1511         result->inset_owner = inset_owner;
1512
1513         // ale970302
1514         result->bibkey = (bibkey) ? new InsetBibKey(bibkey): 0;
1515
1516
1517         // copy everything behind the break-position to the new paragraph
1518
1519         result->text = text;
1520         result->fontlist = fontlist;
1521         result->insetlist = insetlist;
1522         for (InsetList::iterator it = result->insetlist.begin();
1523              it != result->insetlist.end(); ++it)
1524                 (*it).inset = (*it).inset->Clone();
1525         return result;
1526 }
1527
1528
1529 bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const
1530 {
1531         par = par->FirstPhysicalPar();
1532
1533         return (
1534                 par->footnoteflag == footnoteflag &&
1535                 par->footnotekind == footnotekind &&
1536
1537                 par->layout == layout &&
1538
1539                 par->align == align &&
1540
1541                 par->line_bottom == line_bottom &&
1542                 par->pagebreak_bottom == pagebreak_bottom &&
1543                 par->added_space_bottom == added_space_bottom &&
1544
1545                 par->line_top == line_top &&
1546                 par->pagebreak_top == pagebreak_top &&
1547                 par->added_space_top == added_space_top &&
1548
1549                 par->spacing == spacing &&
1550
1551                 par->pextra_type == pextra_type &&
1552                 par->pextra_width == pextra_width &&
1553                 par->pextra_widthp == pextra_widthp &&
1554                 par->pextra_alignment == pextra_alignment &&
1555                 par->pextra_hfill == pextra_hfill &&
1556                 par->pextra_start_minipage == pextra_start_minipage &&
1557
1558                 par->table == table && // what means: NO TABLE AT ALL
1559
1560                 par->noindent == noindent &&
1561                 par->depth == depth);
1562 }
1563
1564
1565 void LyXParagraph::BreakParagraphConservative(LyXParagraph::size_type pos)
1566 {
1567         // create a new paragraph
1568         LyXParagraph * par = ParFromPos(pos);
1569
1570         LyXParagraph * tmp = new LyXParagraph(par);
1571
1572         tmp->MakeSameLayout(par);
1573
1574         // When can pos < Last()?
1575         // I guess pos == Last() is possible.
1576         if (Last() > pos) {
1577                 // copy everything behind the break-position to the new
1578                 // paragraph
1579                 size_type pos_first = 0;
1580                 while (ParFromPos(pos_first) != par)
1581                         ++pos_first;
1582                 size_type pos_end = pos_first + par->text.size() - 1;
1583
1584                 size_type i, j;
1585                 for (i = j = pos; i <= pos_end; ++i) {
1586                         par->CutIntoMinibuffer(i - pos_first);
1587                         if (tmp->InsertFromMinibuffer(j - pos))
1588                                 ++j;
1589                 }
1590                 tmp->text.resize(tmp->text.size());
1591                 for (size_type i = pos_end; i >= pos; --i)
1592                         par->Erase(i - pos_first);
1593
1594                 par->text.resize(par->text.size());
1595         }
1596 }
1597
1598
1599 // Be carefull, this does not make any check at all.
1600 void LyXParagraph::PasteParagraph()
1601 {
1602         // copy the next paragraph to this one
1603         LyXParagraph * the_next = Next();
1604
1605         LyXParagraph * firstpar = FirstPhysicalPar();
1606
1607         // first the DTP-stuff
1608         firstpar->line_bottom = the_next->line_bottom;
1609         firstpar->added_space_bottom = the_next->added_space_bottom;
1610         firstpar->pagebreak_bottom = the_next->pagebreak_bottom;
1611
1612         size_type pos_end = the_next->text.size() - 1;
1613         size_type pos_insert = Last();
1614
1615         // ok, now copy the paragraph
1616         size_type i, j;
1617         for (i = j = 0; i <= pos_end; ++i) {
1618                 the_next->CutIntoMinibuffer(i);
1619                 if (InsertFromMinibuffer(pos_insert + j))
1620                         ++j;
1621         }
1622
1623         // delete the next paragraph
1624         delete the_next;
1625 }
1626
1627
1628 void LyXParagraph::OpenFootnote(LyXParagraph::size_type pos)
1629 {
1630         LyXParagraph * par = ParFromPos(pos);
1631         par = par->next;
1632         while (par && par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
1633                 par->footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
1634                 par = par->next;
1635         }
1636 }
1637
1638
1639 void LyXParagraph::CloseFootnote(LyXParagraph::size_type pos)
1640 {
1641         LyXParagraph * par = ParFromPos(pos);
1642         par = par->next;
1643         while (par && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) {
1644                 par->footnoteflag = LyXParagraph::CLOSED_FOOTNOTE;
1645                 par = par->next;
1646         }
1647 }
1648
1649 int LyXParagraph::GetEndLabel() const
1650 {
1651         LyXParagraph const * par = this;
1652         int par_depth = GetDepth();
1653         while (par) {
1654                 LyXTextClass::LayoutList::size_type layout = par->GetLayout();
1655                 int endlabeltype =
1656                         textclasslist.Style(current_view->buffer()->params.textclass,
1657                                             layout).endlabeltype;
1658                 if (endlabeltype != END_LABEL_NO_LABEL) {
1659                         LyXParagraph const * last = this;
1660                         if( footnoteflag == NO_FOOTNOTE)
1661                                 last = LastPhysicalPar();
1662                         else if (next->footnoteflag == NO_FOOTNOTE)
1663                                 return endlabeltype;
1664
1665                         if (!last || !last->next)
1666                                 return endlabeltype;
1667
1668                         int next_depth = last->next->GetDepth();
1669                         if (par_depth > next_depth ||
1670                             (par_depth == next_depth && layout != last->next->GetLayout() ))
1671                                 return endlabeltype;
1672                         break;
1673                 }
1674                 if (par_depth == 0)
1675                         break;
1676                 par = par->DepthHook(par_depth - 1);
1677                 if (par)
1678                         par_depth = par->GetDepth();
1679         }
1680         return END_LABEL_NO_LABEL;
1681 }
1682
1683
1684 LyXTextClass::size_type LyXParagraph::GetLayout() const
1685 {
1686         return FirstPhysicalPar()->layout;
1687 }
1688
1689
1690 char LyXParagraph::GetDepth() const
1691 {
1692         return FirstPhysicalPar()->depth;
1693 }
1694
1695
1696 char LyXParagraph::GetAlign() const
1697 {
1698         return FirstPhysicalPar()->align;
1699 }
1700
1701
1702 string LyXParagraph::GetLabelstring() const
1703 {
1704         return FirstPhysicalPar()->labelstring;
1705 }
1706
1707
1708 int LyXParagraph::GetFirstCounter(int i) const
1709 {
1710         return FirstPhysicalPar()->counter_[i];
1711 }
1712
1713
1714 // the next two functions are for the manual labels
1715 string LyXParagraph::GetLabelWidthString() const
1716 {
1717         if (!FirstPhysicalPar()->labelwidthstring.empty())
1718                 return FirstPhysicalPar()->labelwidthstring;
1719         else
1720                 return _("Senseless with this layout!");
1721 }
1722
1723
1724 void LyXParagraph::SetLabelWidthString(string const & s)
1725 {
1726         LyXParagraph * par = FirstPhysicalPar();
1727
1728         par->labelwidthstring = s;
1729 }
1730
1731
1732 void LyXParagraph::SetOnlyLayout(LyXTextClass::size_type new_layout)
1733 {
1734         LyXParagraph * par = FirstPhysicalPar();
1735         LyXParagraph * ppar = 0;
1736         LyXParagraph * npar = 0;
1737
1738         par->layout = new_layout;
1739         /* table stuff -- begin*/
1740         if (table)
1741                 par->layout = 0;
1742         /* table stuff -- end*/
1743         if (par->pextra_type == PEXTRA_NONE) {
1744                 if (par->Previous()) {
1745                         ppar = par->Previous()->FirstPhysicalPar();
1746                         while(ppar
1747                               && ppar->Previous()
1748                               && (ppar->depth > par->depth))
1749                                 ppar = ppar->Previous()->FirstPhysicalPar();
1750                 }
1751                 if (par->Next()) {
1752                         npar = par->Next()->NextAfterFootnote();
1753                         while(npar
1754                               && npar->Next()
1755                               && (npar->depth > par->depth))
1756                                 npar = npar->Next()->NextAfterFootnote();
1757                 }
1758                 if (ppar && (ppar->pextra_type != PEXTRA_NONE)) {
1759                         string
1760                                 p1 = ppar->pextra_width,
1761                                 p2 = ppar->pextra_widthp;
1762                         ppar->SetPExtraType(ppar->pextra_type,
1763                                             p1.c_str(), p2.c_str());
1764                 }
1765                 if ((par->pextra_type == PEXTRA_NONE) &&
1766                     npar && (npar->pextra_type != PEXTRA_NONE)) {
1767                         string
1768                                 p1 = npar->pextra_width,
1769                                 p2 = npar->pextra_widthp;
1770                         npar->SetPExtraType(npar->pextra_type,
1771                                             p1.c_str(), p2.c_str());
1772                 }
1773         }
1774 }
1775
1776
1777 void LyXParagraph::SetLayout(LyXTextClass::size_type new_layout)
1778 {
1779         LyXParagraph
1780                 * par = FirstPhysicalPar(),
1781                 * ppar = 0,
1782                 * npar = 0;
1783
1784         par->layout = new_layout;
1785         par->labelwidthstring.erase();
1786         par->align = LYX_ALIGN_LAYOUT;
1787         par->added_space_top = VSpace(VSpace::NONE);
1788         par->added_space_bottom = VSpace(VSpace::NONE);
1789         par->spacing.set(Spacing::Default);
1790
1791         /* table stuff -- begin*/
1792         if (table)
1793                 par->layout = 0;
1794         /* table stuff -- end*/
1795         if (par->pextra_type == PEXTRA_NONE) {
1796                 if (par->Previous()) {
1797                         ppar = par->Previous()->FirstPhysicalPar();
1798                         while(ppar
1799                               && ppar->Previous()
1800                               && (ppar->depth > par->depth))
1801                                 ppar = ppar->Previous()->FirstPhysicalPar();
1802                 }
1803                 if (par->Next()) {
1804                         npar = par->Next()->NextAfterFootnote();
1805                         while(npar
1806                               && npar->Next()
1807                               && (npar->depth > par->depth))
1808                                 npar = npar->Next()->NextAfterFootnote();
1809                 }
1810                 if (ppar && (ppar->pextra_type != PEXTRA_NONE)) {
1811                         string
1812                                 p1 = ppar->pextra_width,
1813                                 p2 = ppar->pextra_widthp;
1814                         ppar->SetPExtraType(ppar->pextra_type,
1815                                             p1.c_str(), p2.c_str());
1816                 }
1817                 if ((par->pextra_type == PEXTRA_NONE) &&
1818                     npar && (npar->pextra_type != PEXTRA_NONE)) {
1819                         string
1820                                 p1 = npar->pextra_width,
1821                                 p2 = npar->pextra_widthp;
1822                         npar->SetPExtraType(npar->pextra_type,
1823                                             p1.c_str(), p2.c_str());
1824                 }
1825         }
1826 }
1827
1828
1829 // if the layout of a paragraph contains a manual label, the beginning of the
1830 // main body is the beginning of the second word. This is what the par-
1831 // function returns. If the layout does not contain a label, the main
1832 // body always starts with position 0. This differentiation is necessary,
1833 // because there cannot be a newline or a blank <= the beginning of the
1834 // main body in TeX.
1835
1836 int LyXParagraph::BeginningOfMainBody() const
1837 {
1838         if (FirstPhysicalPar() != this)
1839                 return -1;
1840
1841         // Unroll the first two cycles of the loop
1842         // and remember the previous character to
1843         // remove unnecessary GetChar() calls
1844         size_type i = 0;
1845         if (i < size()
1846             && GetChar(i) != LyXParagraph::META_NEWLINE
1847                 ) {
1848                 ++i;
1849                 char previous_char = 0, temp = 0;
1850                 if (i < size()
1851                     && (previous_char = GetChar(i)) != LyXParagraph::META_NEWLINE) {
1852                         // Yes, this  ^ is supposed to be "= " not "=="
1853                         ++i;
1854                         while (i < size()
1855                                && previous_char != ' '
1856                                && (temp = GetChar(i)) != LyXParagraph::META_NEWLINE) {
1857                                 ++i;
1858                                 previous_char = temp;
1859                         }
1860                 }
1861         }
1862
1863         if (i == 0 && i == size() &&
1864             !(footnoteflag == LyXParagraph::NO_FOOTNOTE
1865               && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE))
1866                 ++i;                           /* the cursor should not jump
1867                                                 * to the main body if there
1868                                                 * is nothing in! */
1869         return i;
1870 }
1871
1872
1873 LyXParagraph * LyXParagraph::DepthHook(int deth)
1874 {
1875         LyXParagraph * newpar = this;
1876         if (deth < 0)
1877                 return 0;
1878
1879         do {
1880                 newpar = newpar->FirstPhysicalPar()->Previous();
1881         } while (newpar && newpar->GetDepth() > deth
1882                  && newpar->footnoteflag == footnoteflag);
1883
1884         if (!newpar) {
1885                 if (Previous() || GetDepth())
1886                         lyxerr << "ERROR (LyXParagraph::DepthHook): "
1887                                 "no hook." << endl;
1888                 newpar = this;
1889         }
1890         return newpar->FirstPhysicalPar();
1891 }
1892
1893
1894 LyXParagraph const * LyXParagraph::DepthHook(int deth) const
1895 {
1896         LyXParagraph const * newpar = this;
1897         if (deth < 0)
1898                 return 0;
1899
1900         do {
1901                 newpar = newpar->FirstPhysicalPar()->Previous();
1902         } while (newpar && newpar->GetDepth() > deth
1903                  && newpar->footnoteflag == footnoteflag);
1904
1905         if (!newpar) {
1906                 if (Previous() || GetDepth())
1907                         lyxerr << "ERROR (LyXParagraph::DepthHook): "
1908                                 "no hook." << endl;
1909                 newpar = this;
1910         }
1911         return newpar->FirstPhysicalPar();
1912 }
1913
1914
1915 int LyXParagraph::AutoDeleteInsets()
1916 {
1917         int count = 0;
1918         InsetList::size_type index = 0;
1919         while (index < insetlist.size()) {
1920                 if (insetlist[index].inset && insetlist[index].inset->AutoDelete()) {
1921                         Erase(insetlist[index].pos);
1922                         // Erase() calls to insetlist.erase(&insetlist[index])
1923                         // so index shouldn't be increased.
1924                         ++count;
1925                 } else
1926                         ++index;
1927         }
1928         return count;
1929 }
1930
1931
1932 Inset * LyXParagraph::ReturnNextInsetPointer(LyXParagraph::size_type & pos)
1933 {
1934         InsetList::iterator it = lower_bound(insetlist.begin(),
1935                                              insetlist.end(),
1936                                              pos, matchIT());
1937         if (it != insetlist.end()) {
1938                 pos = (*it).pos;
1939                 return (*it).inset;
1940         }
1941         return 0;
1942 }
1943
1944
1945 // returns -1 if inset not found
1946 int LyXParagraph::GetPositionOfInset(Inset * inset) const
1947 {
1948         // Find the entry.
1949         // We could use lower_bound here too, we just need to add
1950         // the approp. operator() to matchIT (and change the name
1951         // of that struct). Code would then be:
1952         // InsetList::const_iterator cit = lower_bound(insetlist.begin(),
1953         //                                             insetlist.end(),
1954         //                                             inset, matchIT());
1955         // if ((*cit).inset == inset) {
1956         //         return (*cit).pos;
1957         // }
1958         for (InsetList::const_iterator cit = insetlist.begin();
1959              cit != insetlist.end(); ++cit) {
1960                 if ((*cit).inset == inset) {
1961                         return (*cit).pos;
1962                 }
1963         }
1964         // Think about footnotes.
1965         if (footnoteflag == LyXParagraph::NO_FOOTNOTE
1966             && next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) {
1967                 int further =
1968                         NextAfterFootnote()->GetPositionOfInset(inset);
1969                 if (further != -1)
1970                         return text.size() + 1 + further;
1971         }
1972         return -1;
1973 }
1974
1975
1976 LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow,
1977                                        bool moving_arg,
1978                                        ostream & foot,
1979                                        TexRow & foot_texrow,
1980                                        int & foot_count)
1981 {
1982         lyxerr[Debug::LATEX] << "TeXOnePar...     " << this << endl;
1983         LyXLayout const & style =
1984                 textclasslist.Style(current_view->buffer()->params.textclass,
1985                                     layout);
1986
1987         bool further_blank_line = false;
1988         if (IsDummy())
1989                 lyxerr << "ERROR (LyXParagraph::TeXOnePar) is dummy." << endl;
1990
1991         if (start_of_appendix) {
1992                 os << "\\appendix\n";
1993                 texrow.newline();
1994         }
1995
1996         if (!spacing.isDefault()
1997             && (!Previous() || !Previous()->HasSameLayout(this))) {
1998                 os << spacing.writeEnvirBegin() << "\n";
1999                 texrow.newline();
2000         }
2001
2002         if (tex_code_break_column && style.isCommand()){
2003                 os << '\n';
2004                 texrow.newline();
2005         }
2006
2007         if (pagebreak_top) {
2008                 os << "\\newpage";
2009                 further_blank_line = true;
2010         }
2011         if (added_space_top.kind() != VSpace::NONE) {
2012                 os << added_space_top.asLatexCommand(current_view->buffer()->params);
2013                 further_blank_line = true;
2014         }
2015
2016         if (line_top) {
2017                 os << "\\lyxline{\\" << getFont(0).latexSize() << '}'
2018                    << "\\vspace{-1\\parskip}";
2019                 further_blank_line = true;
2020         }
2021
2022         if (further_blank_line){
2023                 os << '\n';
2024                 texrow.newline();
2025         }
2026
2027         Language const * language = getParLanguage();
2028         Language const * doc_language = current_view->buffer()->params.language_info;
2029         if (language != doc_language) {
2030                 os << subst(lyxrc.language_command_begin, "$$lang",
2031                             language->lang)
2032                    << endl;
2033                 texrow.newline();
2034         }
2035
2036         switch (style.latextype) {
2037         case LATEX_COMMAND:
2038                 os << '\\'
2039                    << style.latexname()
2040                    << style.latexparam();
2041                 break;
2042         case LATEX_ITEM_ENVIRONMENT:
2043                 if (bibkey) {
2044                         bibkey->Latex(os, false, false);
2045                 } else
2046                         os << "\\item ";
2047                 break;
2048         case LATEX_LIST_ENVIRONMENT:
2049                 os << "\\item ";
2050                 break;
2051         default:
2052                 break;
2053         }
2054
2055         bool need_par = SimpleTeXOnePar(os, texrow, moving_arg);
2056
2057         // Spit out footnotes
2058         LyXParagraph * par = next;
2059         if (lyxrc.rtl_support) {
2060                 if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE
2061                     && next->footnoteflag != footnoteflag) {
2062                         LyXParagraph * p = 0;
2063                         bool is_rtl = GetFontSettings(size()-1).isRightToLeft();
2064                         if ( (p = NextAfterFootnote()) != 0 &&
2065                              p->GetFontSettings(0).isRightToLeft() != is_rtl)
2066                                 is_rtl = GetFontSettings(0).isRightToLeft();
2067                         while (par &&
2068                                par->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
2069                                par->footnoteflag != footnoteflag) {
2070                                 par = par->TeXFootnote(os, texrow, foot,
2071                                                        foot_texrow, foot_count,
2072                                                        is_rtl);
2073                                 par->SimpleTeXOnePar(os, texrow, moving_arg);
2074                                 is_rtl = par->GetFontSettings(par->size()-1).isRightToLeft();
2075                                 if (par->next &&
2076                                     par->next->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
2077                                     (p = par->NextAfterFootnote()) != 0 &&
2078                                     p->GetFontSettings(0).isRightToLeft() != is_rtl)
2079                                         is_rtl = GetFontSettings(0).isRightToLeft();
2080                                 par = par->next;
2081                         }
2082                 }
2083         } else {
2084                 while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE
2085                        && par->footnoteflag != footnoteflag) {
2086                         par = par->TeXFootnote(os, texrow,
2087                                                foot, foot_texrow, foot_count,
2088                                                false);
2089                         par->SimpleTeXOnePar(os, texrow, moving_arg);
2090                         par = par->next;
2091                 }
2092         }
2093
2094         // Make sure that \\par is done with the font of the last
2095         // character if this has another size as the default.
2096         // This is necessary because LaTeX (and LyX on the screen)
2097         // calculates the space between the baselines according
2098         // to this font. (Matthias)
2099         LyXFont font = getFont(Last() - 1);
2100         if (need_par) {
2101                 if (style.resfont.size() != font.size()) {
2102                         os << '\\'
2103                            << font.latexSize()
2104                            << ' ';
2105                 }
2106                 os << "\\par}";
2107         } else if (textclasslist.Style(current_view->buffer()->params.textclass,
2108                                        GetLayout()).isCommand()){
2109                 if (style.resfont.size() != font.size()) {
2110                         os << '\\'
2111                            << font.latexSize()
2112                            << ' ';
2113                 }
2114                 os << '}';
2115         } else if (style.resfont.size() != font.size()){
2116                 os << "{\\" << font.latexSize() << " \\par}";
2117         }
2118
2119         if (language != doc_language) {
2120                 os << endl
2121                    << subst(lyxrc.language_command_end, "$$lang",
2122                             doc_language->lang);
2123         }
2124
2125         switch (style.latextype) {
2126         case LATEX_ITEM_ENVIRONMENT:
2127         case LATEX_LIST_ENVIRONMENT:
2128                 if (par && (depth < par->depth)) {
2129                         os << '\n';
2130                         texrow.newline();
2131                 }
2132                 break;
2133         case LATEX_ENVIRONMENT:
2134                 // if its the last paragraph of the current environment
2135                 // skip it otherwise fall through
2136                 if (par
2137                     && (par->layout != layout
2138                         || par->depth != depth
2139                         || par->pextra_type != pextra_type))
2140                         break;
2141         default:
2142                 // we don't need it for the last paragraph!!!
2143                 if (next && !(footnoteflag != LyXParagraph::NO_FOOTNOTE
2144                       && footnotekind != LyXParagraph::FOOTNOTE
2145                       && footnotekind != LyXParagraph::MARGIN
2146                       && (table
2147                           || (par
2148                               && par->table)))) {
2149                         // don't insert this if we would be adding it
2150                         // before or after a table in a float.  This
2151                         // little trick is needed in order to allow
2152                         // use of tables in \subfigures or \subtables.
2153                         os << '\n';
2154                         texrow.newline();
2155                 }
2156         }
2157
2158         further_blank_line = false;
2159         if (line_bottom) {
2160                 os << "\\lyxline{\\" << getFont(Last() - 1).latexSize() << '}';
2161                 further_blank_line = true;
2162         }
2163
2164         if (added_space_bottom.kind() != VSpace::NONE) {
2165                 os << added_space_bottom.asLatexCommand(current_view->buffer()->params);
2166                 further_blank_line = true;
2167         }
2168
2169         if (pagebreak_bottom) {
2170                 os << "\\newpage";
2171                 further_blank_line = true;
2172         }
2173
2174         if (further_blank_line){
2175                 os << '\n';
2176                 texrow.newline();
2177         }
2178
2179         if (!spacing.isDefault()
2180             && (!par || !par->HasSameLayout(this))) {
2181                 os << spacing.writeEnvirEnd() << "\n";
2182                 texrow.newline();
2183         }
2184
2185         // we don't need it for the last paragraph!!!
2186         if (next && !(footnoteflag != LyXParagraph::NO_FOOTNOTE && par &&
2187               par->footnoteflag == LyXParagraph::NO_FOOTNOTE)) {
2188                 os << '\n';
2189                 texrow.newline();
2190         }
2191
2192         lyxerr[Debug::LATEX] << "TeXOnePar...done " << par << endl;
2193         return par;
2194 }
2195
2196
2197 // This one spits out the text of the paragraph
2198 bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow,
2199                                    bool moving_arg)
2200 {
2201         lyxerr[Debug::LATEX] << "SimpleTeXOnePar...     " << this << endl;
2202
2203         if (table)
2204                 return SimpleTeXOneTablePar(os, texrow);
2205
2206         bool return_value = false;
2207
2208         LyXLayout const & style =
2209                 textclasslist.Style(current_view->buffer()->params.textclass,
2210                                     GetLayout());
2211         LyXFont basefont, last_font;
2212
2213         // Maybe we have to create a optional argument.
2214         size_type main_body;
2215         if (style.labeltype != LABEL_MANUAL)
2216                 main_body = 0;
2217         else
2218                 main_body = BeginningOfMainBody();
2219
2220         if (main_body > 0) {
2221                 os << '[';
2222                 basefont = getFont(-2); // Get label font
2223         } else {
2224                 basefont = getFont(-1); // Get layout font
2225         }
2226
2227         int column = 0;
2228
2229         if (main_body >= 0
2230             && !text.size()
2231             && !IsDummy()) {
2232                 if (style.isCommand()) {
2233                         os << '{';
2234                         ++column;
2235                 } else if (align != LYX_ALIGN_LAYOUT) {
2236                         os << '{';
2237                         ++column;
2238                         return_value = true;
2239                 }
2240         }
2241
2242         moving_arg |= style.needprotect;
2243
2244         // Which font is currently active?
2245         LyXFont running_font(basefont);
2246         // Do we have an open font change?
2247         bool open_font = false;
2248
2249         texrow.start(this, 0);
2250
2251         for (size_type i = 0; i < size(); ++i) {
2252                 ++column;
2253                 // First char in paragraph or after label?
2254                 if (i == main_body && !IsDummy()) {
2255                         if (main_body > 0) {
2256                                 if (open_font) {
2257                                         column += running_font.latexWriteEndChanges(os, basefont, basefont);
2258                                         open_font = false;
2259                                 }
2260                                 basefont = getFont(-1); // Now use the layout font
2261                                 running_font = basefont;
2262                                 os << ']';
2263                                 ++column;
2264                         }
2265                         if (style.isCommand()) {
2266                                 os << '{';
2267                                 ++column;
2268                         } else if (align != LYX_ALIGN_LAYOUT) {
2269                                 os << "{\\par";
2270                                 column += 4;
2271                                 return_value = true;
2272                         }
2273
2274                         if (noindent) {
2275                                 os << "\\noindent ";
2276                                 column += 10;
2277                         }
2278                         switch (align) {
2279                         case LYX_ALIGN_NONE:
2280                         case LYX_ALIGN_BLOCK:
2281                         case LYX_ALIGN_LAYOUT:
2282                         case LYX_ALIGN_SPECIAL:
2283                                 break;
2284                         case LYX_ALIGN_LEFT:
2285                                 if (getParLanguage()->lang != "hebrew") {
2286                                         os << "\\raggedright ";
2287                                         column+= 13;
2288                                 } else {
2289                                         os << "\\raggedleft ";
2290                                         column+= 12;
2291                                 }
2292                                 break;
2293                         case LYX_ALIGN_RIGHT:
2294                                 if (getParLanguage()->lang != "hebrew") {
2295                                         os << "\\raggedleft ";
2296                                         column+= 12;
2297                                 } else {
2298                                         os << "\\raggedright ";
2299                                         column+= 13;
2300                                 }
2301                                 break;
2302                         case LYX_ALIGN_CENTER:
2303                                 os << "\\centering ";
2304                                 column+= 11;
2305                                 break;
2306                         }
2307                 }
2308
2309                 int c = GetChar(i);
2310
2311                 // Fully instantiated font
2312                 LyXFont font = getFont(i);
2313                 LyXParagraph * p = 0;
2314                 if (i == 0 && previous &&
2315                     previous->footnoteflag != LyXParagraph::NO_FOOTNOTE &&
2316                     (p = PreviousBeforeFootnote()) != 0)
2317                         last_font = p->getFont(p->size()-1);
2318                 else
2319                         last_font = running_font;
2320
2321                 // Spaces at end of font change are simulated to be
2322                 // outside font change, i.e. we write "\textXX{text} "
2323                 // rather than "\textXX{text }". (Asger)
2324                 if (open_font && c == ' ' && i <= size() - 2
2325                     && !getFont(i+1).equalExceptLatex(running_font)
2326                     && !getFont(i+1).equalExceptLatex(font)) {
2327                         font = getFont(i + 1);
2328                 }
2329                 // We end font definition before blanks
2330                 if (!font.equalExceptLatex(running_font) && open_font) {
2331                         column += running_font.latexWriteEndChanges(os,
2332                                                                     basefont,
2333                                                                     (i == main_body-1) ? basefont : font);
2334                         running_font = basefont;
2335                         open_font = false;
2336                 }
2337
2338                 // Blanks are printed before start of fontswitch
2339                 if (c == ' '){
2340                         // Do not print the separation of the optional argument
2341                         if (i != main_body - 1) {
2342                                 SimpleTeXBlanks(os, texrow, i,
2343                                                 column, font, style);
2344                         }
2345                 }
2346
2347                 // Do we need to change font?
2348                 if (!font.equalExceptLatex(running_font)
2349                     && i != main_body-1) {
2350                         column += font.latexWriteStartChanges(os, basefont,
2351                                                               last_font);
2352                         running_font = font;
2353                         open_font = true;
2354                 }
2355
2356                 if (c == LyXParagraph::META_NEWLINE) {
2357                         // newlines are handled differently here than
2358                         // the default in SimpleTeXSpecialChars().
2359                         if (!style.newline_allowed
2360                             || font.latex() == LyXFont::ON) {
2361                                 os << '\n';
2362                         } else {
2363                                 if (open_font) {
2364                                         column += running_font.latexWriteEndChanges(os, basefont, basefont);
2365                                         open_font = false;
2366                                 }
2367                                 basefont = getFont(-1);
2368                                 running_font = basefont;
2369                                 if (font.family() ==
2370                                     LyXFont::TYPEWRITER_FAMILY) {
2371                                         os << "~";
2372                                 }
2373                                 if (moving_arg)
2374                                         os << "\\protect ";
2375                                 os << "\\\\\n";
2376                         }
2377                         texrow.newline();
2378                         texrow.start(this, i + 1);
2379                         column = 0;
2380                 } else {
2381                         SimpleTeXSpecialChars(os, texrow, moving_arg,
2382                                               font, running_font, basefont,
2383                                               open_font, style, i, column, c);
2384                 }
2385         }
2386
2387         // If we have an open font definition, we have to close it
2388         if (open_font) {
2389                 LyXParagraph * p = 0;
2390                 if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE
2391                     && (p =  NextAfterFootnote()) != 0)
2392                         running_font.latexWriteEndChanges(os, basefont,
2393                                                           p->getFont(0));
2394                 else
2395                         running_font.latexWriteEndChanges(os, basefont, basefont);
2396         }
2397
2398         // Needed if there is an optional argument but no contents.
2399         if (main_body > 0 && main_body == size()) {
2400                 os << "]~";
2401                 return_value = false;
2402         }
2403
2404         lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl;
2405         return return_value;
2406 }
2407
2408
2409 // This one spits out the text of a table paragraph
2410 bool LyXParagraph::SimpleTeXOneTablePar(ostream & os, TexRow & texrow)
2411 {
2412         lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar...     " << this << endl;
2413
2414         bool return_value = false;
2415
2416         LyXLayout const & style =
2417                 textclasslist.Style(current_view->buffer()->params.textclass,
2418                                     GetLayout());
2419
2420         int column = 0;
2421         if (!IsDummy()) { // it is dummy if it is in a float!!!
2422                 if (style.isCommand()) {
2423                         os << '{';
2424                         ++column;
2425                 } else if (align != LYX_ALIGN_LAYOUT) {
2426                         os << '{';
2427                         ++column;
2428                         return_value = true;
2429                 }
2430                 if (noindent) {
2431                         os << "\\noindent ";
2432                         column += 10;
2433                 }
2434                 switch (align) {
2435                 case LYX_ALIGN_NONE:
2436                 case LYX_ALIGN_BLOCK:
2437                 case LYX_ALIGN_LAYOUT:
2438                 case LYX_ALIGN_SPECIAL: break;
2439                 case LYX_ALIGN_LEFT:
2440                         os << "\\raggedright ";
2441                         column+= 13;
2442                         break;
2443                 case LYX_ALIGN_RIGHT:
2444                         os << "\\raggedleft ";
2445                         column+= 12;
2446                         break;
2447                 case LYX_ALIGN_CENTER:
2448                         os << "\\centering ";
2449                         column+= 11;
2450                         break;
2451                 }
2452         }
2453
2454         LyXFont basefont = getFont(-1); // Get layout font
2455         // Which font is currently active?
2456         LyXFont running_font = basefont;
2457         LyXFont last_font;
2458         // Do we have an open font change?
2459         bool open_font = false;
2460         int current_cell_number = -1;
2461         int tmp = table->TexEndOfCell(os, current_cell_number);
2462         for (; tmp > 0 ; --tmp)
2463                 texrow.newline();
2464
2465         texrow.start(this, 0);
2466
2467         bool is_rtl = getParLanguage()->RightToLeft;
2468         bool first_in_cell = true;
2469
2470         for (size_type i = 0; i < size(); ++i) {
2471                 char c = GetChar(i);
2472                 if (table->IsContRow(current_cell_number + 1)) {
2473                         if (c == LyXParagraph::META_NEWLINE)
2474                                 ++current_cell_number;
2475                         continue;
2476                 }
2477                 ++column;
2478
2479                 if (first_in_cell && is_rtl) {
2480                         os << "\\R{";
2481                         column += 3;
2482                         first_in_cell = false;
2483                 }
2484
2485                 // Fully instantiated font
2486                 LyXFont font = getFont(i);
2487                 last_font = running_font;
2488
2489                 // Spaces at end of font change are simulated to be
2490                 // outside font change.
2491                 // i.e. we write "\textXX{text} " rather than
2492                 // "\textXX{text }". (Asger)
2493                 if (open_font && c == ' ' && i <= size() - 2
2494                     && getFont(i + 1) != running_font
2495                     && getFont(i + 1) != font) {
2496                         font = getFont(i + 1);
2497                 }
2498
2499                 // We end font definition before blanks
2500                 if (font != running_font && open_font) {
2501                         column += running_font.latexWriteEndChanges(os,
2502                                                                     basefont,
2503                                                                     font);
2504                         running_font = basefont;
2505                         open_font = false;
2506                 }
2507                 // Blanks are printed before start of fontswitch
2508                 if (c == ' '){
2509                         SimpleTeXBlanks(os, texrow, i, column, font, style);
2510                 }
2511                 // Do we need to change font?
2512                 if (font != running_font) {
2513                         column += font.latexWriteStartChanges(os, basefont,
2514                                                               last_font);
2515                         running_font = font;
2516                         open_font = true;
2517                 }
2518                 // Do we need to turn on LaTeX mode?
2519                 if (font.latex() != running_font.latex()) {
2520                         if (font.latex() == LyXFont::ON
2521                             && style.needprotect) {
2522                                 os << "\\protect ";
2523                                 column += 9;
2524                         }
2525                 }
2526                 if (c == LyXParagraph::META_NEWLINE) {
2527                         // special case for inside a table
2528                         // different from default case in
2529                         // SimpleTeXSpecialChars()
2530                         if (open_font) {
2531                                 column += running_font
2532                                         .latexWriteEndChanges(os, basefont,
2533                                                               basefont);
2534                                 open_font = false;
2535                         }
2536                         basefont = getFont(-1);
2537                         running_font = basefont;
2538                         ++current_cell_number;
2539                         if (table->CellHasContRow(current_cell_number) >= 0) {
2540                                 TeXContTableRows(os, i + 1,
2541                                                  current_cell_number,
2542                                                  column, texrow);
2543                         }
2544                         if (is_rtl && !first_in_cell) {
2545                                 os << "}";
2546                                 first_in_cell = true;
2547                         }
2548
2549                         // if this cell follow only ContRows till end don't
2550                         // put the EndOfCell because it is put after the
2551                         // for(...)
2552                         if (table->ShouldBeVeryLastCell(current_cell_number)) {
2553                                 --current_cell_number;
2554                                 break;
2555                         }
2556                         int tmp = table->TexEndOfCell(os,
2557                                                       current_cell_number);
2558                         if (tmp > 0) {
2559                                 column = 0;
2560                         } else if (tmp < 0) {
2561                                 tmp = -tmp;
2562                         }
2563                         for (; tmp--;) {
2564                                 texrow.newline();
2565                         }
2566                         texrow.start(this, i + 1);
2567                 } else {
2568                         SimpleTeXSpecialChars(os, texrow, false,
2569                                               font, running_font, basefont,
2570                                               open_font, style, i, column, c);
2571                 }
2572         }
2573
2574         // If we have an open font definition, we have to close it
2575         if (open_font) {
2576                 running_font.latexWriteEndChanges(os, basefont, basefont);
2577         }
2578         ++current_cell_number;
2579         if (is_rtl && !first_in_cell)
2580                 os << "}";
2581         tmp = table->TexEndOfCell(os, current_cell_number);
2582         for (; tmp > 0; --tmp)
2583                 texrow.newline();
2584         lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar...done " << this << endl;
2585         return return_value;
2586 }
2587
2588
2589 // This one spits out the text off ContRows in tables
2590 bool LyXParagraph::TeXContTableRows(ostream & os,
2591                                     LyXParagraph::size_type i,
2592                                     int current_cell_number,
2593                                     int & column, TexRow & texrow)
2594 {
2595         lyxerr[Debug::LATEX] << "TeXContTableRows...     " << this << endl;
2596         if (!table)
2597                 return false;
2598
2599         char c;
2600
2601         bool return_value = false;
2602         LyXLayout const & style =
2603                 textclasslist.Style(current_view->buffer()->params.textclass,
2604                                     GetLayout());
2605         LyXFont basefont = getFont(-1); // Get layout font
2606         LyXFont last_font;
2607         // Which font is currently active?
2608         LyXFont running_font = basefont;
2609         // Do we have an open font change?
2610         bool open_font = false;
2611
2612         size_type lastpos = i;
2613         int cell = table->CellHasContRow(current_cell_number);
2614         ++current_cell_number;
2615         while(cell >= 0) {
2616                 // first find the right position
2617                 i = lastpos;
2618                 for (; (i < size()) && (current_cell_number<cell); ++i) {
2619                         c = GetChar(i);
2620                         if (c == LyXParagraph::META_NEWLINE)
2621                                 ++current_cell_number;
2622                 }
2623                 lastpos = i;
2624                 c = GetChar(i);
2625                 if (table->Linebreaks(table->FirstVirtualCell(cell))) {
2626                         os << " \\\\\n";
2627                         texrow.newline();
2628                         column = 0;
2629                 } else if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) {
2630                         os << ' ';
2631                 }
2632
2633                 for (; i < size()
2634                              && (c = GetChar(i)) != LyXParagraph::META_NEWLINE;
2635                      ++i) {
2636                         ++column;
2637
2638                         // Fully instantiated font
2639                         LyXFont font = getFont(i);
2640                         last_font = running_font;
2641
2642                         // Spaces at end of font change are simulated to
2643                         // be outside font change. i.e. we write
2644                         // "\textXX{text} " rather than "\textXX{text }".
2645                         // (Asger)
2646                         if (open_font && c == ' ' && i <= size() - 2
2647                             && getFont(i + 1) != running_font
2648                             && getFont(i + 1) != font) {
2649                                 font = getFont(i + 1);
2650                         }
2651
2652                         // We end font definition before blanks
2653                         if (font != running_font && open_font) {
2654                                 column += running_font.latexWriteEndChanges(os, basefont, font);
2655                                 running_font = basefont;
2656                                 open_font = false;
2657                         }
2658                         // Blanks are printed before start of fontswitch
2659                         if (c == ' '){
2660                                 SimpleTeXBlanks(os, texrow, i,
2661                                                 column, font, style);
2662                         }
2663                         // Do we need to change font?
2664                         if (font != running_font) {
2665                                 column +=
2666                                         font.latexWriteStartChanges(os,
2667                                                                     basefont,
2668                                                                     last_font);
2669                                 running_font = font;
2670                                 open_font = true;
2671                         }
2672                         // Do we need to turn on LaTeX mode?
2673                         if (font.latex() != running_font.latex()) {
2674                                 if (font.latex() == LyXFont::ON
2675                                     && style.needprotect) {
2676                                         os << "\\protect ";
2677                                         column += 9;
2678                                 }
2679                         }
2680                         SimpleTeXSpecialChars(os, texrow, false, font,
2681                                               running_font, basefont,
2682                                               open_font, style, i, column, c);
2683                 }
2684                 // If we have an open font definition, we have to close it
2685                 if (open_font) {
2686                         running_font.latexWriteEndChanges(os, basefont,
2687                                                           basefont);
2688                         open_font = false;
2689                 }
2690                 basefont = getFont(-1);
2691                 running_font = basefont;
2692                 cell = table->CellHasContRow(current_cell_number);
2693         }
2694         lyxerr[Debug::LATEX] << "TeXContTableRows...done " << this << endl;
2695         return return_value;
2696 }
2697
2698
2699 bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string)
2700 {
2701         bool retval = false;
2702         switch (c) {
2703         case LyXParagraph::META_HFILL:
2704                 sgml_string.erase();
2705                 break;
2706         case LyXParagraph::META_NEWLINE:
2707                 sgml_string = '\n';
2708                 break;
2709         case '&':
2710                 sgml_string = "&amp;";
2711                 break;
2712         case '<':
2713                 sgml_string = "&lt;";
2714                 break;
2715         case '>':
2716                 sgml_string = "&gt;";
2717                 break;
2718         case '$':
2719                 sgml_string = "&dollar;";
2720                 break;
2721         case '#':
2722                 sgml_string = "&num;";
2723                 break;
2724         case '%':
2725                 sgml_string = "&percnt;";
2726                 break;
2727         case '[':
2728                 sgml_string = "&lsqb;";
2729                 break;
2730         case ']':
2731                 sgml_string = "&rsqb;";
2732                 break;
2733         case '{':
2734                 sgml_string = "&lcub;";
2735                 break;
2736         case '}':
2737                 sgml_string = "&rcub;";
2738                 break;
2739         case '~':
2740                 sgml_string = "&tilde;";
2741                 break;
2742         case '"':
2743                 sgml_string = "&quot;";
2744                 break;
2745         case '\\':
2746                 sgml_string = "&bsol;";
2747                 break;
2748         case ' ':
2749                 retval = true;
2750                 sgml_string = ' ';
2751                 break;
2752         case '\0': // Ignore :-)
2753                 sgml_string.erase();
2754                 break;
2755         default:
2756                 sgml_string = c;
2757                 break;
2758         }
2759         return retval;
2760 }
2761
2762
2763 void LyXParagraph::SimpleDocBookOneTablePar(ostream & os, string & extra,
2764                                             int & desc_on, int depth)
2765 {
2766         if (!table) return;
2767         lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar... " << this << endl;
2768         int column = 0;
2769         LyXFont font1, font2;
2770         char c;
2771         Inset * inset;
2772         size_type main_body;
2773         bool emph_flag = false;
2774
2775         LyXLayout const & style =
2776                 textclasslist.Style(current_view->buffer()->params.textclass,
2777                                     GetLayout());
2778
2779         if (style.labeltype != LABEL_MANUAL)
2780                 main_body = 0;
2781         else
2782                 main_body = BeginningOfMainBody();
2783
2784         // Gets paragraph main font.
2785         if (main_body > 0)
2786                 font1 = style.labelfont;
2787         else
2788                 font1 = style.font;
2789
2790         int char_line_count = depth;
2791         os << newlineAndDepth(depth);
2792         if (footnoteflag == LyXParagraph::NO_FOOTNOTE) {
2793                 os << "<INFORMALTABLE>"
2794                    << newlineAndDepth(++depth);
2795         }
2796         int current_cell_number = -1;
2797         int tmp = table->DocBookEndOfCell(os, current_cell_number, depth);
2798
2799         // Parsing main loop.
2800         for (size_type i = 0; i < size(); ++i) {
2801                 c = GetChar(i);
2802                 if (table->IsContRow(current_cell_number+1)) {
2803                         if (c == LyXParagraph::META_NEWLINE)
2804                                 ++current_cell_number;
2805                         continue;
2806                 }
2807                 ++column;
2808
2809                 // Fully instantiated font
2810                 font2 = getFont(i);
2811
2812                 // Handle <emphasis> tag.
2813                 if (font1.emph() != font2.emph() && i) {
2814                         if (font2.emph() == LyXFont::ON) {
2815                                 os << "<emphasis>";
2816                                 emph_flag= true;
2817                         } else if (emph_flag) {
2818                                 os << "</emphasis>";
2819                                 emph_flag= false;
2820                         }
2821                 }
2822                 if (c == LyXParagraph::META_NEWLINE) {
2823                         // We have only to control for emphasis open here!
2824                         if (emph_flag) {
2825                                 os << "</emphasis>";
2826                                 emph_flag= false;
2827                         }
2828                         font1 = font2 = getFont(-1);
2829                         ++current_cell_number;
2830                         if (table->CellHasContRow(current_cell_number) >= 0) {
2831                                 DocBookContTableRows(os, extra, desc_on, i + 1,
2832                                                      current_cell_number,
2833                                                      column);
2834                         }
2835                         // if this cell follow only ContRows till end don't
2836                         // put the EndOfCell because it is put after the
2837                         // for(...)
2838                         if (table->ShouldBeVeryLastCell(current_cell_number)) {
2839                                 --current_cell_number;
2840                                 break;
2841                         }
2842                         tmp = table->DocBookEndOfCell(os,
2843                                                       current_cell_number,
2844                                                       depth);
2845
2846                         if (tmp > 0)
2847                                 column = 0;
2848                 } else if (c == LyXParagraph::META_INSET) {
2849                         inset = GetInset(i);
2850 #ifdef HAVE_SSTREAM
2851                         std::ostringstream ost;
2852                         inset->DocBook(ost);
2853                         string tmp_out = ost.str().c_str();
2854 #else
2855                         ostrstream ost;
2856                         inset->DocBook(ost);
2857                         ost << '\0';
2858                         char * ctmp = ost.str();
2859                         string tmp_out(ctmp);
2860                         delete [] ctmp;
2861 #endif
2862                         //
2863                         // This code needs some explanation:
2864                         // Two insets are treated specially
2865                         //   label if it is the first element in a
2866                         //   command paragraph
2867                         //         desc_on == 3
2868                         //   graphics inside tables or figure floats
2869                         //   can't go on
2870                         //   title (the equivalente in latex for this
2871                         //   case is caption
2872                         //   and title should come first
2873                         //         desc_on == 4
2874                         //
2875                         if(desc_on != 3 || i != 0) {
2876                                 if(tmp_out[0] == '@') {
2877                                         if(desc_on == 4)
2878                                                 extra += frontStrip(tmp_out,
2879                                                                     '@');
2880                                         else
2881                                                 os << frontStrip(tmp_out,
2882                                                                  '@');
2883                                 } else
2884                                         os << tmp_out;
2885                         }
2886                 } else if (font2.latex() == LyXFont::ON) {
2887                         // "TeX"-Mode on == > SGML-Mode on.
2888                         if (c != '\0')
2889                                 os << c;
2890                         ++char_line_count;
2891                 } else {
2892                         string sgml_string;
2893                         if (linuxDocConvertChar(c, sgml_string)
2894                             && !style.free_spacing) {
2895                                 // in freespacing mode, spaces are
2896                                 // non-breaking characters
2897                                 // char is ' '
2898                                 if (desc_on == 1) {
2899                                         ++char_line_count;
2900                                         os << '\n'
2901                                            << "</term><listitem><para>";
2902                                         desc_on = 2;
2903                                 } else  {
2904                                         os << c;
2905                                 }
2906                         } else {
2907                                 os << sgml_string;
2908                         }
2909                 }
2910                 font1 = font2;
2911         }
2912
2913         // Needed if there is an optional argument but no contents.
2914         if (main_body > 0 && main_body == size()) {
2915                 font1 = style.font;
2916         }
2917
2918         if (emph_flag) {
2919                 os << "</emphasis>";
2920         }
2921
2922         ++current_cell_number;
2923         tmp = table->DocBookEndOfCell(os, current_cell_number, depth);
2924         // Resets description flag correctly.
2925         switch(desc_on){
2926         case 1:
2927                 // <term> not closed...
2928                 os << "</term>";
2929                 break;
2930         }
2931         if (footnoteflag == LyXParagraph::NO_FOOTNOTE)
2932                 os << "</INFORMALTABLE>";
2933         os << '\n';
2934         lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar...done "
2935                              << this << endl;
2936 }
2937
2938
2939 void LyXParagraph::DocBookContTableRows(ostream & os, string & extra,
2940                                         int & desc_on,
2941                                         LyXParagraph::size_type i,
2942                                         int current_cell_number, int &column)
2943
2944 {
2945         if (!table) return;
2946
2947         lyxerr[Debug::LATEX] << "DocBookContTableRows... " << this << endl;
2948
2949         LyXFont font2;
2950         char c;
2951         Inset * inset;
2952         //string emph = "emphasis";
2953         bool emph_flag = false;
2954         int char_line_count = 0;
2955
2956         LyXLayout const & style =
2957                 textclasslist.Style(current_view->buffer()->params.textclass,
2958                                     GetLayout());
2959
2960         size_type main_body;
2961         if (style.labeltype != LABEL_MANUAL)
2962                 main_body = 0;
2963         else
2964                 main_body = BeginningOfMainBody();
2965
2966         // Gets paragraph main font.
2967         LyXFont font1;
2968         if (main_body > 0)
2969                 font1 = style.labelfont;
2970         else
2971                 font1 = style.font;
2972
2973         size_type lastpos = i;
2974         int cell = table->CellHasContRow(current_cell_number);
2975         ++current_cell_number;
2976         while(cell >= 0) {
2977                 // first find the right position
2978                 i = lastpos;
2979                 for (; i < size() && current_cell_number < cell; ++i) {
2980                         c = GetChar(i);
2981                         if (c == LyXParagraph::META_NEWLINE)
2982                                 ++current_cell_number;
2983                 }
2984                 lastpos = i;
2985                 c = GetChar(i);
2986                 // I don't know how to handle this so I comment it
2987                 // for the moment (Jug)
2988 //             if (table->Linebreaks(table->FirstVirtualCell(cell))) {
2989 //                     file += " \\\\\n";
2990 //                     column = 0;
2991 //             } else
2992                 if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) {
2993                         os << ' ';
2994                 }
2995
2996                 for (; i < size()
2997                              && (c = GetChar(i)) != LyXParagraph::META_NEWLINE;
2998                      ++i) {
2999                         ++column;
3000
3001                         // Fully instantiated font
3002                         font2 = getFont(i);
3003
3004                         // Handle <emphasis> tag.
3005                         if (font1.emph() != font2.emph() && i) {
3006                                 if (font2.emph() == LyXFont::ON) {
3007                                         os << "<emphasis>";
3008                                         emph_flag= true;
3009                                 } else if (emph_flag) {
3010                                         os << "</emphasis>";
3011                                         emph_flag= false;
3012                                 }
3013                         }
3014                         if (c == LyXParagraph::META_INSET) {
3015                                 inset = GetInset(i);
3016 #ifdef HAVE_SSTREAM
3017                                 std::ostringstream ost;
3018                                 inset->DocBook(ost);
3019                                 string tmp_out = ost.str().c_str();
3020 #else
3021                                 ostrstream ost;
3022                                 inset->DocBook(ost);
3023                                 ost << '\0';
3024                                 char * ctmp = ost.str();
3025                                 string tmp_out(ctmp);
3026                                 delete [] ctmp;
3027 #endif
3028                                 //
3029                                 // This code needs some explanation:
3030                                 // Two insets are treated specially
3031                                 //   label if it is the first element in a
3032                                 //   command paragraph
3033                                 //       desc_on == 3
3034                                 //   graphics inside tables or figure floats
3035                                 //   can't go on title (the equivalente in
3036                                 //   latex for this case is caption and title
3037                                 //   should come first
3038                                 //       desc_on == 4
3039                                 //
3040                                 if(desc_on != 3 || i != 0) {
3041                                         if(tmp_out[0] == '@') {
3042                                                 if(desc_on == 4)
3043                                                         extra += frontStrip(tmp_out, '@');
3044                                                 else
3045                                                         os << frontStrip(tmp_out, '@');
3046                                         } else
3047                                                 os << tmp_out;
3048                                 }
3049                         } else if (font2.latex() == LyXFont::ON) {
3050                                 // "TeX"-Mode on == > SGML-Mode on.
3051                                 if (c!= '\0')
3052                                         os << c;
3053                                 ++char_line_count;
3054                         } else {
3055                                 string sgml_string;
3056                                 if (linuxDocConvertChar(c, sgml_string)
3057                                     && !style.free_spacing) {
3058                                         // in freespacing mode, spaces are
3059                                         // non-breaking characters
3060                                         // char is ' '
3061                                         if (desc_on == 1) {
3062                                                 ++char_line_count;
3063                                                 os << '\n'
3064                                                    << "</term><listitem><para>";
3065                                                 desc_on = 2;
3066                                         } else  {
3067                                                 os << c;
3068                                         }
3069                                 } else {
3070                                         os << sgml_string;
3071                                 }
3072                         }
3073                 }
3074                 // we have only to control for emphasis open here!
3075                 if (emph_flag) {
3076                         os << "</emphasis>";
3077                         emph_flag= false;
3078                 }
3079                 font1 = font2 = getFont(-1);
3080                 cell = table->CellHasContRow(current_cell_number);
3081         }
3082         lyxerr[Debug::LATEX] << "DocBookContTableRows...done " << this << endl;
3083 }
3084
3085
3086 void LyXParagraph::SimpleTeXBlanks(ostream & os, TexRow & texrow,
3087                                    LyXParagraph::size_type const i,
3088                                    int & column, LyXFont const & font,
3089                                    LyXLayout const & style)
3090 {
3091         if (column > tex_code_break_column
3092             && i
3093             && GetChar(i - 1) != ' '
3094             && (i < size() - 1)
3095             // In LaTeX mode, we don't want to
3096             // break lines since some commands
3097             // do not like this
3098             && ! (font.latex() == LyXFont::ON)
3099             // same in FreeSpacing mode
3100             && !style.free_spacing
3101             // In typewriter mode, we want to avoid
3102             // ! . ? : at the end of a line
3103             && !(font.family() == LyXFont::TYPEWRITER_FAMILY
3104                  && (GetChar(i-1) == '.'
3105                      || GetChar(i-1) == '?'
3106                      || GetChar(i-1) == ':'
3107                      || GetChar(i-1) == '!'))) {
3108                 if (tex_code_break_column == 0) {
3109                         // in batchmode we need LaTeX to still
3110                         // see it as a space not as an extra '\n'
3111                         os << " %\n";
3112                 } else {
3113                         os << '\n';
3114                 }
3115                 texrow.newline();
3116                 texrow.start(this, i + 1);
3117                 column = 0;
3118         } else if (font.latex() == LyXFont::OFF) {
3119                 if (style.free_spacing) {
3120                         os << '~';
3121                 } else {
3122                         os << ' ';
3123                 }
3124         }
3125 }
3126
3127
3128 void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow,
3129                                          bool moving_arg,
3130                                          LyXFont & font,
3131                                          LyXFont & running_font,
3132                                          LyXFont & basefont,
3133                                          bool & open_font,
3134                                          LyXLayout const & style,
3135                                          LyXParagraph::size_type & i,
3136                                          int & column, char const c)
3137 {
3138         // Two major modes:  LaTeX or plain
3139         // Handle here those cases common to both modes
3140         // and then split to handle the two modes separately.
3141         switch (c) {
3142         case LyXParagraph::META_INSET: {
3143                 Inset * inset = GetInset(i);
3144                 if (inset) {
3145                         bool close = false;
3146                         int len = os.tellp();
3147                         if ((inset->LyxCode() == Inset::GRAPHICS_CODE
3148                              || inset->LyxCode() == Inset::MATH_CODE
3149                              || inset->LyxCode() == Inset::URL_CODE)
3150                             && running_font.isRightToLeft()) {
3151                                 os << "\\L{";
3152                                 close = true;
3153                         }
3154
3155                         int tmp = inset->Latex(os, moving_arg,
3156                                                style.free_spacing);
3157
3158                         if (close)
3159                                 os << "}";
3160
3161                         if (tmp) {
3162                                 column = 0;
3163                         } else {
3164                                 column += os.tellp() - len;
3165                         }
3166                         for (; tmp--;) {
3167                                 texrow.newline();
3168                         }
3169                 }
3170         }
3171         break;
3172
3173         case LyXParagraph::META_NEWLINE:
3174                 if (open_font) {
3175                         column += running_font.latexWriteEndChanges(os,
3176                                                                     basefont,
3177                                                                     basefont);
3178                         open_font = false;
3179                 }
3180                 basefont = getFont(-1);
3181                 running_font = basefont;
3182                 break;
3183
3184         case LyXParagraph::META_HFILL:
3185                 os << "\\hfill{}";
3186                 column += 7;
3187                 break;
3188
3189         default:
3190                 // And now for the special cases within each mode
3191                 // Are we in LaTeX mode?
3192                 if (font.latex() == LyXFont::ON) {
3193                         // at present we only have one option
3194                         // but I'll leave it as a switch statement
3195                         // so its simpler to extend. (ARRae)
3196                         switch (c) {
3197                         default:
3198                                 // make sure that we will not print
3199                                 // error generating chars to the tex
3200                                 // file. This test would not be needed
3201                                 // if it were done in the buffer
3202                                 // itself.
3203                                 if (c != '\0') {
3204                                         os << c;
3205                                 }
3206                                 break;
3207                         }
3208                 } else {
3209                         // Plain mode (i.e. not LaTeX)
3210                         switch (c) {
3211                         case '\\':
3212                                 os << "\\textbackslash{}";
3213                                 column += 15;
3214                                 break;
3215
3216                         case '°': case '±': case '²': case '³':
3217                         case '×': case '÷': case '¹': case 'ª':
3218                         case 'º': case '¬': case 'µ':
3219                                 if (current_view->buffer()->params.inputenc == "latin1") {
3220                                         os << "\\ensuremath{"
3221                                            << c
3222                                            << '}';
3223                                         column += 13;
3224                                 } else {
3225                                         os << c;
3226                                 }
3227                                 break;
3228
3229                         case '|': case '<': case '>':
3230                                 // In T1 encoding, these characters exist
3231                                 if (lyxrc.fontenc == "T1") {
3232                                         os << c;
3233                                         //... but we should avoid ligatures
3234                                         if ((c == '>' || c == '<')
3235                                             && i <= size() - 2
3236                                             && GetChar(i + 1) == c){
3237                                                 os << "\\textcompwordmark{}";
3238                                                 column += 19;
3239                                         }
3240                                         break;
3241                                 }
3242                                 // Typewriter font also has them
3243                                 if (font.family() == LyXFont::TYPEWRITER_FAMILY) {
3244                                         os << c;
3245                                         break;
3246                                 }
3247                                 // Otherwise, we use what LaTeX
3248                                 // provides us.
3249                                 switch(c) {
3250                                 case '<':
3251                                         os << "\\textless{}";
3252                                         column += 10;
3253                                         break;
3254                                 case '>':
3255                                         os << "\\textgreater{}";
3256                                         column += 13;
3257                                         break;
3258                                 case '|':
3259                                         os << "\\textbar{}";
3260                                         column += 9;
3261                                         break;
3262                                 }
3263                                 break;
3264
3265                         case '-': // "--" in Typewriter mode -> "-{}-"
3266                                 if (i <= size() - 2
3267                                     && GetChar(i + 1) == '-'
3268                                     && font.family() == LyXFont::TYPEWRITER_FAMILY) {
3269                                         os << "-{}";
3270                                         column += 2;
3271                                 } else {
3272                                         os << '-';
3273                                 }
3274                                 break;
3275
3276                         case '\"':
3277                                 os << "\\char`\\\"{}";
3278                                 column += 9;
3279                                 break;
3280
3281                         case '£':
3282                                 if (current_view->buffer()->params.inputenc == "default") {
3283                                         os << "\\pounds{}";
3284                                         column += 8;
3285                                 } else {
3286                                         os << c;
3287                                 }
3288                                 break;
3289
3290                         case '$': case '&':
3291                         case '%': case '#': case '{':
3292                         case '}': case '_':
3293                                 os << '\\' << c;
3294                                 column += 1;
3295                                 break;
3296
3297                         case '~':
3298                                 os << "\\textasciitilde{}";
3299                                 column += 16;
3300                                 break;
3301
3302                         case '^':
3303                                 os << "\\textasciicircum{}";
3304                                 column += 17;
3305                                 break;
3306
3307                         case '*': case '[': case ']':
3308                                 // avoid being mistaken for optional arguments
3309                                 os << '{' << c << '}';
3310                                 column += 2;
3311                                 break;
3312
3313                         case ' ':
3314                                 // Blanks are printed before font switching.
3315                                 // Sure? I am not! (try nice-latex)
3316                                 // I am sure it's correct. LyX might be smarter
3317                                 // in the future, but for now, nothing wrong is
3318                                 // written. (Asger)
3319                                 break;
3320
3321                         default:
3322                                 /* idea for labels --- begin*/
3323                                 // Check for "LyX"
3324                                 if (c ==  'L'
3325                                     && i <= size() - 3
3326                                     && font.family() != LyXFont::TYPEWRITER_FAMILY
3327                                     && GetChar(i + 1) == 'y'
3328                                     && GetChar(i + 2) == 'X') {
3329                                         os << "\\LyX{}";
3330                                         i += 2;
3331                                         column += 5;
3332                                 }
3333                                 // Check for "TeX"
3334                                 else if (c == 'T'
3335                                          && i <= size() - 3
3336                                          && font.family() != LyXFont::TYPEWRITER_FAMILY
3337                                          && GetChar(i + 1) == 'e'
3338                                          && GetChar(i + 2) == 'X') {
3339                                         os << "\\TeX{}";
3340                                         i += 2;
3341                                         column += 5;
3342                                 }
3343                                 // Check for "LaTeX2e"
3344                                 else if (c == 'L'
3345                                          && i <= size() - 7
3346                                          && font.family() != LyXFont::TYPEWRITER_FAMILY
3347                                          && GetChar(i + 1) == 'a'
3348                                          && GetChar(i + 2) == 'T'
3349                                          && GetChar(i + 3) == 'e'
3350                                          && GetChar(i + 4) == 'X'
3351                                          && GetChar(i + 5) == '2'
3352                                          && GetChar(i + 6) == 'e') {
3353                                         os << "\\LaTeXe{}";
3354                                         i += 6;
3355                                         column += 8;
3356                                 }
3357                                 // Check for "LaTeX"
3358                                 else if (c == 'L'
3359                                          && i <= size() - 5
3360                                          && font.family() != LyXFont::TYPEWRITER_FAMILY
3361                                          && GetChar(i + 1) == 'a'
3362                                          && GetChar(i + 2) == 'T'
3363                                          && GetChar(i + 3) == 'e'
3364                                          && GetChar(i + 4) == 'X') {
3365                                         os << "\\LaTeX{}";
3366                                         i += 4;
3367                                         column += 7;
3368                                         /* idea for labels --- end*/
3369                                 } else if (c != '\0') {
3370                                         os << c;
3371                                 }
3372                                 break;
3373                         }
3374                 }
3375         }
3376 }
3377
3378
3379 #if 0
3380 bool LyXParagraph::RoffContTableRows(ostream & os,
3381                                      LyXParagraph::size_type i,
3382                                      int actcell)
3383 {
3384         if (!table)
3385                 return false;
3386
3387         LyXFont font1(LyXFont::ALL_INHERIT);
3388         LyXFont font2;
3389         Inset * inset;
3390         char c;
3391
3392         string fname2 = TmpFileName(string(), "RAT2");
3393         int lastpos = i;
3394         int cell = table->CellHasContRow(actcell);
3395         ++actcell;
3396         while(cell >= 0) {
3397                 // first find the right position
3398                 i = lastpos;
3399                 for (; i < size() && actcell < cell; ++i) {
3400                         c = GetChar(i);
3401                         if (c == LyXParagraph::META_NEWLINE)
3402                                 ++actcell;
3403                 }
3404                 lastpos = i;
3405                 c = GetChar(i);
3406                 if ((c != ' ') && (c != LyXParagraph::META_NEWLINE))
3407                         os << " ";
3408                 for (; i < size()
3409                              && (c = GetChar(i)) != LyXParagraph::META_NEWLINE;
3410                      ++i) {
3411                         font2 = GetFontSettings(i);
3412                         if (font1.latex() != font2.latex()) {
3413                                 if (font2.latex() != LyXFont::OFF)
3414                                         continue;
3415                         }
3416                         c = GetChar(i);
3417                         switch (c) {
3418                         case LyXParagraph::META_INSET:
3419                                 if ((inset = GetInset(i))) {
3420 #ifdef HAVE_SSTREAM
3421                                         stringstream ss(ios::in | ios::out);
3422                                         inset->Ascii(ss);
3423                                         ss.seekp(0);
3424                                         ss.get(c);
3425                                         while (!ss) {
3426                                                 if (c == '\\')
3427                                                         os << "\\\\";
3428                                                 else
3429                                                         os << c;
3430                                                 ss.get(c);
3431                                         }
3432 #else
3433                                         strstream ss;
3434                                         inset->Ascii(ss);
3435                                         ss.seekp(0);
3436                                         ss.get(c);
3437                                         while (!ss) {
3438                                                 if (c == '\\')
3439                                                         os << "\\\\";
3440                                                 else
3441                                                         os << c;
3442                                                 ss.get(c);
3443                                         }
3444                                         delete [] ss.str();
3445 #endif
3446                                 }
3447                                 break;
3448                         case LyXParagraph::META_NEWLINE:
3449                                 break;
3450                         case LyXParagraph::META_HFILL:
3451                                 break;
3452                         case '\\':
3453                                 os << "\\\\";
3454                                 break;
3455                         default:
3456                                 if (c != '\0')
3457                                         os << c;
3458                                 else
3459                                         lyxerr.debug() << "RoffAsciiTable: "
3460                                                 "NULL char in structure."
3461                                                        << endl;
3462                                 break;
3463                         }
3464                 }
3465                 cell = table->CellHasContRow(actcell);
3466         }
3467         return true;
3468 }
3469 #endif
3470
3471
3472 LyXParagraph * LyXParagraph::TeXDeeper(ostream & os, TexRow & texrow,
3473                                        ostream & foot,
3474                                        TexRow & foot_texrow,
3475                                        int & foot_count)
3476 {
3477         lyxerr[Debug::LATEX] << "TeXDeeper...     " << this << endl;
3478         LyXParagraph * par = this;
3479
3480         while (par &&
3481                (par->depth == depth) &&
3482                (par->footnoteflag == footnoteflag)) {
3483                 if (par->IsDummy())
3484                         lyxerr << "ERROR (LyXParagraph::TeXDeeper)" << endl;
3485                 if (textclasslist.Style(current_view->buffer()->params.textclass,
3486                                         par->layout).isEnvironment()
3487                     || par->pextra_type != PEXTRA_NONE) {
3488                         par = par->TeXEnvironment(os, texrow,
3489                                                   foot, foot_texrow,
3490                                                   foot_count);
3491                 } else {
3492                         par = par->TeXOnePar(os, texrow, false,
3493                                              foot, foot_texrow,
3494                                              foot_count);
3495                 }
3496         }
3497         lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl;
3498
3499         return par;
3500 }
3501
3502
3503 LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow,
3504                                             ostream & foot,
3505                                             TexRow & foot_texrow,
3506                                             int & foot_count)
3507 {
3508         bool eindent_open = false;
3509         bool foot_this_level = false;
3510         // flags when footnotetext should be appended to file.
3511         static bool minipage_open = false;
3512         static int minipage_open_depth = 0;
3513         char par_sep = current_view->buffer()->params.paragraph_separation;
3514
3515         lyxerr[Debug::LATEX] << "TeXEnvironment...     " << this << endl;
3516         if (IsDummy())
3517                 lyxerr << "ERROR (LyXParagraph::TeXEnvironment)" << endl;
3518
3519         LyXLayout const & style =
3520                 textclasslist.Style(current_view->buffer()->params.textclass,
3521                                     layout);
3522
3523         if (pextra_type == PEXTRA_INDENT) {
3524                 if (!pextra_width.empty()) {
3525                         os << "\\begin{LyXParagraphIndent}{"
3526                            << pextra_width << "}\n";
3527                 } else {
3528                         //float ib = atof(pextra_widthp.c_str())/100;
3529                         // string can't handle floats at present (971109)
3530                         // so I'll do a conversion by hand knowing that
3531                         // the limits are 0.0 to 1.0. ARRae.
3532                         os << "\\begin{LyXParagraphIndent}{";
3533                         switch (pextra_widthp.length()) {
3534                         case 3:
3535                                 os << "1.00";
3536                                 break;
3537                         case 2:
3538                                 os << "0."
3539                                    << pextra_widthp;
3540                                 break;
3541                         case 1:
3542                                 os << "0.0"
3543                                    << pextra_widthp;
3544                         }
3545                         os << "\\columnwidth}\n";
3546                 }
3547                 texrow.newline();
3548                 eindent_open = true;
3549         }
3550         if ((pextra_type == PEXTRA_MINIPAGE) && !minipage_open) {
3551                 if (pextra_hfill && Previous() &&
3552                     (Previous()->pextra_type == PEXTRA_MINIPAGE)) {
3553                         os << "\\hfill{}\n";
3554                         texrow.newline();
3555                 }
3556                 if (par_sep == BufferParams::PARSEP_INDENT) {
3557                         os << "{\\setlength\\parindent{0pt}\n";
3558                         texrow.newline();
3559                 }
3560                 os << "\\begin{minipage}";
3561                 switch(pextra_alignment) {
3562                 case MINIPAGE_ALIGN_TOP:
3563                         os << "[t]";
3564                         break;
3565                 case MINIPAGE_ALIGN_MIDDLE:
3566                         os << "[m]";
3567                         break;
3568                 case MINIPAGE_ALIGN_BOTTOM:
3569                         os << "[b]";
3570                         break;
3571                 }
3572                 if (!pextra_width.empty()) {
3573                         os << '{' << pextra_width << "}\n";
3574                 } else {
3575                         //float ib = atof(par->pextra_width.c_str())/100;
3576                         // string can't handle floats at present
3577                         // so I'll do a conversion by hand knowing that
3578                         // the limits are 0.0 to 1.0. ARRae.
3579                         os << '{';
3580                         switch (pextra_widthp.length()) {
3581                         case 3:
3582                                 os << "1.00";
3583                                 break;
3584                         case 2:
3585                                 os << "0."
3586                                    << pextra_widthp;
3587                                 break;
3588                         case 1:
3589                                 os << "0.0"
3590                                    << pextra_widthp;
3591                         }
3592                         os << "\\columnwidth}\n";
3593                 }
3594                 texrow.newline();
3595                 if (par_sep == BufferParams::PARSEP_INDENT) {
3596                         os << "\\setlength\\parindent{\\LyXMinipageIndent}\n";
3597                         texrow.newline();
3598                 }
3599                 minipage_open = true;
3600                 minipage_open_depth = depth;
3601         }
3602
3603 #ifdef WITH_WARNINGS
3604 #warning Define FANCY_FOOTNOTE_CODE to re-enable Allan footnote code
3605         //I disabled it because it breaks when lists span on several
3606         //pages (JMarc)
3607 #endif
3608         if (style.isEnvironment()){
3609                 if (style.latextype == LATEX_LIST_ENVIRONMENT) {
3610 #ifdef FANCY_FOOTNOTE_CODE
3611                         if (foot_count < 0) {
3612                                 // flag that footnote[mark][text] should be
3613                                 // used for any footnotes from now on
3614                                 foot_count = 0;
3615                                 foot_this_level = true;
3616                         }
3617 #endif
3618                         os << "\\begin{" << style.latexname() << "}{"
3619                            << labelwidthstring << "}\n";
3620                 } else if (style.labeltype == LABEL_BIBLIO) {
3621                         // ale970405
3622                         os << "\\begin{" << style.latexname() << "}{"
3623                            << bibitemWidthest(current_view->painter())
3624                            << "}\n";
3625                 } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) {
3626 #ifdef FANCY_FOOTNOTE_CODE
3627                         if (foot_count < 0) {
3628                                 // flag that footnote[mark][text] should be
3629                                 // used for any footnotes from now on
3630                                 foot_count = 0;
3631                                 foot_this_level = true;
3632                         }
3633 #endif
3634                         os << "\\begin{" << style.latexname() << '}'
3635                            << style.latexparam() << '\n';
3636                 } else
3637                         os << "\\begin{" << style.latexname() << '}'
3638                            << style.latexparam() << '\n';
3639                 texrow.newline();
3640         }
3641         LyXParagraph * par = this;
3642         do {
3643                 par = par->TeXOnePar(os, texrow, false,
3644                                      foot, foot_texrow, foot_count);
3645
3646                 if (minipage_open && par && !style.isEnvironment() &&
3647                     (par->pextra_type == PEXTRA_MINIPAGE) &&
3648                     par->pextra_start_minipage) {
3649                         os << "\\end{minipage}\n";
3650                         texrow.newline();
3651                         if (par_sep == BufferParams::PARSEP_INDENT) {
3652                                 os << "}\n";
3653                                 texrow.newline();
3654                         }
3655                         minipage_open = false;
3656                 }
3657                 if (par && par->depth > depth) {
3658                         if (textclasslist.Style(current_view->buffer()->params.textclass,
3659                                                 par->layout).isParagraph()
3660                             && !par->table
3661                             // Thinko!
3662                             // How to handle this? (Lgb)
3663                             //&& !suffixIs(os, "\n\n")
3664                                 ) {
3665                                 // There should be at least one '\n' already
3666                                 // but we need there to be two for Standard
3667                                 // paragraphs that are depth-increment'ed to be
3668                                 // output correctly.  However, tables can
3669                                 // also be paragraphs so don't adjust them.
3670                                 // ARRae
3671                                 // Thinkee:
3672                                 // Will it ever harm to have one '\n' too
3673                                 // many? i.e. that we sometimes will have
3674                                 // three in a row. (Lgb)
3675                                 os << '\n';
3676                                 texrow.newline();
3677                         }
3678                         par = par->TeXDeeper(os, texrow,
3679                                              foot, foot_texrow, foot_count);
3680                 }
3681                 if (par && par->layout == layout && par->depth == depth &&
3682                     (par->pextra_type == PEXTRA_MINIPAGE) && !minipage_open) {
3683                         if (par->pextra_hfill && par->Previous() &&
3684                             (par->Previous()->pextra_type == PEXTRA_MINIPAGE)){
3685                                 os << "\\hfill{}\n";
3686                                 texrow.newline();
3687                         }
3688                         if (par_sep == BufferParams::PARSEP_INDENT) {
3689                                 os << "{\\setlength\\parindent{0pt}\n";
3690                                 texrow.newline();
3691                         }
3692                         os << "\\begin{minipage}";
3693                         switch(par->pextra_alignment) {
3694                         case MINIPAGE_ALIGN_TOP:
3695                                 os << "[t]";
3696                                 break;
3697                         case MINIPAGE_ALIGN_MIDDLE:
3698                                 os << "[m]";
3699                                 break;
3700                         case MINIPAGE_ALIGN_BOTTOM:
3701                                 os << "[b]";
3702                                 break;
3703                         }
3704                         if (!par->pextra_width.empty()) {
3705                                 os << '{' << par->pextra_width << "}\n";
3706                         } else {
3707                                 //float ib = atof(par->pextra_widthp.c_str())/100;
3708                                 // string can't handle floats at present
3709                                 // so I'll do a conversion by hand knowing that
3710                                 // the limits are 0.0 to 1.0. ARRae.
3711                                 os << '{';
3712                                 switch (par->pextra_widthp.length()) {
3713                                 case 3:
3714                                         os << "1.00";
3715                                         break;
3716                                 case 2:
3717                                         os << "0." << par->pextra_widthp;
3718                                         break;
3719                                 case 1:
3720                                         os << "0.0" << par->pextra_widthp;
3721                                 }
3722                                 os << "\\columnwidth}\n";
3723                         }
3724                         texrow.newline();
3725                         if (par_sep == BufferParams::PARSEP_INDENT) {
3726                                 os << "\\setlength\\parindent{\\LyXMinipageIndent}\n";
3727                                 texrow.newline();
3728                         }
3729                         minipage_open = true;
3730                         minipage_open_depth = par->depth;
3731                 }
3732         } while (par
3733                  && par->layout == layout
3734                  && par->depth == depth
3735                  && par->pextra_type == pextra_type
3736                  && par->footnoteflag == footnoteflag);
3737
3738         if (style.isEnvironment()) {
3739                 os << "\\end{" << style.latexname() << '}';
3740                 // maybe this should go after the minipage closes?
3741                 if (foot_this_level) {
3742                         if (foot_count >= 1) {
3743                                 if (foot_count > 1) {
3744                                         os << "\\addtocounter{footnote}{-"
3745                                            << foot_count - 1
3746                                            << '}';
3747                                 }
3748                                 os << foot;
3749                                 texrow += foot_texrow;
3750                                 foot.clear();
3751                                 foot_texrow.reset();
3752                                 foot_count = 0;
3753                         }
3754                 }
3755         }
3756         if (minipage_open && (minipage_open_depth == depth) &&
3757             (!par || par->pextra_start_minipage ||
3758              par->pextra_type != PEXTRA_MINIPAGE)) {
3759                 os << "\\end{minipage}\n";
3760                 texrow.newline();
3761                 if (par_sep == BufferParams::PARSEP_INDENT) {
3762                         os << "}\n";
3763                         texrow.newline();
3764                 }
3765                 if (par && par->pextra_type != PEXTRA_MINIPAGE) {
3766                         os << "\\medskip\n\n";
3767                         texrow.newline();
3768                         texrow.newline();
3769                 }
3770                 minipage_open = false;
3771         }
3772         if (eindent_open) {
3773                 os << "\\end{LyXParagraphIndent}\n";
3774                 texrow.newline();
3775         }
3776         if (!(par && (par->pextra_type == PEXTRA_MINIPAGE)
3777               && par->pextra_hfill)) {
3778                 os << '\n';
3779                 texrow.newline();
3780         }
3781         lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl;
3782         return par;  // ale970302
3783 }
3784
3785
3786 LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow,
3787                                          ostream & foot, TexRow & foot_texrow,
3788                                          int & foot_count,
3789                                          bool parent_is_rtl)
3790 {
3791         lyxerr[Debug::LATEX] << "TeXFootnote...  " << this << endl;
3792         if (footnoteflag == LyXParagraph::NO_FOOTNOTE)
3793                 lyxerr << "ERROR (LyXParagraph::TeXFootnote): "
3794                         "No footnote!" << endl;
3795
3796         LyXParagraph * par = this;
3797         LyXLayout const & style =
3798                 textclasslist.Style(current_view->buffer()->params.textclass,
3799                                     previous->GetLayout());
3800
3801         if (style.needprotect && footnotekind != LyXParagraph::FOOTNOTE){
3802                 lyxerr << "ERROR (LyXParagraph::TeXFootnote): "
3803                         "Float other than footnote in command"
3804                         " with moving argument is illegal" << endl;
3805         }
3806
3807         if (footnotekind != LyXParagraph::FOOTNOTE
3808             && footnotekind != LyXParagraph::MARGIN
3809             && os.tellp()
3810             // Thinko
3811             // How to solve this?
3812             //&& !suffixIs(file, '\n')
3813                 ) {
3814                 // we need to ensure that real floats like tables and figures
3815                 // have their \begin{} on a new line otherwise we can get
3816                 // incorrect results when using the endfloat.sty package
3817                 // especially if two floats follow one another.  ARRae 981022
3818                 // NOTE: if the file is length 0 it must have just been
3819                 //       written out so we assume it ended with a '\n'
3820                 // Thinkee:
3821                 // As far as I can see there is never any harm in writing
3822                 // a '\n' too much. Please tell me if I am wrong. (Lgb)
3823                 os << '\n';
3824                 texrow.newline();
3825         }
3826
3827         bool moving_arg = false;
3828         bool need_closing = false;
3829         bool is_rtl = isRightToLeftPar();
3830
3831         if (is_rtl != parent_is_rtl) {
3832                 if (is_rtl)
3833                         os << "\\R{";
3834                 else
3835                         os << "\\L{";
3836                 need_closing = true;
3837         }
3838
3839         BufferParams * params = &current_view->buffer()->params;
3840         bool footer_in_body = true;
3841         switch (footnotekind) {
3842         case LyXParagraph::FOOTNOTE:
3843                 if (style.intitle) {
3844                         os << "\\thanks{\n";
3845                         footer_in_body = false;
3846                         moving_arg = true;
3847                 } else {
3848                         if (foot_count == -1) {
3849                                 // we're at depth 0 so we can use:
3850                                 os << "\\footnote{%\n";
3851                                 footer_in_body = false;
3852                         } else {
3853                                 os << "\\footnotemark{}%\n";
3854                                 if (foot_count) {
3855                                         // we only need this when there are
3856                                         // multiple footnotes
3857                                         os << "\\stepcounter{footnote}";
3858                                 }
3859                                 os << "\\footnotetext{%\n";
3860                                 foot_texrow.start(this, 0);
3861                                 foot_texrow.newline();
3862                                 ++foot_count;
3863                         }
3864                 }
3865                 break;
3866         case LyXParagraph::MARGIN:
3867                 os << "\\marginpar{\n";
3868                 break;
3869         case LyXParagraph::FIG:
3870                 if (pextra_type == PEXTRA_FLOATFLT
3871                     && (!pextra_width.empty()
3872                         || !pextra_widthp.empty())) {
3873                         if (!pextra_width.empty())
3874                                 os << "\\begin{floatingfigure}{"
3875                                    << pextra_width << "}\n";
3876                         else
3877                                 os << "\\begin{floatingfigure}{"
3878                                    << atoi(pextra_widthp.c_str())/100.0
3879                                    << "\\textwidth}\n";
3880                 } else {
3881                         os << "\\begin{figure}";
3882                         if (!params->float_placement.empty()) {
3883                                 os << '[' << params->float_placement << "]\n";
3884                         } else {
3885                                 os << '\n';
3886                         }
3887                 }
3888                 break;
3889         case LyXParagraph::TAB:
3890                 os << "\\begin{table}";
3891                 if (!params->float_placement.empty()) {
3892                         os << '[' << params->float_placement << "]\n";
3893                 } else {
3894                         os << '\n';
3895                 }
3896                 break;
3897         case LyXParagraph::WIDE_FIG:
3898                 os << "\\begin{figure*}";
3899                 if (!params->float_placement.empty()) {
3900                         os << '[' << params->float_placement << "]\n";
3901                 } else {
3902                         os << '\n';
3903                 }
3904                 break;
3905         case LyXParagraph::WIDE_TAB:
3906                 os << "\\begin{table*}";
3907                 if (!params->float_placement.empty()) {
3908                         os << '[' << params->float_placement << "]\n";
3909                 } else {
3910                         os << '\n';
3911                 }
3912                 break;
3913         case LyXParagraph::ALGORITHM:
3914                 os << "\\begin{algorithm}\n";
3915                 break;
3916         }
3917         texrow.newline();
3918
3919         if (footnotekind != LyXParagraph::FOOTNOTE
3920             || !footer_in_body) {
3921                 // Process text for all floats except footnotes in body
3922                 do {
3923                         LyXLayout const & style =
3924                                 textclasslist
3925                                 .Style(current_view->buffer()->params
3926                                        .textclass,
3927                                        par->layout);
3928                         if (par->IsDummy())
3929                                 lyxerr << "ERROR (LyXParagraph::TeXFootnote)"
3930                                        << endl;
3931                         if (style.isEnvironment()
3932                             || par->pextra_type == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */
3933                                 // Allows the use of minipages within float
3934                                 // environments. Shouldn't be circular because
3935                                 // we don't support footnotes inside
3936                                 // floats (yet). ARRae
3937                                 par = par->TeXEnvironment(os, texrow,
3938                                                           foot, foot_texrow,
3939                                                           foot_count);
3940                         } else {
3941                                 par = par->TeXOnePar(os, texrow, moving_arg,
3942                                                      foot, foot_texrow,
3943                                                      foot_count);
3944                         }
3945
3946                         if (par && !par->IsDummy() && par->depth > depth) {
3947                                 par = par->TeXDeeper(os, texrow,
3948                                                      foot, foot_texrow,
3949                                                      foot_count);
3950                         }
3951                 } while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE);
3952         } else {
3953                 // process footnotes > depth 0 or in environments separately
3954                 // NOTE: Currently don't support footnotes within footnotes
3955                 //       even though that is possible using the \footnotemark
3956 #ifdef HAVE_SSTREAM
3957                 std::ostringstream dummy;
3958 #else
3959                 ostrstream dummy;
3960 #endif
3961                 TexRow dummy_texrow;
3962                 int dummy_count = 0;
3963                 do {
3964                         LyXLayout const & style =
3965                                 textclasslist
3966                                 .Style(current_view->buffer()->params
3967                                        .textclass,
3968                                        par->layout);
3969                         if (par->IsDummy())
3970                                 lyxerr << "ERROR (LyXParagraph::TeXFootnote)"
3971                                        << endl;
3972                         if (style.isEnvironment()
3973                             || par->pextra_type == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */
3974                                 // Allows the use of minipages within float
3975                                 // environments. Shouldn't be circular because
3976                                 // we don't support footnotes inside
3977                                 // floats (yet). ARRae
3978                                 par = par->TeXEnvironment(foot, foot_texrow,
3979                                                           dummy, dummy_texrow,
3980                                                           dummy_count);
3981                         } else {
3982                                 par = par->TeXOnePar(foot, foot_texrow,
3983                                                      moving_arg,
3984                                                      dummy, dummy_texrow,
3985                                                      dummy_count);
3986                         }
3987
3988                         if (par && !par->IsDummy() && par->depth > depth) {
3989                                 par = par->TeXDeeper(foot, foot_texrow,
3990                                                      dummy, dummy_texrow,
3991                                                      dummy_count);
3992                         }
3993                 } while (par
3994                          && par->footnoteflag != LyXParagraph::NO_FOOTNOTE);
3995                 if (dummy_count) {
3996                         lyxerr << "ERROR (LyXParagraph::TeXFootnote): "
3997                                 "Footnote in a Footnote -- not supported"
3998                                << endl;
3999                 }
4000 #ifndef HAVE_OSTREAM
4001                 delete [] dummy.str();
4002 #endif
4003         }
4004
4005         switch (footnotekind) {
4006         case LyXParagraph::FOOTNOTE:
4007                 if (footer_in_body) {
4008                         // This helps tell which of the multiple
4009                         // footnotetexts an error was in.
4010                         foot << "}%\n";
4011                         foot_texrow.newline();
4012                 } else {
4013                         os << '}';
4014                 }
4015                 break;
4016         case LyXParagraph::MARGIN:
4017                 os << '}';
4018                 break;
4019         case LyXParagraph::FIG:
4020                 if (pextra_type == PEXTRA_FLOATFLT
4021                     && (!pextra_width.empty()
4022                         || !pextra_widthp.empty()))
4023                         os << "\\end{floatingfigure}";
4024                 else
4025                         os << "\\end{figure}";
4026                 break;
4027         case LyXParagraph::TAB:
4028                 os << "\\end{table}";
4029                 break;
4030         case LyXParagraph::WIDE_FIG:
4031                 os << "\\end{figure*}";
4032                 break;
4033         case LyXParagraph::WIDE_TAB:
4034                 os << "\\end{table*}";
4035                 break;
4036         case LyXParagraph::ALGORITHM:
4037                 os << "\\end{algorithm}";
4038                 break;
4039         }
4040
4041         if (need_closing)
4042                 os << "}";
4043
4044         if (footnotekind != LyXParagraph::FOOTNOTE
4045             && footnotekind != LyXParagraph::MARGIN) {
4046                 // we need to ensure that real floats like tables and figures
4047                 // have their \end{} on a line of their own otherwise we can
4048                 // get incorrect results when using the endfloat.sty package.
4049                 os << "\n";
4050                 texrow.newline();
4051         }
4052
4053         lyxerr[Debug::LATEX] << "TeXFootnote...done " << par->next << endl;
4054         return par;
4055 }
4056
4057
4058 bool LyXParagraph::IsDummy() const
4059 {
4060         return (footnoteflag == LyXParagraph::NO_FOOTNOTE && previous
4061                 && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE);
4062 }
4063
4064
4065 void LyXParagraph::SetPExtraType(int type, char const * width,
4066                                  char const * widthp)
4067 {
4068         pextra_type = type;
4069         pextra_width = width;
4070         pextra_widthp = widthp;
4071
4072         if (textclasslist.Style(current_view->buffer()->params.textclass,
4073                                 layout).isEnvironment()) {
4074                 LyXParagraph
4075                         * par = this,
4076                         * ppar = par;
4077
4078                 while (par && (par->layout == layout)
4079                        && (par->depth == depth)) {
4080                         ppar = par;
4081                         par = par->Previous();
4082                         if (par)
4083                                 par = par->FirstPhysicalPar();
4084                         while (par && par->depth > depth) {
4085                                 par = par->Previous();
4086                                 if (par)
4087                                         par = par->FirstPhysicalPar();
4088                         }
4089                 }
4090                 par = ppar;
4091                 while (par && (par->layout == layout)
4092                        && (par->depth == depth)) {
4093                         par->pextra_type = type;
4094                         par->pextra_width = width;
4095                         par->pextra_widthp = widthp;
4096                         par = par->NextAfterFootnote();
4097                         if (par && (par->depth > depth))
4098                                 par->SetPExtraType(type, width, widthp);
4099                         while (par && ((par->depth > depth) || par->IsDummy()))
4100                                 par = par->NextAfterFootnote();
4101                 }
4102         }
4103 }
4104
4105
4106 void LyXParagraph::UnsetPExtraType()
4107 {
4108         if (pextra_type == PEXTRA_NONE)
4109                 return;
4110
4111         pextra_type = PEXTRA_NONE;
4112         pextra_width.erase();
4113         pextra_widthp.erase();
4114
4115         if (textclasslist.Style(current_view->buffer()->params.textclass,
4116                                 layout).isEnvironment()) {
4117                 LyXParagraph
4118                         * par = this,
4119                         * ppar = par;
4120
4121                 while (par && (par->layout == layout)
4122                        && (par->depth == depth)) {
4123                         ppar = par;
4124                         par = par->Previous();
4125                         if (par)
4126                                 par = par->FirstPhysicalPar();
4127                         while (par && par->depth > depth) {
4128                                 par = par->Previous();
4129                                 if (par)
4130                                         par = par->FirstPhysicalPar();
4131                         }
4132                 }
4133                 par = ppar;
4134                 while (par && (par->layout == layout)
4135                        && (par->depth == depth)) {
4136                         par->pextra_type = PEXTRA_NONE;
4137                         par->pextra_width.erase();
4138                         par->pextra_widthp.erase();
4139                         par = par->NextAfterFootnote();
4140                         if (par && (par->depth > depth))
4141                                 par->UnsetPExtraType();
4142                         while (par && ((par->depth > depth) || par->IsDummy()))
4143                                 par = par->NextAfterFootnote();
4144                 }
4145         }
4146 }
4147
4148
4149 bool LyXParagraph::IsHfill(size_type pos) const
4150 {
4151         return IsHfillChar(GetChar(pos));
4152 }
4153
4154
4155 bool LyXParagraph::IsInset(size_type pos) const
4156 {
4157         return IsInsetChar(GetChar(pos));
4158 }
4159
4160
4161 bool LyXParagraph::IsFloat(size_type pos) const
4162 {
4163         return IsFloatChar(GetChar(pos));
4164 }
4165
4166
4167 bool LyXParagraph::IsNewline(size_type pos) const
4168 {
4169         return pos >= 0 && IsNewlineChar(GetChar(pos));
4170 }
4171
4172
4173 bool LyXParagraph::IsSeparator(size_type pos) const
4174 {
4175         return IsSeparatorChar(GetChar(pos));
4176 }
4177
4178
4179 bool LyXParagraph::IsLineSeparator(size_type pos) const
4180 {
4181         return IsLineSeparatorChar(GetChar(pos));
4182 }
4183
4184
4185 bool LyXParagraph::IsKomma(size_type pos) const
4186 {
4187         return IsKommaChar(GetChar(pos));
4188 }
4189
4190
4191 /// Used by the spellchecker
4192 bool LyXParagraph::IsLetter(LyXParagraph::size_type pos) const
4193 {
4194         unsigned char c = GetChar(pos);
4195         if (IsLetterChar(c))
4196                 return true;
4197         // '\0' is not a letter, allthough every string contains "" (below)
4198         if( c == '\0')
4199                 return false;
4200         // We want to pass the ' and escape chars to ispell
4201         string extra = lyxrc.isp_esc_chars + '\'';
4202         char ch[2];
4203         ch[0] = c;
4204         ch[1] = 0;
4205         return contains(extra, ch);
4206 }
4207
4208
4209 bool LyXParagraph::IsWord(size_type pos ) const
4210 {
4211         return IsWordChar(GetChar(pos)) ;
4212 }
4213
4214
4215 Language const * LyXParagraph::getParLanguage() const
4216 {
4217         if (size() > 0)
4218                 if (!table)
4219                         return FirstPhysicalPar()->GetFirstFontSettings()
4220                                 .language();
4221                 else {
4222                         for (size_type pos = 0; pos < size(); ++pos)
4223                                 if (IsNewline(pos))
4224                                         return GetFontSettings(pos).language();
4225                         return GetFirstFontSettings().language();
4226                 }
4227         else if (previous)
4228                 return previous->getParLanguage();
4229         else
4230                 return current_view->buffer()->params.language_info;
4231 }
4232
4233
4234 bool LyXParagraph::isRightToLeftPar() const
4235 {
4236         return lyxrc.rtl_support && !table && getParLanguage()->RightToLeft;
4237 }
4238
4239
4240 void LyXParagraph::ChangeLanguage(Language const * from, Language const * to)
4241 {
4242         for(size_type i = 0; i < size(); ++i) {
4243                 LyXFont font = GetFontSettings(i);
4244                 if (font.language() == from) {
4245                         font.setLanguage(to);
4246                         SetFont(i, font);
4247                 }
4248         }
4249 }
4250
4251
4252 bool LyXParagraph::isMultiLingual()
4253 {
4254         Language const * doc_language =
4255                 current_view->buffer()->params.language_info;
4256         for(size_type i = 0; i < size(); ++i) {
4257                 LyXFont font = GetFontSettings(i);
4258                 if (font.language() != doc_language)
4259                         return true;
4260         }
4261         return false;
4262 }