src/buffer.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  *           This file is Copyright 1996-1999
  10  *           Lars Gullik Bjønnes
  11  *
  12  * ======================================================
  13  */
  14
  15 #include <config.h>
  16
  17 #include <fstream>
  18 #include <iomanip>
  19
  20 #include <cstdlib>
  21 #include <cmath>
  22 #include <unistd.h>
  23 #include <sys/types.h>
  24 #include <utime.h>
  25
  26 #include <algorithm>
  27
  28 #ifdef HAVE_LOCALE
  29 #include <locale>
  30 #endif
  31
  32 #ifdef __GNUG__
  33 #pragma implementation "buffer.h"
  34 #endif
  35
  36 #include "buffer.h"
  37 #include "bufferlist.h"
  38 #include "lyx_main.h"
  39 #include "lyx_gui_misc.h"
  40 #include "LyXAction.h"
  41 #include "lyxrc.h"
  42 #include "lyxlex.h"
  43 #include "tex-strings.h"
  44 #include "layout.h"
  45 #include "bufferview_funcs.h"
  46 #include "minibuffer.h"
  47 #include "lyxfont.h"
  48 #include "version.h"
  49 #include "mathed/formulamacro.h"
  50 #include "insets/lyxinset.h"
  51 #include "insets/inseterror.h"
  52 #include "insets/insetlabel.h"
  53 #include "insets/insetref.h"
  54 #include "insets/inseturl.h"
  55 #include "insets/insetinfo.h"
  56 #include "insets/insetquotes.h"
  57 #include "insets/insetlatexaccent.h"
  58 #include "insets/insetbib.h"
  59 #include "insets/insetcite.h"
  60 #include "insets/insetexternal.h"
  61 #include "insets/insetindex.h"
  62 #include "insets/insetinclude.h"
  63 #include "insets/insettoc.h"
  64 #include "insets/insetparent.h"
  65 #include "insets/insetspecialchar.h"
  66 #include "insets/figinset.h"
  67 #include "insets/insettext.h"
  68 #include "insets/insetert.h"
  69 #include "insets/insetgraphics.h"
  70 #include "insets/insetfoot.h"
  71 #include "insets/insetmarginal.h"
  72 #include "insets/insetminipage.h"
  73 #include "insets/insetfloat.h"
  74 #include "insets/insetlist.h"
  75 #include "insets/insettabular.h"
  76 #include "insets/insettheorem.h"
  77 #include "insets/insetcaption.h"
  78 #include "support/filetools.h"
  79 #include "support/path.h"
  80 #include "LaTeX.h"
  81 #include "Chktex.h"
  82 #include "LyXView.h"
  83 #include "debug.h"
  84 #include "LaTeXFeatures.h"
  85 #include "support/syscall.h"
  86 #include "support/lyxlib.h"
  87 #include "support/FileInfo.h"
  88 #include "support/lyxmanip.h"
  89 #include "lyxtext.h"
  90 #include "gettext.h"
  91 #include "language.h"
  92 #include "lyx_gui_misc.h"       // WarnReadonly()
  93 #include "frontends/Dialogs.h"
  94 #include "encoding.h"
  95 #include "exporter.h"
  96 #include "Lsstream.h"
  97 #include "converter.h"
  98
  99 using std::ostream;
 100 using std::ofstream;
 101 using std::ifstream;
 102 using std::fstream;
 103 using std::ios;
 104 using std::setw;
 105 using std::endl;
 106 using std::pair;
 107 using std::make_pair;
 108 using std::vector;
 109 using std::max;
 110 using std::set;
 111
 112 // all these externs should eventually be removed.
 113 extern BufferList bufferlist;
 114
 115 extern LyXAction lyxaction;
 116
 117
 118 static const int LYX_FORMAT = 218;
 119
 120 extern int tex_code_break_column;
 121
 122
 123 Buffer::Buffer(string const & file, bool ronly)
 124 {
 125         lyxerr[Debug::INFO] << "Buffer::Buffer()" << endl;
 126         filename = file;
 127         filepath = OnlyPath(file);
 128         paragraph = 0;
 129         lyx_clean = true;
 130         bak_clean = true;
 131         dep_clean = 0;
 132         read_only = ronly;
 133         unnamed = false;
 134         users = 0;
 135         lyxvc.buffer(this);
 136         if (read_only || (lyxrc.use_tempdir)) {
 137                 tmppath = CreateBufferTmpDir();
 138         } else tmppath.erase();
 139 }
 140
 141
 142 Buffer::~Buffer()
 143 {
 144         lyxerr[Debug::INFO] << "Buffer::~Buffer()" << endl;
 145         // here the buffer should take care that it is
 146         // saved properly, before it goes into the void.
 147
 148         // make sure that views using this buffer
 149         // forgets it.
 150         if (users)
 151                 users->buffer(0);
 152
 153         if (!tmppath.empty()) {
 154                 DestroyBufferTmpDir(tmppath);
 155         }
 156
 157         LyXParagraph * par = paragraph;
 158         LyXParagraph * tmppar;
 159         while (par) {
 160                 tmppar = par->next;
 161                 delete par;
 162                 par = tmppar;
 163         }
 164         paragraph = 0;
 165 }
 166
 167
 168 string const Buffer::getLatexName(bool no_path) const
 169 {
 170         if (no_path)
 171                 return OnlyFilename(ChangeExtension(MakeLatexName(filename),
 172                                                     ".tex"));
 173         else
 174                 return ChangeExtension(MakeLatexName(filename),
 175                                        ".tex");
 176 }
 177
 178 pair<Buffer::LogType, string> const Buffer::getLogName(void) const
 179 {
 180         string filename, fname, bname, path;
 181
 182         filename = getLatexName(false);
 183
 184         if (filename.empty())
 185                 return make_pair(Buffer::latexlog, string());
 186
 187         path = OnlyPath(filename);
 188
 189         if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1))
 190                 path = tmppath;
 191
 192         fname = AddName(path, OnlyFilename(ChangeExtension(filename, ".log")));
 193         bname = AddName(path, OnlyFilename(ChangeExtension(filename,
 194                 formats.Extension("literate") + ".out")));
 195
 196         // If no Latex log or Build log is newer, show Build log
 197
 198         FileInfo f_fi(fname), b_fi(bname);
 199
 200         if (b_fi.exist() &&
 201                 (!f_fi.exist() || f_fi.getModificationTime() < b_fi.getModificationTime())) {
 202                 lyxerr[Debug::FILES] << "Log name calculated as : " << bname << endl;
 203                 return make_pair(Buffer::buildlog, bname);
 204         }
 205         lyxerr[Debug::FILES] << "Log name calculated as : " << fname << endl;
 206         return make_pair(Buffer::latexlog, fname);
 207 }
 208
 209 void Buffer::setReadonly(bool flag)
 210 {
 211         if (read_only != flag) {
 212                 read_only = flag;
 213                 updateTitles();
 214                 users->owner()->getDialogs()->updateBufferDependent(false);
 215         }
 216         if (read_only) {
 217                 WarnReadonly(filename);
 218         }
 219 }
 220
 221
 222 bool Buffer::saveParamsAsDefaults() // const
 223 {
 224         string const fname = AddName(AddPath(user_lyxdir, "templates/"),
 225                                "defaults.lyx");
 226         Buffer defaults = Buffer(fname);
 227
 228         // Use the current buffer's parameters as default
 229         defaults.params = params;
 230
 231         // add an empty paragraph. Is this enough?
 232         defaults.paragraph = new LyXParagraph;
 233
 234         return defaults.writeFile(defaults.filename, false);
 235 }
 236
 237
 238 /// Update window titles of all users
 239 // Should work on a list
 240 void Buffer::updateTitles() const
 241 {
 242         if (users) users->owner()->updateWindowTitle();
 243 }
 244
 245
 246 /// Reset autosave timer of all users
 247 // Should work on a list
 248 void Buffer::resetAutosaveTimers() const
 249 {
 250         if (users) users->owner()->resetAutosaveTimer();
 251 }
 252
 253
 254 void Buffer::setFileName(string const & newfile)
 255 {
 256         filename = MakeAbsPath(newfile);
 257         filepath = OnlyPath(filename);
 258         setReadonly(IsFileWriteable(filename) == 0);
 259         updateTitles();
 260 }
 261
 262
 263 // candidate for move to BufferView
 264 // (at least some parts in the beginning of the func)
 265 //
 266 // Uwe C. Schroeder
 267 // changed to be public and have one parameter
 268 // if par = 0 normal behavior
 269 // else insert behavior
 270 // Returns false if "\the_end" is not read for formats >= 2.13. (Asger)
 271 bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par)
 272 {
 273         int pos = 0;
 274         char depth = 0; // signed or unsigned?
 275 #ifndef NEW_INSETS
 276         LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE;
 277         LyXParagraph::footnote_kind footnotekind = LyXParagraph::FOOTNOTE;
 278 #endif
 279         bool the_end_read = false;
 280
 281         LyXParagraph * return_par = 0;
 282         LyXFont font(LyXFont::ALL_INHERIT, params.language);
 283         if (file_format < 216 && params.language->lang() == "hebrew")
 284                 font.setLanguage(default_language);
 285         // If we are inserting, we cheat and get a token in advance
 286         bool has_token = false;
 287         string pretoken;
 288
 289         if (!par) {
 290                 par = new LyXParagraph;
 291         } else {
 292                 users->text->BreakParagraph(users);
 293                 return_par = users->text->FirstParagraph();
 294                 pos = 0;
 295                 markDirty();
 296                 // We don't want to adopt the parameters from the
 297                 // document we insert, so we skip until the text begins:
 298                 while (lex.IsOK()) {
 299                         lex.nextToken();
 300                         pretoken = lex.GetString();
 301                         if (pretoken == "\\layout") {
 302                                 has_token = true;
 303                                 break;
 304                         }
 305                 }
 306         }
 307
 308         while (lex.IsOK()) {
 309                 if (has_token) {
 310                         has_token = false;
 311                 } else {
 312                         lex.nextToken();
 313                         pretoken = lex.GetString();
 314                 }
 315
 316                 if (pretoken.empty()) continue;
 317
 318                 the_end_read =
 319                         parseSingleLyXformat2Token(lex, par, return_par,
 320                                                    pretoken, pos, depth,
 321                                                    font
 322 #ifndef NEW_INSETS
 323                                                    , footnoteflag,
 324                                                    footnotekind
 325 #endif
 326                                 );
 327         }
 328
 329         if (!return_par)
 330                 return_par = par;
 331
 332         paragraph = return_par;
 333
 334         return the_end_read;
 335 }
 336
 337
 338 // We'll remove this later. (Lgb)
 339 static string last_inset_read;
 340
 341
 342 bool
 343 Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 344                                    LyXParagraph *& return_par,
 345                                    string const & token, int & pos,
 346                                    char & depth, LyXFont & font
 347 #ifndef NEW_INSETS
 348                                    , LyXParagraph::footnote_flag & footnoteflag,
 349                                    LyXParagraph::footnote_kind & footnotekind
 350 #endif
 351         )
 352 {
 353         bool the_end_read = false;
 354
 355         if (token[0] != '\\') {
 356                 for (string::const_iterator cit = token.begin();
 357                      cit != token.end(); ++cit) {
 358                         par->InsertChar(pos, (*cit), font);
 359                         ++pos;
 360                 }
 361         } else if (token == "\\i") {
 362                 Inset * inset = new InsetLatexAccent;
 363                 inset->Read(this, lex);
 364                 par->InsertInset(pos, inset, font);
 365                 ++pos;
 366         } else if (token == "\\layout") {
 367                 if (!return_par)
 368                         return_par = par;
 369                 else {
 370                         par->fitToSize();
 371                         par = new LyXParagraph(par);
 372                 }
 373                 pos = 0;
 374                 lex.EatLine();
 375                 string const layoutname = lex.GetString();
 376                 pair<bool, LyXTextClass::LayoutList::size_type> pp
 377                         = textclasslist.NumberOfLayout(params.textclass,
 378                                                        layoutname);
 379                 if (pp.first) {
 380                         par->layout = pp.second;
 381                 } else { // layout not found
 382                         // use default layout "Standard" (0)
 383                         par->layout = 0;
 384                 }
 385                 // Test whether the layout is obsolete.
 386                 LyXLayout const & layout =
 387                         textclasslist.Style(params.textclass,
 388                                             par->layout);
 389                 if (!layout.obsoleted_by().empty())
 390                         par->layout =
 391                                 textclasslist.NumberOfLayout(params.textclass,
 392                                                              layout.obsoleted_by()).second;
 393 #ifndef NEW_INSETS
 394                 par->footnoteflag = footnoteflag;
 395                 par->footnotekind = footnotekind;
 396 #endif
 397                 par->depth = depth;
 398                 font = LyXFont(LyXFont::ALL_INHERIT, params.language);
 399                 if (file_format < 216 && params.language->lang() == "hebrew")
 400                         font.setLanguage(default_language);
 401 #ifndef NEW_INSETS
 402         } else if (token == "\\end_float") {
 403                 if (!return_par)
 404                         return_par = par;
 405                 else {
 406                         par->fitToSize();
 407                         par = new LyXParagraph(par);
 408                 }
 409                 footnotekind = LyXParagraph::FOOTNOTE;
 410                 footnoteflag = LyXParagraph::NO_FOOTNOTE;
 411                 pos = 0;
 412                 lex.EatLine();
 413                 par->layout = LYX_DUMMY_LAYOUT;
 414                 font = LyXFont(LyXFont::ALL_INHERIT, params.language);
 415                 if (file_format < 216 && params.language->lang() == "hebrew")
 416                         font.setLanguage(default_language);
 417         } else if (token == "\\begin_float") {
 418                 int tmpret = lex.FindToken(string_footnotekinds);
 419                 if (tmpret == -1) ++tmpret;
 420                 if (tmpret != LYX_LAYOUT_DEFAULT)
 421                         footnotekind = static_cast<LyXParagraph::footnote_kind>(tmpret); // bad
 422                 if (footnotekind == LyXParagraph::FOOTNOTE
 423                     || footnotekind == LyXParagraph::MARGIN)
 424                         footnoteflag = LyXParagraph::CLOSED_FOOTNOTE;
 425                 else
 426                         footnoteflag = LyXParagraph::OPEN_FOOTNOTE;
 427 #else
 428         } else if (token == "\\begin_float") {
 429                 // This is the compability reader, unfinished but tested.
 430                 // (Lgb)
 431                 lex.next();
 432                 string const tmptok = lex.GetString();
 433                 //lyxerr << "old float: " << tmptok << endl;
 434
 435                 Inset * inset = 0;
 436                 string old_float;
 437
 438                 if (tmptok == "footnote") {
 439                         inset = new InsetFoot;
 440                 } else if (tmptok == "margin") {
 441                         inset = new InsetMarginal;
 442                 } else if (tmptok == "fig") {
 443                         inset = new InsetFloat("figure");
 444                         old_float += "placement htbp\n";
 445                 } else if (tmptok == "tab") {
 446                         inset = new InsetFloat("table");
 447                         old_float += "placement htbp\n";
 448                 } else if (tmptok == "alg") {
 449                         inset = new InsetFloat("algorithm");
 450                         old_float += "placement htbp\n";
 451                 } else if (tmptok == "wide-fig") {
 452                         InsetFloat * tmp = new InsetFloat("figure");
 453                         tmp->wide(true);
 454                         inset = tmp;
 455                         old_float += "placement htbp\n";
 456                 } else if (tmptok == "wide-tab") {
 457                         InsetFloat * tmp = new InsetFloat("table");
 458                         tmp->wide(true);
 459                         inset = tmp;
 460                         old_float += "placement htbp\n";
 461                 }
 462
 463                 if (!inset) return false; // no end read yet
 464
 465                 old_float += "collapsed true\n";
 466
 467                 // Here we need to check for \end_deeper and handle that
 468                 // before we do the footnote parsing.
 469                 // This _is_ a hack! (Lgb)
 470                 while(true) {
 471                         lex.next();
 472                         string const tmp = lex.GetString();
 473                         if (tmp == "\\end_deeper") {
 474                                 lyxerr << "\\end_deeper caught!" << endl;
 475                                 if (!depth) {
 476                                         lex.printError("\\end_deeper: "
 477                                                        "depth is already null");
 478                                 } else
 479                                         --depth;
 480
 481                         } else {
 482                                 old_float += tmp;
 483                                 old_float += ' ';
 484                                 break;
 485                         }
 486                 }
 487
 488                 old_float += lex.getLongString("\\end_float");
 489                 old_float += "\n\\end_inset\n";
 490                 //lyxerr << "float body: " << old_float << endl;
 491
 492                 istringstream istr(old_float);
 493
 494                 LyXLex nylex(0, 0);
 495                 nylex.setStream(istr);
 496
 497                 inset->Read(this, nylex);
 498                 par->InsertInset(pos, inset, font);
 499                 ++pos;
 500 #endif
 501         } else if (token == "\\begin_deeper") {
 502                 ++depth;
 503         } else if (token == "\\end_deeper") {
 504                 if (!depth) {
 505                         lex.printError("\\end_deeper: "
 506                                        "depth is already null");
 507                 }
 508                 else
 509                         --depth;
 510         } else if (token == "\\begin_preamble") {
 511                 params.readPreamble(lex);
 512         } else if (token == "\\textclass") {
 513                 lex.EatLine();
 514                 pair<bool, LyXTextClassList::size_type> pp =
 515                         textclasslist.NumberOfClass(lex.GetString());
 516                 if (pp.first) {
 517                         params.textclass = pp.second;
 518                 } else {
 519                         WriteAlert(string(_("Textclass error")),
 520                                 string(_("The document uses an unknown textclass \"")) +
 521                                 lex.GetString() + string("\"."),
 522                                 string(_("LyX will not be able to produce output correctly.")));
 523                         params.textclass = 0;
 524                 }
 525                 if (!textclasslist.Load(params.textclass)) {
 526                                 // if the textclass wasn't loaded properly
 527                                 // we need to either substitute another
 528                                 // or stop loading the file.
 529                                 // I can substitute but I don't see how I can
 530                                 // stop loading... ideas??  ARRae980418
 531                         WriteAlert(_("Textclass Loading Error!"),
 532                                    string(_("Can't load textclass ")) +
 533                                    textclasslist.NameOfClass(params.textclass),
 534                                    _("-- substituting default"));
 535                         params.textclass = 0;
 536                 }
 537         } else if (token == "\\options") {
 538                 lex.EatLine();
 539                 params.options = lex.GetString();
 540         } else if (token == "\\language") {
 541                 params.readLanguage(lex);
 542         } else if (token == "\\fontencoding") {
 543                 lex.EatLine();
 544         } else if (token == "\\inputencoding") {
 545                 lex.EatLine();
 546                 params.inputenc = lex.GetString();
 547         } else if (token == "\\graphics") {
 548                 params.readGraphicsDriver(lex);
 549         } else if (token == "\\fontscheme") {
 550                 lex.EatLine();
 551                 params.fonts = lex.GetString();
 552         } else if (token == "\\noindent") {
 553                 par->noindent = true;
 554         } else if (token == "\\fill_top") {
 555                 par->added_space_top = VSpace(VSpace::VFILL);
 556         } else if (token == "\\fill_bottom") {
 557                 par->added_space_bottom = VSpace(VSpace::VFILL);
 558         } else if (token == "\\line_top") {
 559                 par->line_top = true;
 560         } else if (token == "\\line_bottom") {
 561                 par->line_bottom = true;
 562         } else if (token == "\\pagebreak_top") {
 563                 par->pagebreak_top = true;
 564         } else if (token == "\\pagebreak_bottom") {
 565                 par->pagebreak_bottom = true;
 566         } else if (token == "\\start_of_appendix") {
 567                 par->start_of_appendix = true;
 568         } else if (token == "\\paragraph_separation") {
 569                 int tmpret = lex.FindToken(string_paragraph_separation);
 570                 if (tmpret == -1) ++tmpret;
 571                 if (tmpret != LYX_LAYOUT_DEFAULT)
 572                         params.paragraph_separation =
 573                                 static_cast<BufferParams::PARSEP>(tmpret);
 574         } else if (token == "\\defskip") {
 575                 lex.nextToken();
 576                 params.defskip = VSpace(lex.GetString());
 577         } else if (token == "\\epsfig") { // obsolete
 578                 // Indeed it is obsolete, but we HAVE to be backwards
 579                 // compatible until 0.14, because otherwise all figures
 580                 // in existing documents are irretrivably lost. (Asger)
 581                 params.readGraphicsDriver(lex);
 582         } else if (token == "\\quotes_language") {
 583                 int tmpret = lex.FindToken(string_quotes_language);
 584                 if (tmpret == -1) ++tmpret;
 585                 if (tmpret != LYX_LAYOUT_DEFAULT) {
 586                         InsetQuotes::quote_language tmpl =
 587                                 InsetQuotes::EnglishQ;
 588                         switch (tmpret) {
 589                         case 0:
 590                                 tmpl = InsetQuotes::EnglishQ;
 591                                 break;
 592                         case 1:
 593                                 tmpl = InsetQuotes::SwedishQ;
 594                                 break;
 595                         case 2:
 596                                 tmpl = InsetQuotes::GermanQ;
 597                                 break;
 598                         case 3:
 599                                 tmpl = InsetQuotes::PolishQ;
 600                                 break;
 601                         case 4:
 602                                 tmpl = InsetQuotes::FrenchQ;
 603                                 break;
 604                         case 5:
 605                                 tmpl = InsetQuotes::DanishQ;
 606                                 break;
 607                         }
 608                         params.quotes_language = tmpl;
 609                 }
 610         } else if (token == "\\quotes_times") {
 611                 lex.nextToken();
 612                 switch (lex.GetInteger()) {
 613                 case 1:
 614                         params.quotes_times = InsetQuotes::SingleQ;
 615                         break;
 616                 case 2:
 617                         params.quotes_times = InsetQuotes::DoubleQ;
 618                         break;
 619                 }
 620         } else if (token == "\\papersize") {
 621                 int tmpret = lex.FindToken(string_papersize);
 622                 if (tmpret == -1)
 623                         ++tmpret;
 624                 else
 625                         params.papersize2 = tmpret;
 626         } else if (token == "\\paperpackage") {
 627                 int tmpret = lex.FindToken(string_paperpackages);
 628                 if (tmpret == -1) {
 629                         ++tmpret;
 630                         params.paperpackage = BufferParams::PACKAGE_NONE;
 631                 } else
 632                         params.paperpackage = tmpret;
 633         } else if (token == "\\use_geometry") {
 634                 lex.nextToken();
 635                 params.use_geometry = lex.GetInteger();
 636         } else if (token == "\\use_amsmath") {
 637                 lex.nextToken();
 638                 params.use_amsmath = lex.GetInteger();
 639         } else if (token == "\\paperorientation") {
 640                 int tmpret = lex.FindToken(string_orientation);
 641                 if (tmpret == -1) ++tmpret;
 642                 if (tmpret != LYX_LAYOUT_DEFAULT)
 643                         params.orientation = static_cast<BufferParams::PAPER_ORIENTATION>(tmpret);
 644         } else if (token == "\\paperwidth") {
 645                 lex.next();
 646                 params.paperwidth = lex.GetString();
 647         } else if (token == "\\paperheight") {
 648                 lex.next();
 649                 params.paperheight = lex.GetString();
 650         } else if (token == "\\leftmargin") {
 651                 lex.next();
 652                 params.leftmargin = lex.GetString();
 653         } else if (token == "\\topmargin") {
 654                 lex.next();
 655                 params.topmargin = lex.GetString();
 656         } else if (token == "\\rightmargin") {
 657                 lex.next();
 658                 params.rightmargin = lex.GetString();
 659         } else if (token == "\\bottommargin") {
 660                 lex.next();
 661                 params.bottommargin = lex.GetString();
 662         } else if (token == "\\headheight") {
 663                 lex.next();
 664                 params.headheight = lex.GetString();
 665         } else if (token == "\\headsep") {
 666                 lex.next();
 667                 params.headsep = lex.GetString();
 668         } else if (token == "\\footskip") {
 669                 lex.next();
 670                 params.footskip = lex.GetString();
 671         } else if (token == "\\paperfontsize") {
 672                 lex.nextToken();
 673                 params.fontsize = strip(lex.GetString());
 674         } else if (token == "\\papercolumns") {
 675                 lex.nextToken();
 676                 params.columns = lex.GetInteger();
 677         } else if (token == "\\papersides") {
 678                 lex.nextToken();
 679                 switch (lex.GetInteger()) {
 680                 default:
 681                 case 1: params.sides = LyXTextClass::OneSide; break;
 682                 case 2: params.sides = LyXTextClass::TwoSides; break;
 683                 }
 684         } else if (token == "\\paperpagestyle") {
 685                 lex.nextToken();
 686                 params.pagestyle = strip(lex.GetString());
 687         } else if (token == "\\bullet") {
 688                 lex.nextToken();
 689                 int const index = lex.GetInteger();
 690                 lex.nextToken();
 691                 int temp_int = lex.GetInteger();
 692                 params.user_defined_bullets[index].setFont(temp_int);
 693                 params.temp_bullets[index].setFont(temp_int);
 694                 lex.nextToken();
 695                 temp_int = lex.GetInteger();
 696                 params.user_defined_bullets[index].setCharacter(temp_int);
 697                 params.temp_bullets[index].setCharacter(temp_int);
 698                 lex.nextToken();
 699                 temp_int = lex.GetInteger();
 700                 params.user_defined_bullets[index].setSize(temp_int);
 701                 params.temp_bullets[index].setSize(temp_int);
 702                 lex.nextToken();
 703                 string const temp_str = lex.GetString();
 704                 if (temp_str != "\\end_bullet") {
 705                                 // this element isn't really necessary for
 706                                 // parsing but is easier for humans
 707                                 // to understand bullets. Put it back and
 708                                 // set a debug message?
 709                         lex.printError("\\end_bullet expected, got" + temp_str);
 710                                 //how can I put it back?
 711                 }
 712         } else if (token == "\\bulletLaTeX") {
 713                 lex.nextToken();
 714                 int const index = lex.GetInteger();
 715                 lex.next();
 716                 string temp_str = lex.GetString();
 717                 string sum_str;
 718                 while (temp_str != "\\end_bullet") {
 719                                 // this loop structure is needed when user
 720                                 // enters an empty string since the first
 721                                 // thing returned will be the \\end_bullet
 722                                 // OR
 723                                 // if the LaTeX entry has spaces. Each element
 724                                 // therefore needs to be read in turn
 725                         sum_str += temp_str;
 726                         lex.next();
 727                         temp_str = lex.GetString();
 728                 }
 729                 params.user_defined_bullets[index].setText(sum_str);
 730                 params.temp_bullets[index].setText(sum_str);
 731         } else if (token == "\\secnumdepth") {
 732                 lex.nextToken();
 733                 params.secnumdepth = lex.GetInteger();
 734         } else if (token == "\\tocdepth") {
 735                 lex.nextToken();
 736                 params.tocdepth = lex.GetInteger();
 737         } else if (token == "\\spacing") {
 738                 lex.next();
 739                 string const tmp = strip(lex.GetString());
 740                 Spacing::Space tmp_space = Spacing::Default;
 741                 float tmp_val = 0.0;
 742                 if (tmp == "single") {
 743                         tmp_space = Spacing::Single;
 744                 } else if (tmp == "onehalf") {
 745                         tmp_space = Spacing::Onehalf;
 746                 } else if (tmp == "double") {
 747                         tmp_space = Spacing::Double;
 748                 } else if (tmp == "other") {
 749                         lex.next();
 750                         tmp_space = Spacing::Other;
 751                         tmp_val = lex.GetFloat();
 752                 } else {
 753                         lex.printError("Unknown spacing token: '$$Token'");
 754                 }
 755                 // Small hack so that files written with klyx will be
 756                 // parsed correctly.
 757                 if (return_par) {
 758                         par->spacing.set(tmp_space, tmp_val);
 759                 } else {
 760                         params.spacing.set(tmp_space, tmp_val);
 761                 }
 762         } else if (token == "\\paragraph_spacing") {
 763                 lex.next();
 764                 string const tmp = strip(lex.GetString());
 765                 if (tmp == "single") {
 766                         par->spacing.set(Spacing::Single);
 767                 } else if (tmp == "onehalf") {
 768                         par->spacing.set(Spacing::Onehalf);
 769                 } else if (tmp == "double") {
 770                         par->spacing.set(Spacing::Double);
 771                 } else if (tmp == "other") {
 772                         lex.next();
 773                         par->spacing.set(Spacing::Other,
 774                                          lex.GetFloat());
 775                 } else {
 776                         lex.printError("Unknown spacing token: '$$Token'");
 777                 }
 778         } else if (token == "\\float_placement") {
 779                 lex.nextToken();
 780                 params.float_placement = lex.GetString();
 781         } else if (token == "\\family") {
 782                 lex.next();
 783                 font.setLyXFamily(lex.GetString());
 784         } else if (token == "\\series") {
 785                 lex.next();
 786                 font.setLyXSeries(lex.GetString());
 787         } else if (token == "\\shape") {
 788                 lex.next();
 789                 font.setLyXShape(lex.GetString());
 790         } else if (token == "\\size") {
 791                 lex.next();
 792                 font.setLyXSize(lex.GetString());
 793         } else if (token == "\\latex") {
 794                 lex.next();
 795                 string const tok = lex.GetString();
 796                 // This is dirty, but gone with LyX3. (Asger)
 797                 if (tok == "no_latex")
 798                         font.setLatex(LyXFont::OFF);
 799                 else if (tok == "latex")
 800                         font.setLatex(LyXFont::ON);
 801                 else if (tok == "default")
 802                         font.setLatex(LyXFont::INHERIT);
 803                 else
 804                         lex.printError("Unknown LaTeX font flag "
 805                                        "`$$Token'");
 806         } else if (token == "\\lang") {
 807                 lex.next();
 808                 string const tok = lex.GetString();
 809                 Language const * lang = languages.getLanguage(tok);
 810                 if (lang) {
 811                         font.setLanguage(lang);
 812                 } else {
 813                         font.setLanguage(params.language);
 814                         lex.printError("Unknown language `$$Token'");
 815                 }
 816         } else if (token == "\\numeric") {
 817                 lex.next();
 818                 font.setNumber(font.setLyXMisc(lex.GetString()));
 819         } else if (token == "\\emph") {
 820                 lex.next();
 821                 font.setEmph(font.setLyXMisc(lex.GetString()));
 822         } else if (token == "\\bar") {
 823                 lex.next();
 824                 string const tok = lex.GetString();
 825                 // This is dirty, but gone with LyX3. (Asger)
 826                 if (tok == "under")
 827                         font.setUnderbar(LyXFont::ON);
 828                 else if (tok == "no")
 829                         font.setUnderbar(LyXFont::OFF);
 830                 else if (tok == "default")
 831                         font.setUnderbar(LyXFont::INHERIT);
 832                 else
 833                         lex.printError("Unknown bar font flag "
 834                                        "`$$Token'");
 835         } else if (token == "\\noun") {
 836                 lex.next();
 837                 font.setNoun(font.setLyXMisc(lex.GetString()));
 838         } else if (token == "\\color") {
 839                 lex.next();
 840                 font.setLyXColor(lex.GetString());
 841         } else if (token == "\\align") {
 842                 int tmpret = lex.FindToken(string_align);
 843                 if (tmpret == -1) ++tmpret;
 844                 if (tmpret != LYX_LAYOUT_DEFAULT) { // tmpret != 99 ???
 845                         int const tmpret2 = int(pow(2.0, tmpret));
 846                         //lyxerr << "Tmpret2 = " << tmpret2 << endl;
 847                         par->align = LyXAlignment(tmpret2);
 848                 }
 849         } else if (token == "\\added_space_top") {
 850                 lex.nextToken();
 851                 par->added_space_top = VSpace(lex.GetString());
 852         } else if (token == "\\added_space_bottom") {
 853                 lex.nextToken();
 854                 par->added_space_bottom = VSpace(lex.GetString());
 855         } else if (token == "\\pextra_type") {
 856                 lex.nextToken();
 857                 par->pextra_type = lex.GetInteger();
 858         } else if (token == "\\pextra_width") {
 859                 lex.nextToken();
 860                 par->pextra_width = lex.GetString();
 861         } else if (token == "\\pextra_widthp") {
 862                 lex.nextToken();
 863                 par->pextra_widthp = lex.GetString();
 864         } else if (token == "\\pextra_alignment") {
 865                 lex.nextToken();
 866                 par->pextra_alignment = lex.GetInteger();
 867         } else if (token == "\\pextra_hfill") {
 868                 lex.nextToken();
 869                 par->pextra_hfill = lex.GetInteger();
 870         } else if (token == "\\pextra_start_minipage") {
 871                 lex.nextToken();
 872                 par->pextra_start_minipage = lex.GetInteger();
 873         } else if (token == "\\labelwidthstring") {
 874                 lex.EatLine();
 875                 par->labelwidthstring = lex.GetString();
 876                 // do not delete this token, it is still needed!
 877         } else if (token == "\\end_inset") {
 878                 lyxerr << "Solitary \\end_inset. Missing \\begin_inset?.\n"
 879                        << "Last inset read was: " << last_inset_read
 880                        << endl;
 881                 // Simply ignore this. The insets do not have
 882                 // to read this.
 883                 // But insets should read it, it is a part of
 884                 // the inset isn't it? Lgb.
 885         } else if (token == "\\begin_inset") {
 886                 readInset(lex, par, pos, font);
 887         } else if (token == "\\SpecialChar") {
 888                 LyXLayout const & layout =
 889                         textclasslist.Style(params.textclass,
 890                                             par->GetLayout());
 891
 892                 // Insets don't make sense in a free-spacing context! ---Kayvan
 893                 if (layout.free_spacing) {
 894                         if (lex.IsOK()) {
 895                                 lex.next();
 896                                 string next_token = lex.GetString();
 897                                 if (next_token == "\\-") {
 898                                         par->InsertChar(pos, '-', font);
 899                                 } else if (next_token == "\\protected_separator"
 900                                         || next_token == "~") {
 901                                         par->InsertChar(pos, ' ', font);
 902                                 } else {
 903                                         lex.printError("Token `$$Token' "
 904                                                        "is in free space "
 905                                                        "paragraph layout!");
 906                                         --pos;
 907                                 }
 908                         }
 909                 } else {
 910                         Inset * inset = new InsetSpecialChar;
 911                         inset->Read(this, lex);
 912                         par->InsertInset(pos, inset, font);
 913                 }
 914                 ++pos;
 915         } else if (token == "\\newline") {
 916                 par->InsertChar(pos, LyXParagraph::META_NEWLINE, font);
 917                 ++pos;
 918         } else if (token == "\\LyXTable") {
 919                 Inset * inset = new InsetTabular(*this);
 920                 inset->Read(this, lex);
 921                 par->InsertInset(pos, inset, font);
 922                 ++pos;
 923         } else if (token == "\\hfill") {
 924                 par->InsertChar(pos, LyXParagraph::META_HFILL, font);
 925                 ++pos;
 926         } else if (token == "\\protected_separator") { // obsolete
 927                 // This is a backward compability thingie. (Lgb)
 928                 // Remove it later some time...introduced with fileformat
 929                 // 2.16. (Lgb)
 930                 LyXLayout const & layout =
 931                         textclasslist.Style(params.textclass,
 932                                             par->GetLayout());
 933
 934                 if (layout.free_spacing) {
 935                         par->InsertChar(pos, ' ', font);
 936                 } else {
 937                         Inset * inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR);
 938                         par->InsertInset(pos, inset, font);
 939                 }
 940                 ++pos;
 941         } else if (token == "\\bibitem") {  // ale970302
 942                 if (!par->bibkey) {
 943                         InsetCommandParams p("bibitem", "dummy");
 944                         par->bibkey = new InsetBibKey(p);
 945                 }
 946                 par->bibkey->Read(this, lex);
 947         } else if (token == "\\backslash") {
 948                 par->InsertChar(pos, '\\', font);
 949                 ++pos;
 950         } else if (token == "\\the_end") {
 951                 the_end_read = true;
 952         } else {
 953                 // This should be insurance for the future: (Asger)
 954                 lex.printError("Unknown token `$$Token'. "
 955                                "Inserting as text.");
 956                 string::const_iterator cit = token.begin();
 957                 string::const_iterator end = token.end();
 958                 for (; cit != end; ++cit) {
 959                         par->InsertChar(pos, (*cit), font);
 960                         ++pos;
 961                 }
 962         }
 963         return the_end_read;
 964 }
 965
 966
 967 void Buffer::readInset(LyXLex & lex, LyXParagraph *& par,
 968                        int & pos, LyXFont & font)
 969 {
 970         // consistency check
 971         if (lex.GetString() != "\\begin_inset") {
 972                 lyxerr << "Buffer::readInset: Consistency check failed."
 973                        << endl;
 974         }
 975
 976         Inset * inset = 0;
 977
 978         lex.next();
 979         string const tmptok = lex.GetString();
 980         last_inset_read = tmptok;
 981
 982         // test the different insets
 983         if (tmptok == "LatexCommand") {
 984                 InsetCommandParams inscmd;
 985                 inscmd.Read(lex);
 986
 987                 if (inscmd.getCmdName() == "cite") {
 988                         inset = new InsetCitation(inscmd);
 989                 } else if (inscmd.getCmdName() == "bibitem") {
 990                         lex.printError("Wrong place for bibitem");
 991                         inset = new InsetBibKey(inscmd);
 992                 } else if (inscmd.getCmdName() == "BibTeX") {
 993                         inset = new InsetBibtex(inscmd);
 994                 } else if (inscmd.getCmdName() == "index") {
 995                         inset = new InsetIndex(inscmd);
 996                 } else if (inscmd.getCmdName() == "include") {
 997                         inset = new InsetInclude(inscmd, *this);
 998                 } else if (inscmd.getCmdName() == "label") {
 999                         inset = new InsetLabel(inscmd);
1000                 } else if (inscmd.getCmdName() == "url"
1001                            || inscmd.getCmdName() == "htmlurl") {
1002                         inset = new InsetUrl(inscmd);
1003                 } else if (inscmd.getCmdName() == "ref"
1004                            || inscmd.getCmdName() == "pageref"
1005                            || inscmd.getCmdName() == "vref"
1006                            || inscmd.getCmdName() == "vpageref"
1007                            || inscmd.getCmdName() == "prettyref") {
1008                         if (!inscmd.getOptions().empty()
1009                             || !inscmd.getContents().empty()) {
1010                                 inset = new InsetRef(inscmd, *this);
1011                         }
1012                 } else if (inscmd.getCmdName() == "tableofcontents"
1013                            || inscmd.getCmdName() == "listofalgorithms"
1014                            || inscmd.getCmdName() == "listoffigures"
1015                            || inscmd.getCmdName() == "listoftables") {
1016                         inset = new InsetTOC(inscmd);
1017                 } else if (inscmd.getCmdName() == "printindex") {
1018                         inset = new InsetPrintIndex(inscmd);
1019                 } else if (inscmd.getCmdName() == "lyxparent") {
1020                         inset = new InsetParent(inscmd, *this);
1021                 }
1022         } else {
1023                 if (tmptok == "Quotes") {
1024                         inset = new InsetQuotes;
1025                 } else if (tmptok == "External") {
1026                         inset = new InsetExternal;
1027                 } else if (tmptok == "FormulaMacro") {
1028                         inset = new InsetFormulaMacro;
1029                 } else if (tmptok == "Formula") {
1030                         inset = new InsetFormula;
1031                 } else if (tmptok == "Figure") {
1032                         inset = new InsetFig(100, 100, *this);
1033                 } else if (tmptok == "Info") {
1034                         inset = new InsetInfo;
1035                 } else if (tmptok == "Include") {
1036                         InsetCommandParams p( "Include" );
1037                         inset = new InsetInclude(p, *this);
1038                 } else if (tmptok == "ERT") {
1039                         inset = new InsetERT;
1040                 } else if (tmptok == "Tabular") {
1041                         inset = new InsetTabular(*this);
1042                 } else if (tmptok == "Text") {
1043                         inset = new InsetText;
1044                 } else if (tmptok == "Foot") {
1045                         inset = new InsetFoot;
1046                 } else if (tmptok == "Marginal") {
1047                         inset = new InsetMarginal;
1048                 } else if (tmptok == "Minipage") {
1049                         inset = new InsetMinipage;
1050                 } else if (tmptok == "Float") {
1051                         lex.next();
1052                         string tmptok = lex.GetString();
1053                         inset = new InsetFloat(tmptok);
1054                 } else if (tmptok == "List") {
1055                         inset = new InsetList;
1056                 } else if (tmptok == "Theorem") {
1057                         inset = new InsetList;
1058                 } else if (tmptok == "Caption") {
1059                         inset = new InsetCaption;
1060                 } else if (tmptok == "GRAPHICS") {
1061                         inset = new InsetGraphics;
1062                 }
1063
1064                 if (inset) inset->Read(this, lex);
1065         }
1066
1067         if (inset) {
1068                 par->InsertInset(pos, inset, font);
1069                 ++pos;
1070         }
1071 }
1072
1073
1074 bool Buffer::readFile(LyXLex & lex, LyXParagraph * par)
1075 {
1076         if (lex.IsOK()) {
1077                 lex.next();
1078                 string const token(lex.GetString());
1079                 if (token == "\\lyxformat") { // the first token _must_ be...
1080                         lex.EatLine();
1081                         string tmp_format = lex.GetString();
1082                         //lyxerr << "LyX Format: `" << tmp_format << "'" << endl;
1083                         // if present remove ".," from string.
1084                         string::size_type dot = tmp_format.find_first_of(".,");
1085                         //lyxerr << "           dot found at " << dot << endl;
1086                         if (dot != string::npos)
1087                                 tmp_format.erase(dot, 1);
1088                         file_format = strToInt(tmp_format);
1089                         if (file_format == LYX_FORMAT) {
1090                                 // current format
1091                         } else if (file_format > LYX_FORMAT) {
1092                                 // future format
1093                                 WriteAlert(_("Warning!"),
1094                                            _("LyX file format is newer that what"),
1095                                            _("is supported in this LyX version. Expect some problems."));
1096
1097                         } else if (file_format < LYX_FORMAT) {
1098                                 // old formats
1099                                 if (file_format < 200) {
1100                                         WriteAlert(_("ERROR!"),
1101                                                    _("Old LyX file format found. "
1102                                                      "Use LyX 0.10.x to read this!"));
1103                                         return false;
1104                                 }
1105                         }
1106                         bool the_end = readLyXformat2(lex, par);
1107                         setPaperStuff();
1108                         // the_end was added in 213
1109                         if (file_format < 213)
1110                                 the_end = true;
1111
1112                         if (!the_end)
1113                                 WriteAlert(_("Warning!"),
1114                                            _("Reading of document is not complete"),
1115                                            _("Maybe the document is truncated"));
1116                         return true;
1117                 } else { // "\\lyxformat" not found
1118                         WriteAlert(_("ERROR!"), _("Not a LyX file!"));
1119                 }
1120         } else
1121                 WriteAlert(_("ERROR!"), _("Unable to read file!"));
1122         return false;
1123 }
1124
1125
1126
1127 // Should probably be moved to somewhere else: BufferView? LyXView?
1128 bool Buffer::save() const
1129 {
1130         // We don't need autosaves in the immediate future. (Asger)
1131         resetAutosaveTimers();
1132
1133         // make a backup
1134         string s;
1135         if (lyxrc.make_backup) {
1136                 s = fileName() + '~';
1137                 if (!lyxrc.backupdir_path.empty())
1138                         s = AddName(lyxrc.backupdir_path,
1139                                     subst(CleanupPath(s),'/','!'));
1140
1141                 // Rename is the wrong way of making a backup,
1142                 // this is the correct way.
1143                 /* truss cp fil fil2:
1144                    lstat("LyXVC3.lyx", 0xEFFFF898)                 Err#2 ENOENT
1145                    stat("LyXVC.lyx", 0xEFFFF688)                   = 0
1146                    open("LyXVC.lyx", O_RDONLY)                     = 3
1147                    open("LyXVC3.lyx", O_WRONLY|O_CREAT|O_TRUNC, 0600) = 4
1148                    fstat(4, 0xEFFFF508)                            = 0
1149                    fstat(3, 0xEFFFF508)                            = 0
1150                    read(3, " # T h i s   f i l e   w".., 8192)     = 5579
1151                    write(4, " # T h i s   f i l e   w".., 5579)    = 5579
1152                    read(3, 0xEFFFD4A0, 8192)                       = 0
1153                    close(4)                                        = 0
1154                    close(3)                                        = 0
1155                    chmod("LyXVC3.lyx", 0100644)                    = 0
1156                    lseek(0, 0, SEEK_CUR)                           = 46440
1157                    _exit(0)
1158                 */
1159
1160                 // Should proabaly have some more error checking here.
1161                 // Should be cleaned up in 0.13, at least a bit.
1162                 // Doing it this way, also makes the inodes stay the same.
1163                 // This is still not a very good solution, in particular we
1164                 // might loose the owner of the backup.
1165                 FileInfo finfo(fileName());
1166                 if (finfo.exist()) {
1167                         mode_t fmode = finfo.getMode();
1168                         struct utimbuf times = {
1169                                 finfo.getAccessTime(),
1170                                 finfo.getModificationTime() };
1171
1172                         ifstream ifs(fileName().c_str());
1173                         ofstream ofs(s.c_str(), ios::out|ios::trunc);
1174                         if (ifs && ofs) {
1175                                 ofs << ifs.rdbuf();
1176                                 ifs.close();
1177                                 ofs.close();
1178                                 ::chmod(s.c_str(), fmode);
1179
1180                                 if (::utime(s.c_str(), &times)) {
1181                                         lyxerr << "utime error." << endl;
1182                                 }
1183                         } else {
1184                                 lyxerr << "LyX was not able to make "
1185                                         "backupcopy. Beware." << endl;
1186                         }
1187                 }
1188         }
1189
1190         if (writeFile(fileName(), false)) {
1191                 markLyxClean();
1192                 removeAutosaveFile(fileName());
1193         } else {
1194                 // Saving failed, so backup is not backup
1195                 if (lyxrc.make_backup) {
1196                         lyx::rename(s, fileName());
1197                 }
1198                 return false;
1199         }
1200         return true;
1201 }
1202
1203
1204 // Returns false if unsuccesful
1205 bool Buffer::writeFile(string const & fname, bool flag) const
1206 {
1207         // if flag is false writeFile will not create any GUI
1208         // warnings, only cerr.
1209         // Needed for autosave in background or panic save (Matthias 120496)
1210
1211         if (read_only && (fname == filename)) {
1212                 // Here we should come with a question if we should
1213                 // perform the write anyway.
1214                 if (flag)
1215                         lyxerr << _("Error! Document is read-only: ")
1216                                << fname << endl;
1217                 else
1218                         WriteAlert(_("Error! Document is read-only: "),
1219                                    fname);
1220                 return false;
1221         }
1222
1223         FileInfo finfo(fname);
1224         if (finfo.exist() && !finfo.writable()) {
1225                 // Here we should come with a question if we should
1226                 // try to do the save anyway. (i.e. do a chmod first)
1227                 if (flag)
1228                         lyxerr << _("Error! Cannot write file: ")
1229                                << fname << endl;
1230                 else
1231                         WriteFSAlert(_("Error! Cannot write file: "),
1232                                      fname);
1233                 return false;
1234         }
1235
1236         ofstream ofs(fname.c_str());
1237         if (!ofs) {
1238                 if (flag)
1239                         lyxerr << _("Error! Cannot open file: ")
1240                                << fname << endl;
1241                 else
1242                         WriteFSAlert(_("Error! Cannot open file: "),
1243                                      fname);
1244                 return false;
1245         }
1246
1247 #ifdef HAVE_LOCALE
1248         // Use the standard "C" locale for file output.
1249         ofs.imbue(std::locale::classic());
1250 #endif
1251
1252         // The top of the file should not be written by params.
1253
1254         // write out a comment in the top of the file
1255         ofs << '#' << LYX_DOCVERSION
1256             << " created this file. For more info see http://www.lyx.org/\n"
1257             << "\\lyxformat " << LYX_FORMAT << "\n";
1258
1259         // now write out the buffer paramters.
1260         params.writeFile(ofs);
1261
1262         char footnoteflag = 0;
1263         char depth = 0;
1264
1265         // this will write out all the paragraphs
1266         // using recursive descent.
1267         paragraph->writeFile(this, ofs, params, footnoteflag, depth);
1268
1269         // Write marker that shows file is complete
1270         ofs << "\n\\the_end" << endl;
1271
1272         ofs.close();
1273
1274         // how to check if close went ok?
1275         // Following is an attempt... (BE 20001011)
1276
1277         // good() returns false if any error occured, including some
1278         //        formatting error.
1279         // bad()  returns true if something bad happened in the buffer,
1280         //        which should include file system full errors.
1281
1282         bool status = true;
1283         if (!ofs.good()) {
1284                 status = false;
1285 #if 0
1286                 if (ofs.bad()) {
1287                         lyxerr << "Buffer::writeFile: BAD ERROR!" << endl;
1288                 } else {
1289                         lyxerr << "Buffer::writeFile: NOT SO BAD ERROR!"
1290                                << endl;
1291                 }
1292 #endif
1293         }
1294
1295         return status;
1296 }
1297
1298
1299 string const Buffer::asciiParagraph(LyXParagraph const * par,
1300                                     unsigned int linelen) const
1301 {
1302         ostringstream buffer;
1303         LyXFont font1;
1304         LyXFont font2;
1305         Inset const * inset;
1306         char c;
1307 #ifndef NEW_INSETS
1308         LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE;
1309 #endif
1310         char depth = 0;
1311         int ltype = 0;
1312         int ltype_depth = 0;
1313         unsigned int currlinelen = 0;
1314         bool ref_printed = false;
1315
1316         int noparbreak = 0;
1317         int islatex = 0;
1318         if (
1319 #ifndef NEW_INSETS
1320                 par->footnoteflag != LyXParagraph::NO_FOOTNOTE ||
1321 #endif
1322                 !par->previous
1323 #ifndef NEW_INSETS
1324                 || par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE
1325 #endif
1326                 ){
1327 #ifndef NEW_INSETS
1328                 /* begins a footnote environment ? */
1329                 if (footnoteflag != par->footnoteflag) {
1330                         footnoteflag = par->footnoteflag;
1331                         if (footnoteflag) {
1332                                 size_t const j = strlen(string_footnotekinds[par->footnotekind]) + 4;
1333                                 if ((linelen > 0) &&
1334                                     ((currlinelen + j) > linelen)) {
1335                                         buffer << "\n";
1336                                         currlinelen = 0;
1337                                 }
1338                                 buffer << "(["
1339                                        << string_footnotekinds[par->footnotekind]
1340                                        << "] ";
1341                                 currlinelen += j;
1342                         }
1343                 }
1344 #endif
1345                 /* begins or ends a deeper area ?*/
1346                 if (depth != par->depth) {
1347                         if (par->depth > depth) {
1348                                 while (par->depth > depth) {
1349                                         ++depth;
1350                                 }
1351                         }
1352                         else {
1353                                 while (par->depth < depth) {
1354                                         --depth;
1355                                 }
1356                         }
1357                 }
1358
1359                 /* First write the layout */
1360                 string const tmp = textclasslist.NameOfLayout(params.textclass, par->layout);
1361                 if (tmp == "Itemize") {
1362                         ltype = 1;
1363                         ltype_depth = depth+1;
1364                 } else if (tmp == "Enumerate") {
1365                         ltype = 2;
1366                         ltype_depth = depth+1;
1367                 } else if (strstr(tmp.c_str(), "ection")) {
1368                         ltype = 3;
1369                         ltype_depth = depth+1;
1370                 } else if (strstr(tmp.c_str(), "aragraph")) {
1371                         ltype = 4;
1372                         ltype_depth = depth+1;
1373                 } else if (tmp == "Description") {
1374                         ltype = 5;
1375                         ltype_depth = depth+1;
1376                 } else if (tmp == "Abstract") {
1377                         ltype = 6;
1378                         ltype_depth = 0;
1379                 } else if (tmp == "Bibliography") {
1380                         ltype = 7;
1381                         ltype_depth = 0;
1382                 } else {
1383                         ltype = 0;
1384                         ltype_depth = 0;
1385                 }
1386
1387                 /* maybe some vertical spaces */
1388
1389                 /* the labelwidthstring used in lists */
1390
1391                 /* some lines? */
1392
1393                 /* some pagebreaks? */
1394
1395                 /* noindent ? */
1396
1397                 /* what about the alignment */
1398         } else {
1399 #ifndef NEW_INSETS
1400                 /* dummy layout, that means a footnote ended */
1401                 footnoteflag = LyXParagraph::NO_FOOTNOTE;
1402                 buffer << ") ";
1403                 noparbreak = 1;
1404 #else
1405                 lyxerr << "Should this ever happen?" << endl;
1406 #endif
1407         }
1408
1409         font1 = LyXFont(LyXFont::ALL_INHERIT, params.language);
1410         for (LyXParagraph::size_type i = 0; i < par->size(); ++i) {
1411                 if (!i &&
1412 #ifndef NEW_INSETS
1413                     !footnoteflag &&
1414 #endif
1415                     !noparbreak) {
1416                         if (linelen > 0)
1417                                 buffer << "\n\n";
1418                         for (char j = 0; j < depth; ++j)
1419                                 buffer << "  ";
1420                         currlinelen = depth * 2;
1421                         switch (ltype) {
1422                         case 0: /* Standard */
1423                         case 4: /* (Sub)Paragraph */
1424                         case 5: /* Description */
1425                                 break;
1426                         case 6: /* Abstract */
1427                                 if (linelen > 0)
1428                                         buffer << "Abstract\n\n";
1429                                 else
1430                                         buffer << "Abstract: ";
1431                                 break;
1432                         case 7: /* Bibliography */
1433                                 if (!ref_printed) {
1434                                         if (linelen > 0)
1435                                                 buffer << "References\n\n";
1436                                         else
1437                                                 buffer << "References: ";
1438                                         ref_printed = true;
1439                                 }
1440                                 break;
1441                         default:
1442                                 buffer << par->labelstring << " ";
1443                                 break;
1444                         }
1445                         if (ltype_depth > depth) {
1446                                 for (char j = ltype_depth - 1; j > depth; --j)
1447                                         buffer << "  ";
1448                                 currlinelen += (ltype_depth-depth)*2;
1449                         }
1450                 }
1451                 font2 = par->GetFontSettings(params, i);
1452                 if (font1.latex() != font2.latex()) {
1453                         if (font2.latex() == LyXFont::OFF)
1454                                 islatex = 0;
1455                         else
1456                                 islatex = 1;
1457                 } else {
1458                         islatex = 0;
1459                 }
1460                 c = par->GetUChar(params, i);
1461                 if (islatex)
1462                         continue;
1463                 switch (c) {
1464                 case LyXParagraph::META_INSET:
1465                         if ((inset = par->GetInset(i))) {
1466                                 if (!inset->Ascii(this, buffer)) {
1467                                         string dummy;
1468                                         string s = rsplit(buffer.str().c_str(),
1469                                                           dummy, '\n');
1470                                         currlinelen += s.length();
1471                                 } else {
1472                                         // to be sure it breaks paragraph
1473                                         currlinelen += linelen;
1474                                 }
1475                         }
1476                         break;
1477                 case LyXParagraph::META_NEWLINE:
1478                         if (linelen > 0) {
1479                                 buffer << "\n";
1480                                 for (char j = 0; j < depth; ++j)
1481                                         buffer << "  ";
1482                         }
1483                         currlinelen = depth * 2;
1484                         if (ltype_depth > depth) {
1485                                 for (char j = ltype_depth;
1486                                     j > depth; --j)
1487                                         buffer << "  ";
1488                                 currlinelen += (ltype_depth - depth) * 2;
1489                         }
1490                         break;
1491                 case LyXParagraph::META_HFILL:
1492                         buffer << "\t";
1493                         break;
1494                 case '\\':
1495                         buffer << "\\";
1496                         break;
1497                 default:
1498                         if ((linelen > 0) && (currlinelen > (linelen - 10)) &&
1499                             (c == ' ') && ((i + 2) < par->size()))
1500                         {
1501                                 buffer << "\n";
1502                                 for (char j = 0; j < depth; ++j)
1503                                         buffer << "  ";
1504                                 currlinelen = depth * 2;
1505                                 if (ltype_depth > depth) {
1506                                         for (char j = ltype_depth;
1507                                             j > depth; --j)
1508                                                 buffer << "  ";
1509                                         currlinelen += (ltype_depth-depth)*2;
1510                                 }
1511                         } else if (c != '\0')
1512                                 buffer << c;
1513                         else if (c == '\0')
1514                                 lyxerr.debug() << "writeAsciiFile: NULL char in structure." << endl;
1515                         ++currlinelen;
1516                         break;
1517                 }
1518         }
1519         return buffer.str().c_str();
1520 }
1521
1522
1523 void Buffer::writeFileAscii(string const & fname, int linelen)
1524 {
1525         ofstream ofs(fname.c_str());
1526         if (!ofs) {
1527                 WriteFSAlert(_("Error: Cannot write file:"), fname);
1528                 return;
1529         }
1530         writeFileAscii(ofs, linelen);
1531 }
1532
1533
1534 void Buffer::writeFileAscii(ostream & ofs, int linelen)
1535 {
1536         LyXParagraph * par = paragraph;
1537         while (par) {
1538                 ofs << asciiParagraph(par, linelen);
1539                 par = par->next;
1540         }
1541         ofs << "\n";
1542 }
1543
1544
1545 void Buffer::makeLaTeXFile(string const & fname,
1546                            string const & original_path,
1547                            bool nice, bool only_body)
1548 {
1549         lyxerr[Debug::LATEX] << "makeLaTeXFile..." << endl;
1550
1551         niceFile = nice; // this will be used by Insetincludes.
1552
1553         tex_code_break_column = lyxrc.ascii_linelen;
1554
1555         LyXTextClass const & tclass =
1556                 textclasslist.TextClass(params.textclass);
1557
1558         ofstream ofs(fname.c_str());
1559         if (!ofs) {
1560                 WriteFSAlert(_("Error: Cannot open file: "), fname);
1561                 return;
1562         }
1563
1564         // validate the buffer.
1565         lyxerr[Debug::LATEX] << "  Validating buffer..." << endl;
1566         LaTeXFeatures features(params, tclass.numLayouts());
1567         validate(features);
1568         lyxerr[Debug::LATEX] << "  Buffer validation done." << endl;
1569
1570         texrow.reset();
1571         // The starting paragraph of the coming rows is the
1572         // first paragraph of the document. (Asger)
1573         texrow.start(paragraph, 0);
1574
1575         if (!only_body && nice) {
1576                 ofs << "%% " LYX_DOCVERSION " created this file.  "
1577                         "For more info, see http://www.lyx.org/.\n"
1578                         "%% Do not edit unless you really know what "
1579                         "you are doing.\n";
1580                 texrow.newline();
1581                 texrow.newline();
1582         }
1583         lyxerr.debug() << "lyx header finished" << endl;
1584         // There are a few differences between nice LaTeX and usual files:
1585         // usual is \batchmode and has a
1586         // special input@path to allow the including of figures
1587         // with either \input or \includegraphics (what figinsets do).
1588         // batchmode is not set if there is a tex_code_break_column.
1589         // In this case somebody is interested in the generated LaTeX,
1590         // so this is OK. input@path is set when the actual parameter
1591         // original_path is set. This is done for usual tex-file, but not
1592         // for nice-latex-file. (Matthias 250696)
1593         if (!only_body) {
1594                 if (!nice){
1595                         // code for usual, NOT nice-latex-file
1596                         ofs << "\\batchmode\n"; // changed
1597                         // from \nonstopmode
1598                         texrow.newline();
1599                 }
1600                 if (!original_path.empty()) {
1601                         ofs << "\\makeatletter\n"
1602                             << "\\def\\input@path{{"
1603                             << original_path << "/}}\n"
1604                             << "\\makeatother\n";
1605                         texrow.newline();
1606                         texrow.newline();
1607                         texrow.newline();
1608                 }
1609
1610                 ofs << "\\documentclass";
1611
1612                 string options; // the document class options.
1613
1614                 if (tokenPos(tclass.opt_fontsize(),
1615                              '|', params.fontsize) >= 0) {
1616                         // only write if existing in list (and not default)
1617                         options += params.fontsize;
1618                         options += "pt,";
1619                 }
1620
1621
1622                 if (!params.use_geometry &&
1623                     (params.paperpackage == BufferParams::PACKAGE_NONE)) {
1624                         switch (params.papersize) {
1625                         case BufferParams::PAPER_A4PAPER:
1626                                 options += "a4paper,";
1627                                 break;
1628                         case BufferParams::PAPER_USLETTER:
1629                                 options += "letterpaper,";
1630                                 break;
1631                         case BufferParams::PAPER_A5PAPER:
1632                                 options += "a5paper,";
1633                                 break;
1634                         case BufferParams::PAPER_B5PAPER:
1635                                 options += "b5paper,";
1636                                 break;
1637                         case BufferParams::PAPER_EXECUTIVEPAPER:
1638                                 options += "executivepaper,";
1639                                 break;
1640                         case BufferParams::PAPER_LEGALPAPER:
1641                                 options += "legalpaper,";
1642                                 break;
1643                         }
1644                 }
1645
1646                 // if needed
1647                 if (params.sides != tclass.sides()) {
1648                         switch (params.sides) {
1649                         case LyXTextClass::OneSide:
1650                                 options += "oneside,";
1651                                 break;
1652                         case LyXTextClass::TwoSides:
1653                                 options += "twoside,";
1654                                 break;
1655                         }
1656
1657                 }
1658
1659                 // if needed
1660                 if (params.columns != tclass.columns()) {
1661                         if (params.columns == 2)
1662                                 options += "twocolumn,";
1663                         else
1664                                 options += "onecolumn,";
1665                 }
1666
1667                 if (!params.use_geometry
1668                     && params.orientation == BufferParams::ORIENTATION_LANDSCAPE)
1669                         options += "landscape,";
1670
1671                 // language should be a parameter to \documentclass
1672                 bool use_babel = false;
1673                 if (params.language->babel() == "hebrew"
1674                     && default_language->babel() != "hebrew")
1675                          // This seems necessary
1676                         features.UsedLanguages.insert(default_language);
1677 #ifdef DO_USE_DEFAULT_LANGUAGE
1678                 if (params.language->lang() != "default" ||
1679                     !features.UsedLanguages.empty()) {
1680 #endif
1681                         use_babel = true;
1682                         for (LaTeXFeatures::LanguageList::const_iterator cit =
1683                                      features.UsedLanguages.begin();
1684                              cit != features.UsedLanguages.end(); ++cit)
1685                                 options += (*cit)->babel() + ",";
1686                         options += params.language->babel() + ',';
1687 #ifdef DO_USE_DEFAULT_LANGUAGE
1688                 }
1689 #endif
1690
1691                 // the user-defined options
1692                 if (!params.options.empty()) {
1693                         options += params.options + ',';
1694                 }
1695
1696                 if (!options.empty()){
1697                         options = strip(options, ',');
1698                         ofs << '[' << options << ']';
1699                 }
1700
1701                 ofs << '{'
1702                     << textclasslist.LatexnameOfClass(params.textclass)
1703                     << "}\n";
1704                 texrow.newline();
1705                 // end of \documentclass defs
1706
1707                 // font selection must be done before loading fontenc.sty
1708                 // The ae package is not needed when using OT1 font encoding.
1709                 if (params.fonts != "default" &&
1710                     (params.fonts != "ae" || lyxrc.fontenc != "default")) {
1711                         ofs << "\\usepackage{" << params.fonts << "}\n";
1712                         texrow.newline();
1713                         if (params.fonts == "ae") {
1714                                 ofs << "\\usepackage{aecompl}\n";
1715                                 texrow.newline();
1716                         }
1717                 }
1718                 // this one is not per buffer
1719                 if (lyxrc.fontenc != "default") {
1720                         ofs << "\\usepackage[" << lyxrc.fontenc
1721                             << "]{fontenc}\n";
1722                         texrow.newline();
1723                 }
1724
1725                 if (params.inputenc == "auto") {
1726                         string const doc_encoding =
1727                                 params.language->encoding()->LatexName();
1728
1729                         // Create a list with all the input encodings used
1730                         // in the document
1731                         set<string> encodings;
1732                         for (LaTeXFeatures::LanguageList::const_iterator it =
1733                                      features.UsedLanguages.begin();
1734                              it != features.UsedLanguages.end(); ++it)
1735                                 if ((*it)->encoding()->LatexName() != doc_encoding)
1736                                         encodings.insert((*it)->encoding()->LatexName());
1737
1738                         ofs << "\\usepackage[";
1739                         std::copy(encodings.begin(), encodings.end(),
1740                                   std::ostream_iterator<string>(ofs, ","));
1741                         ofs << doc_encoding << "]{inputenc}\n";
1742                         texrow.newline();
1743                 } else if (params.inputenc != "default") {
1744                         ofs << "\\usepackage[" << params.inputenc
1745                             << "]{inputenc}\n";
1746                         texrow.newline();
1747                 }
1748
1749                 // At the very beginning the text parameters.
1750                 if (params.paperpackage != BufferParams::PACKAGE_NONE) {
1751                         switch (params.paperpackage) {
1752                         case BufferParams::PACKAGE_A4:
1753                                 ofs << "\\usepackage{a4}\n";
1754                                 texrow.newline();
1755                                 break;
1756                         case BufferParams::PACKAGE_A4WIDE:
1757                                 ofs << "\\usepackage{a4wide}\n";
1758                                 texrow.newline();
1759                                 break;
1760                         case BufferParams::PACKAGE_WIDEMARGINSA4:
1761                                 ofs << "\\usepackage[widemargins]{a4}\n";
1762                                 texrow.newline();
1763                                 break;
1764                         }
1765                 }
1766                 if (params.use_geometry) {
1767                         ofs << "\\usepackage{geometry}\n";
1768                         texrow.newline();
1769                         ofs << "\\geometry{verbose";
1770                         if (params.orientation == BufferParams::ORIENTATION_LANDSCAPE)
1771                                 ofs << ",landscape";
1772                         switch (params.papersize2) {
1773                         case BufferParams::VM_PAPER_CUSTOM:
1774                                 if (!params.paperwidth.empty())
1775                                         ofs << ",paperwidth="
1776                                             << params.paperwidth;
1777                                 if (!params.paperheight.empty())
1778                                         ofs << ",paperheight="
1779                                             << params.paperheight;
1780                                 break;
1781                         case BufferParams::VM_PAPER_USLETTER:
1782                                 ofs << ",letterpaper";
1783                                 break;
1784                         case BufferParams::VM_PAPER_USLEGAL:
1785                                 ofs << ",legalpaper";
1786                                 break;
1787                         case BufferParams::VM_PAPER_USEXECUTIVE:
1788                                 ofs << ",executivepaper";
1789                                 break;
1790                         case BufferParams::VM_PAPER_A3:
1791                                 ofs << ",a3paper";
1792                                 break;
1793                         case BufferParams::VM_PAPER_A4:
1794                                 ofs << ",a4paper";
1795                                 break;
1796                         case BufferParams::VM_PAPER_A5:
1797                                 ofs << ",a5paper";
1798                                 break;
1799                         case BufferParams::VM_PAPER_B3:
1800                                 ofs << ",b3paper";
1801                                 break;
1802                         case BufferParams::VM_PAPER_B4:
1803                                 ofs << ",b4paper";
1804                                 break;
1805                         case BufferParams::VM_PAPER_B5:
1806                                 ofs << ",b5paper";
1807                                 break;
1808                         default:
1809                                 // default papersize ie BufferParams::VM_PAPER_DEFAULT
1810                                 switch (lyxrc.default_papersize) {
1811                                 case BufferParams::PAPER_DEFAULT: // keep compiler happy
1812                                 case BufferParams::PAPER_USLETTER:
1813                                         ofs << ",letterpaper";
1814                                         break;
1815                                 case BufferParams::PAPER_LEGALPAPER:
1816                                         ofs << ",legalpaper";
1817                                         break;
1818                                 case BufferParams::PAPER_EXECUTIVEPAPER:
1819                                         ofs << ",executivepaper";
1820                                         break;
1821                                 case BufferParams::PAPER_A3PAPER:
1822                                         ofs << ",a3paper";
1823                                         break;
1824                                 case BufferParams::PAPER_A4PAPER:
1825                                         ofs << ",a4paper";
1826                                         break;
1827                                 case BufferParams::PAPER_A5PAPER:
1828                                         ofs << ",a5paper";
1829                                         break;
1830                                 case BufferParams::PAPER_B5PAPER:
1831                                         ofs << ",b5paper";
1832                                         break;
1833                                 }
1834                         }
1835                         if (!params.topmargin.empty())
1836                                 ofs << ",tmargin=" << params.topmargin;
1837                         if (!params.bottommargin.empty())
1838                                 ofs << ",bmargin=" << params.bottommargin;
1839                         if (!params.leftmargin.empty())
1840                                 ofs << ",lmargin=" << params.leftmargin;
1841                         if (!params.rightmargin.empty())
1842                                 ofs << ",rmargin=" << params.rightmargin;
1843                         if (!params.headheight.empty())
1844                                 ofs << ",headheight=" << params.headheight;
1845                         if (!params.headsep.empty())
1846                                 ofs << ",headsep=" << params.headsep;
1847                         if (!params.footskip.empty())
1848                                 ofs << ",footskip=" << params.footskip;
1849                         ofs << "}\n";
1850                         texrow.newline();
1851                 }
1852                 if (features.amsstyle
1853                     && !tclass.provides(LyXTextClass::amsmath)) {
1854                         ofs << "\\usepackage{amsmath}\n";
1855                         texrow.newline();
1856                 }
1857
1858                 if (tokenPos(tclass.opt_pagestyle(),
1859                              '|', params.pagestyle) >= 0) {
1860                         if (params.pagestyle == "fancy") {
1861                                 ofs << "\\usepackage{fancyhdr}\n";
1862                                 texrow.newline();
1863                         }
1864                         ofs << "\\pagestyle{" << params.pagestyle << "}\n";
1865                         texrow.newline();
1866                 }
1867
1868                 // We try to load babel late, in case it interferes
1869                 // with other packages.
1870                 if (use_babel) {
1871                         ofs << lyxrc.language_package << endl;
1872                         texrow.newline();
1873                 }
1874
1875                 if (params.secnumdepth != tclass.secnumdepth()) {
1876                         ofs << "\\setcounter{secnumdepth}{"
1877                             << params.secnumdepth
1878                             << "}\n";
1879                         texrow.newline();
1880                 }
1881                 if (params.tocdepth != tclass.tocdepth()) {
1882                         ofs << "\\setcounter{tocdepth}{"
1883                             << params.tocdepth
1884                             << "}\n";
1885                         texrow.newline();
1886                 }
1887
1888                 if (params.paragraph_separation) {
1889                         switch (params.defskip.kind()) {
1890                         case VSpace::SMALLSKIP:
1891                                 ofs << "\\setlength\\parskip{\\smallskipamount}\n";
1892                                 break;
1893                         case VSpace::MEDSKIP:
1894                                 ofs << "\\setlength\\parskip{\\medskipamount}\n";
1895                                 break;
1896                         case VSpace::BIGSKIP:
1897                                 ofs << "\\setlength\\parskip{\\bigskipamount}\n";
1898                                 break;
1899                         case VSpace::LENGTH:
1900                                 ofs << "\\setlength\\parskip{"
1901                                     << params.defskip.length().asLatexString()
1902                                     << "}\n";
1903                                 break;
1904                         default: // should never happen // Then delete it.
1905                                 ofs << "\\setlength\\parskip{\\medskipamount}\n";
1906                                 break;
1907                         }
1908                         texrow.newline();
1909
1910                         ofs << "\\setlength\\parindent{0pt}\n";
1911                         texrow.newline();
1912                 }
1913
1914                 // Now insert the LyX specific LaTeX commands...
1915
1916                 // The optional packages;
1917                 string preamble(features.getPackages());
1918
1919                 // this might be useful...
1920                 preamble += "\n\\makeatletter\n";
1921
1922                 // Some macros LyX will need
1923                 string tmppreamble(features.getMacros());
1924
1925                 if (!tmppreamble.empty()) {
1926                         preamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1927                                 "LyX specific LaTeX commands.\n"
1928                                 + tmppreamble + '\n';
1929                 }
1930
1931                 // the text class specific preamble
1932                 tmppreamble = features.getTClassPreamble();
1933                 if (!tmppreamble.empty()) {
1934                         preamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1935                                 "Textclass specific LaTeX commands.\n"
1936                                 + tmppreamble + '\n';
1937                 }
1938
1939                 /* the user-defined preamble */
1940                 if (!params.preamble.empty()) {
1941                         preamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
1942                                 "User specified LaTeX commands.\n"
1943                                 + params.preamble + '\n';
1944                 }
1945
1946                 preamble += "\\makeatother\n";
1947
1948                 // Itemize bullet settings need to be last in case the user
1949                 // defines their own bullets that use a package included
1950                 // in the user-defined preamble -- ARRae
1951                 // Actually it has to be done much later than that
1952                 // since some packages like frenchb make modifications
1953                 // at \begin{document} time -- JMarc
1954                 string bullets_def;
1955                 for (int i = 0; i < 4; ++i) {
1956                         if (params.user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) {
1957                                 if (bullets_def.empty())
1958                                         bullets_def="\\AtBeginDocument{\n";
1959                                 bullets_def += "  \\renewcommand{\\labelitemi";
1960                                 switch (i) {
1961                                 // `i' is one less than the item to modify
1962                                 case 0:
1963                                         break;
1964                                 case 1:
1965                                         bullets_def += 'i';
1966                                         break;
1967                                 case 2:
1968                                         bullets_def += "ii";
1969                                         break;
1970                                 case 3:
1971                                         bullets_def += 'v';
1972                                         break;
1973                                 }
1974                                 bullets_def += "}{" +
1975                                   params.user_defined_bullets[i].getText()
1976                                   + "}\n";
1977                         }
1978                 }
1979
1980                 if (!bullets_def.empty())
1981                   preamble += bullets_def + "}\n\n";
1982
1983                 for (int j = countChar(preamble, '\n'); j-- ;) {
1984                         texrow.newline();
1985                 }
1986
1987                 ofs << preamble;
1988
1989                 // make the body.
1990                 ofs << "\\begin{document}\n";
1991                 texrow.newline();
1992         } // only_body
1993         lyxerr.debug() << "preamble finished, now the body." << endl;
1994 #ifdef DO_USE_DEFAULT_LANGUAGE
1995         if (!lyxrc.language_auto_begin && params.language->lang() != "default") {
1996 #else
1997         if (!lyxrc.language_auto_begin) {
1998 #endif
1999                 ofs << subst(lyxrc.language_command_begin, "$$lang",
2000                              params.language->babel())
2001                     << endl;
2002                 texrow.newline();
2003         }
2004
2005         latexParagraphs(ofs, paragraph, 0, texrow);
2006
2007         // add this just in case after all the paragraphs
2008         ofs << endl;
2009         texrow.newline();
2010
2011 #ifdef DO_USE_DEFAULT_LANGUAGE
2012         if (!lyxrc.language_auto_end && params.language->lang() != "default") {
2013 #else
2014                 if (!lyxrc.language_auto_end) {
2015 #endif
2016                 ofs << subst(lyxrc.language_command_end, "$$lang",
2017                              params.language->babel())
2018                     << endl;
2019                 texrow.newline();
2020         }
2021
2022         if (!only_body) {
2023                 ofs << "\\end{document}\n";
2024                 texrow.newline();
2025
2026                 lyxerr[Debug::LATEX] << "makeLaTeXFile...done" << endl;
2027         } else {
2028                 lyxerr[Debug::LATEX] << "LaTeXFile for inclusion made."
2029                                      << endl;
2030         }
2031
2032         // Just to be sure. (Asger)
2033         texrow.newline();
2034
2035         // tex_code_break_column's value is used to decide
2036         // if we are in batchmode or not (within mathed_write()
2037         // in math_write.C) so we must set it to a non-zero
2038         // value when we leave otherwise we save incorrect .lyx files.
2039         tex_code_break_column = lyxrc.ascii_linelen;
2040
2041         ofs.close();
2042         if (ofs.fail()) {
2043                 lyxerr << "File was not closed properly." << endl;
2044         }
2045
2046         lyxerr.debug() << "Finished making latex file." << endl;
2047 }
2048
2049
2050 //
2051 // LaTeX all paragraphs from par to endpar, if endpar == 0 then to the end
2052 //
2053 void Buffer::latexParagraphs(ostream & ofs, LyXParagraph * par,
2054                              LyXParagraph * endpar, TexRow & texrow) const
2055 {
2056         bool was_title = false;
2057         bool already_title = false;
2058         std::ostringstream ftnote;
2059         TexRow ft_texrow;
2060         int ftcount = 0;
2061
2062         // if only_body
2063         while (par != endpar) {
2064 #ifndef NEW_INSETS
2065                 if (par->IsDummy())
2066                         lyxerr[Debug::LATEX] << "Error in latexParagraphs."
2067                                              << endl;
2068 #endif
2069                 LyXLayout const & layout =
2070                         textclasslist.Style(params.textclass,
2071                                             par->layout);
2072
2073                 if (layout.intitle) {
2074                         if (already_title) {
2075                                 lyxerr <<"Error in latexParagraphs: You"
2076                                         " should not mix title layouts"
2077                                         " with normal ones." << endl;
2078                         } else
2079                                 was_title = true;
2080                 } else if (was_title && !already_title) {
2081                         ofs << "\\maketitle\n";
2082                         texrow.newline();
2083                         already_title = true;
2084                         was_title = false;
2085                 }
2086                 // We are at depth 0 so we can just use
2087                 // ordinary \footnote{} generation
2088                 // flag this with ftcount
2089                 ftcount = -1;
2090                 if (layout.isEnvironment()
2091                     || par->pextra_type != LyXParagraph::PEXTRA_NONE) {
2092                         par = par->TeXEnvironment(this, params, ofs, texrow
2093 #ifndef NEW_INSETS
2094                                                   ,ftnote, ft_texrow, ftcount
2095 #endif
2096                                 );
2097                 } else {
2098                         par = par->TeXOnePar(this, params, ofs, texrow, false
2099 #ifndef NEW_INSETS
2100                                              ,
2101                                              ftnote, ft_texrow, ftcount
2102 #endif
2103                                 );
2104                 }
2105
2106                 // Write out what we've generated...
2107                 if (ftcount >= 1) {
2108                         if (ftcount > 1) {
2109                                 ofs << "\\addtocounter{footnote}{-"
2110                                     << ftcount - 1
2111                                     << '}';
2112                         }
2113                         ofs << ftnote.str();
2114                         texrow += ft_texrow;
2115
2116                         // The extra .c_str() is needed when we use
2117                         // lyxstring instead of the STL string class.
2118                         ftnote.str(string().c_str());
2119                         ft_texrow.reset();
2120                         ftcount = 0;
2121                 }
2122         }
2123         // It might be that we only have a title in this document
2124         if (was_title && !already_title) {
2125                 ofs << "\\maketitle\n";
2126                 texrow.newline();
2127         }
2128 }
2129
2130
2131 bool Buffer::isLatex() const
2132 {
2133         return textclasslist.TextClass(params.textclass).outputType() == LATEX;
2134 }
2135
2136
2137 bool Buffer::isLinuxDoc() const
2138 {
2139         return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC;
2140 }
2141
2142
2143 bool Buffer::isLiterate() const
2144 {
2145         return textclasslist.TextClass(params.textclass).outputType() == LITERATE;
2146 }
2147
2148
2149 bool Buffer::isDocBook() const
2150 {
2151         return textclasslist.TextClass(params.textclass).outputType() == DOCBOOK;
2152 }
2153
2154
2155 bool Buffer::isSGML() const
2156 {
2157         return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC ||
2158                textclasslist.TextClass(params.textclass).outputType() == DOCBOOK;
2159 }
2160
2161
2162 void Buffer::sgmlOpenTag(ostream & os, int depth,
2163                          string const & latexname) const
2164 {
2165         if (latexname != "!-- --")
2166                 os << string(depth, ' ') << "<" << latexname << ">\n";
2167 }
2168
2169
2170 void Buffer::sgmlCloseTag(ostream & os, int depth,
2171                           string const & latexname) const
2172 {
2173         if (latexname != "!-- --")
2174                 os << string(depth, ' ') << "</" << latexname << ">\n";
2175 }
2176
2177
2178 void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
2179 {
2180         LyXParagraph * par = paragraph;
2181
2182         niceFile = nice; // this will be used by Insetincludes.
2183
2184         string top_element = textclasslist.LatexnameOfClass(params.textclass);
2185         string environment_stack[10];
2186         string item_name;
2187
2188         int depth = 0; // paragraph depth
2189
2190         ofstream ofs(fname.c_str());
2191
2192         if (!ofs) {
2193                 WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname);
2194                 return;
2195         }
2196
2197         LyXTextClass const & tclass =
2198                 textclasslist.TextClass(params.textclass);
2199
2200         LaTeXFeatures features(params, tclass.numLayouts());
2201         validate(features);
2202
2203         //if (nice)
2204         tex_code_break_column = lyxrc.ascii_linelen;
2205         //else
2206         //tex_code_break_column = 0;
2207
2208         texrow.reset();
2209
2210         if (!body_only) {
2211                 string sgml_includedfiles=features.getIncludedFiles(fname);
2212
2213                 if (params.preamble.empty() && sgml_includedfiles.empty()) {
2214                         ofs << "<!doctype linuxdoc system>\n\n";
2215                 } else {
2216                         ofs << "<!doctype linuxdoc system [ "
2217                             << params.preamble << sgml_includedfiles << " \n]>\n\n";
2218                 }
2219
2220                 if (params.options.empty())
2221                         sgmlOpenTag(ofs, 0, top_element);
2222                 else {
2223                         string top = top_element;
2224                         top += " ";
2225                         top += params.options;
2226                         sgmlOpenTag(ofs, 0, top);
2227                 }
2228         }
2229
2230         ofs << "<!-- "  << LYX_DOCVERSION
2231             << " created this file. For more info see http://www.lyx.org/"
2232             << " -->\n";
2233
2234         while (par) {
2235                 int desc_on = 0; // description mode
2236                 LyXLayout const & style =
2237                         textclasslist.Style(params.textclass,
2238                                             par->layout);
2239
2240                 // treat <toc> as a special case for compatibility with old code
2241                 if (par->GetChar(0) == LyXParagraph::META_INSET) {
2242                         Inset * inset = par->GetInset(0);
2243                         Inset::Code lyx_code = inset->LyxCode();
2244                         if (lyx_code == Inset::TOC_CODE){
2245                                 string const temp = "toc";
2246                                 sgmlOpenTag(ofs, depth, temp);
2247
2248                                 par = par->next;
2249 #ifndef NEW_INSETS
2250                                 linuxDocHandleFootnote(ofs, par, depth);
2251 #endif
2252                                 continue;
2253                         }
2254                 }
2255
2256                 // environment tag closing
2257                 for (; depth > par->depth; --depth) {
2258                         sgmlCloseTag(ofs, depth, environment_stack[depth]);
2259                         environment_stack[depth].erase();
2260                 }
2261
2262                 // write opening SGML tags
2263                 switch (style.latextype) {
2264                 case LATEX_PARAGRAPH:
2265                         if (depth == par->depth
2266                            && !environment_stack[depth].empty()) {
2267                                 sgmlCloseTag(ofs, depth, environment_stack[depth]);
2268                                 environment_stack[depth].erase();
2269                                 if (depth)
2270                                         --depth;
2271                                 else
2272                                         ofs << "</p>";
2273                         }
2274                         sgmlOpenTag(ofs, depth, style.latexname());
2275                         break;
2276
2277                 case LATEX_COMMAND:
2278                         if (depth!= 0)
2279                                 LinuxDocError(par, 0,
2280                                               _("Error : Wrong depth for"
2281                                                 " LatexType Command.\n"));
2282
2283                         if (!environment_stack[depth].empty()){
2284                                 sgmlCloseTag(ofs, depth,
2285                                              environment_stack[depth]);
2286                                 ofs << "</p>";
2287                         }
2288
2289                         environment_stack[depth].erase();
2290                         sgmlOpenTag(ofs, depth, style.latexname());
2291                         break;
2292
2293                 case LATEX_ENVIRONMENT:
2294                 case LATEX_ITEM_ENVIRONMENT:
2295                         if (depth == par->depth
2296                            && environment_stack[depth] != style.latexname()
2297                            && !environment_stack[depth].empty()) {
2298
2299                                 sgmlCloseTag(ofs, depth,
2300                                              environment_stack[depth]);
2301                                 environment_stack[depth].erase();
2302                         }
2303                         if (depth < par->depth) {
2304                                depth = par->depth;
2305                                environment_stack[depth].erase();
2306                         }
2307                         if (environment_stack[depth] != style.latexname()) {
2308                                 if (depth == 0) {
2309                                         string const temp = "p";
2310                                         sgmlOpenTag(ofs, depth, temp);
2311                                 }
2312                                 environment_stack[depth] = style.latexname();
2313                                 sgmlOpenTag(ofs, depth,
2314                                             environment_stack[depth]);
2315                         }
2316                         if (style.latextype == LATEX_ENVIRONMENT) break;
2317
2318                         desc_on = (style.labeltype == LABEL_MANUAL);
2319
2320                         if (desc_on)
2321                                 item_name = "tag";
2322                         else
2323                                 item_name = "item";
2324
2325                         sgmlOpenTag(ofs, depth + 1, item_name);
2326                         break;
2327                 default:
2328                         sgmlOpenTag(ofs, depth, style.latexname());
2329                         break;
2330                 }
2331
2332 #ifndef NEW_INSETS
2333                 do {
2334 #endif
2335                         SimpleLinuxDocOnePar(ofs, par, desc_on, depth);
2336
2337                         par = par->next;
2338 #ifndef NEW_INSETS
2339                         linuxDocHandleFootnote(ofs, par, depth);
2340                 }
2341                 while(par && par->IsDummy());
2342 #endif
2343
2344                 ofs << "\n";
2345                 // write closing SGML tags
2346                 switch (style.latextype) {
2347                 case LATEX_COMMAND:
2348                 case LATEX_ENVIRONMENT:
2349                 case LATEX_ITEM_ENVIRONMENT:
2350                         break;
2351                 default:
2352                         sgmlCloseTag(ofs, depth, style.latexname());
2353                         break;
2354                 }
2355         }
2356
2357         // Close open tags
2358         for (; depth > 0; --depth)
2359                 sgmlCloseTag(ofs, depth, environment_stack[depth]);
2360
2361         if (!environment_stack[depth].empty())
2362                 sgmlCloseTag(ofs, depth, environment_stack[depth]);
2363
2364         if (!body_only) {
2365                 ofs << "\n\n";
2366                 sgmlCloseTag(ofs, 0, top_element);
2367         }
2368
2369         ofs.close();
2370         // How to check for successful close
2371 }
2372
2373
2374 #ifndef NEW_INSETS
2375 void Buffer::linuxDocHandleFootnote(ostream & os, LyXParagraph * & par,
2376                                     int depth)
2377 {
2378         string const tag = "footnote";
2379
2380         while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
2381                 sgmlOpenTag(os, depth + 1, tag);
2382                 SimpleLinuxDocOnePar(os, par, 0, depth + 1);
2383                 sgmlCloseTag(os, depth + 1, tag);
2384                 par = par->next;
2385         }
2386 }
2387 #endif
2388
2389
2390 void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag,
2391                                   int depth, int desc_on,
2392                                   LyXParagraph * & par)
2393 {
2394         LyXParagraph * tpar = par;
2395         while (tpar
2396 #ifndef NEW_INSETS
2397                && (tpar->footnoteflag != LyXParagraph::NO_FOOTNOTE)
2398 #endif
2399                && (tpar->layout != textclasslist.NumberOfLayout(params.textclass,
2400                                                              "Caption").second))
2401                 tpar = tpar->next;
2402         if (tpar &&
2403             tpar->layout == textclasslist.NumberOfLayout(params.textclass,
2404                                                          "Caption").second) {
2405                 sgmlOpenTag(os, depth + 1, inner_tag);
2406                 string extra_par;
2407                 SimpleDocBookOnePar(os, extra_par, tpar,
2408                                     desc_on, depth + 2);
2409                 sgmlCloseTag(os, depth+1, inner_tag);
2410                 if (!extra_par.empty())
2411                         os << extra_par;
2412         }
2413 }
2414
2415
2416 #ifndef NEW_INSETS
2417 void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par,
2418                                    int depth)
2419 {
2420         string tag, inner_tag;
2421         string tmp_par, extra_par;
2422         bool inner_span = false;
2423         int desc_on = 4;
2424
2425         // Someone should give this enum a proper name (Lgb)
2426         enum SOME_ENUM {
2427                 NO_ONE,
2428                 FOOTNOTE_LIKE,
2429                 MARGIN_LIKE,
2430                 FIG_LIKE,
2431                 TAB_LIKE
2432         };
2433         SOME_ENUM last = NO_ONE;
2434         SOME_ENUM present = FOOTNOTE_LIKE;
2435
2436         while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
2437                 if (last == present) {
2438                         if (inner_span) {
2439                                 if (!tmp_par.empty()) {
2440                                         os << tmp_par;
2441                                         tmp_par.erase();
2442                                         sgmlCloseTag(os, depth + 1, inner_tag);
2443                                         sgmlOpenTag(os, depth + 1, inner_tag);
2444                                 }
2445                         } else {
2446                                 os << "\n";
2447                         }
2448                 } else {
2449                         os << tmp_par;
2450                         if (!inner_tag.empty()) sgmlCloseTag(os, depth + 1,
2451                                                             inner_tag);
2452                         if (!extra_par.empty()) os << extra_par;
2453                         if (!tag.empty()) sgmlCloseTag(os, depth, tag);
2454                         extra_par.erase();
2455
2456                         switch (par->footnotekind) {
2457                         case LyXParagraph::FOOTNOTE:
2458                         case LyXParagraph::ALGORITHM:
2459                                 tag = "footnote";
2460                                 inner_tag = "para";
2461                                 present = FOOTNOTE_LIKE;
2462                                 inner_span = true;
2463                                 break;
2464                         case LyXParagraph::MARGIN:
2465                                 tag = "sidebar";
2466                                 inner_tag = "para";
2467                                 present = MARGIN_LIKE;
2468                                 inner_span = true;
2469                                 break;
2470                         case LyXParagraph::FIG:
2471                         case LyXParagraph::WIDE_FIG:
2472                                 tag = "figure";
2473                                 inner_tag = "title";
2474                                 present = FIG_LIKE;
2475                                 inner_span = false;
2476                                 break;
2477                         case LyXParagraph::TAB:
2478                         case LyXParagraph::WIDE_TAB:
2479                                 tag = "table";
2480                                 inner_tag = "title";
2481                                 present = TAB_LIKE;
2482                                 inner_span = false;
2483                                 break;
2484                         }
2485                         sgmlOpenTag(os, depth, tag);
2486                         if ((present == TAB_LIKE) || (present == FIG_LIKE)) {
2487                                 DocBookHandleCaption(os, inner_tag, depth,
2488                                                      desc_on, par);
2489                                 inner_tag.erase();
2490                         } else {
2491                                 sgmlOpenTag(os, depth + 1, inner_tag);
2492                         }
2493                 }
2494                 // ignore all caption here, we processed them above!!!
2495                 if (par->layout != textclasslist
2496                     .NumberOfLayout(params.textclass,
2497                                     "Caption").second) {
2498                         std::ostringstream ost;
2499                         SimpleDocBookOnePar(ost, extra_par, par,
2500                                             desc_on, depth + 2);
2501                         tmp_par += ost.str().c_str();
2502                 }
2503                 tmp_par = frontStrip(strip(tmp_par));
2504
2505                 last = present;
2506                 par = par->next;
2507         }
2508         os << tmp_par;
2509         if (!inner_tag.empty()) sgmlCloseTag(os, depth + 1, inner_tag);
2510         if (!extra_par.empty()) os << extra_par;
2511         if (!tag.empty()) sgmlCloseTag(os, depth, tag);
2512 }
2513 #endif
2514
2515
2516 // push a tag in a style stack
2517 void Buffer::push_tag(ostream & os, string const & tag,
2518                       int & pos, char stack[5][3])
2519 {
2520 #ifdef WITH_WARNINGS
2521 #warning Use a real stack! (Lgb)
2522 #endif
2523         // pop all previous tags
2524         for (int j = pos; j >= 0; --j)
2525                 os << "</" << stack[j] << ">";
2526
2527         // add new tag
2528         sprintf(stack[++pos], "%s", tag.c_str());
2529
2530         // push all tags
2531         for (int i = 0; i <= pos; ++i)
2532                 os << "<" << stack[i] << ">";
2533 }
2534
2535
2536 void Buffer::pop_tag(ostream & os, string const & tag,
2537                      int & pos, char stack[5][3])
2538 {
2539 #ifdef WITH_WARNINGS
2540 #warning Use a real stack! (Lgb)
2541 #endif
2542         // Please, Lars, do not remove the global variable. I already
2543         // had to reintroduce it twice! (JMarc)
2544         // but...but... I'll remove it anyway. (well not quite) (Lgb)
2545 #if 0
2546         int j;
2547
2548         // pop all tags till specified one
2549         for (j = pos; (j >= 0) && tag != stack[j]; --j)
2550                 os << "</" << stack[j] << ">";
2551
2552         // closes the tag
2553         os << "</" << tag << ">";
2554
2555         // push all tags, but the specified one
2556         for (j = j + 1; j <= pos; ++j) {
2557                 os << "<" << stack[j] << ">";
2558                 strcpy(stack[j - 1], stack[j]);
2559         }
2560         --pos;
2561 #else
2562         // pop all tags till specified one
2563         int j = pos;
2564         for (int j = pos; (j >= 0) && tag != stack[j]; --j)
2565                 os << "</" << stack[j] << ">";
2566
2567         // closes the tag
2568         os << "</" << tag << ">";
2569
2570         // push all tags, but the specified one
2571         for (int i = j + 1; i <= pos; ++i) {
2572                 os << "<" << stack[i] << ">";
2573                 strcpy(stack[i - 1], stack[i]);
2574         }
2575         --pos;
2576 #endif
2577 }
2578
2579
2580 // Handle internal paragraph parsing -- layout already processed.
2581
2582 // checks, if newcol chars should be put into this line
2583 // writes newline, if necessary.
2584 static
2585 void linux_doc_line_break(ostream & os, string::size_type & colcount,
2586                           string::size_type newcol)
2587 {
2588         colcount += newcol;
2589         if (colcount > lyxrc.ascii_linelen) {
2590                 os << "\n";
2591                 colcount = newcol; // assume write after this call
2592         }
2593 }
2594
2595
2596 void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
2597                                   int desc_on, int /*depth*/)
2598 {
2599         LyXFont font1;
2600         char c;
2601         Inset * inset;
2602         LyXParagraph::size_type main_body;
2603         int j;
2604         LyXLayout const & style = textclasslist.Style(params.textclass,
2605                                                       par->GetLayout());
2606
2607         char family_type = 0;               // family font flag
2608         bool is_bold     = false;           // series font flag
2609         char shape_type  = 0;               // shape font flag
2610         bool is_em = false;                 // emphasis (italic) font flag
2611
2612         int stack_num = -1;          // style stack position
2613         // Can this be rewritten to use a std::stack, please. (Lgb)
2614         char stack[5][3];            // style stack
2615         string::size_type char_line_count = 5;     // Heuristic choice ;-)
2616
2617         if (style.labeltype != LABEL_MANUAL)
2618                 main_body = 0;
2619         else
2620                 main_body = par->BeginningOfMainBody();
2621
2622         // gets paragraph main font
2623         if (main_body > 0)
2624                 font1 = style.labelfont;
2625         else
2626                 font1 = style.font;
2627
2628
2629         // parsing main loop
2630         for (LyXParagraph::size_type i = 0;
2631              i < par->size(); ++i) {
2632
2633                 // handle quote tag
2634                 if (i == main_body
2635 #ifndef NEW_INSETS
2636                     && !par->IsDummy()
2637 #endif
2638                         ) {
2639                         if (main_body > 0)
2640                                 font1 = style.font;
2641                 }
2642
2643                 LyXFont const font2 = par->getFont(params, i);
2644
2645                 if (font1.family() != font2.family()) {
2646                         switch (family_type) {
2647                         case 0:
2648                                 if (font2.family() == LyXFont::TYPEWRITER_FAMILY) {
2649                                         push_tag(os, "tt", stack_num, stack);
2650                                         family_type = 1;
2651                                 }
2652                                 else if (font2.family() == LyXFont::SANS_FAMILY) {
2653                                         push_tag(os, "sf", stack_num, stack);
2654                                         family_type = 2;
2655                                 }
2656                                 break;
2657                         case 1:
2658                                 pop_tag(os, "tt", stack_num, stack);
2659                                 if (font2.family() == LyXFont::SANS_FAMILY) {
2660                                         push_tag(os, "sf", stack_num, stack);
2661                                         family_type = 2;
2662                                 } else {
2663                                         family_type = 0;
2664                                 }
2665                                 break;
2666                         case 2:
2667                                 pop_tag(os, "sf", stack_num, stack);
2668                                 if (font2.family() == LyXFont::TYPEWRITER_FAMILY) {
2669                                         push_tag(os, "tt", stack_num, stack);
2670                                         family_type = 1;
2671                                 } else {
2672                                         family_type = 0;
2673                                 }
2674                         }
2675                 }
2676
2677                 // handle bold face
2678                 if (font1.series() != font2.series()) {
2679                         if (font2.series() == LyXFont::BOLD_SERIES) {
2680                                 push_tag(os, "bf", stack_num, stack);
2681                                 is_bold = true;
2682                         } else if (is_bold) {
2683                                 pop_tag(os, "bf", stack_num, stack);
2684                                 is_bold = false;
2685                         }
2686                 }
2687
2688                 // handle italic and slanted fonts
2689                 if (font1.shape() != font2.shape()) {
2690                         switch (shape_type) {
2691                         case 0:
2692                                 if (font2.shape() == LyXFont::ITALIC_SHAPE) {
2693                                         push_tag(os, "it", stack_num, stack);
2694                                         shape_type = 1;
2695                                 } else if (font2.shape() == LyXFont::SLANTED_SHAPE) {
2696                                         push_tag(os, "sl", stack_num, stack);
2697                                         shape_type = 2;
2698                                 }
2699                                 break;
2700                         case 1:
2701                                 pop_tag(os, "it", stack_num, stack);
2702                                 if (font2.shape() == LyXFont::SLANTED_SHAPE) {
2703                                         push_tag(os, "sl", stack_num, stack);
2704                                         shape_type = 2;
2705                                 } else {
2706                                         shape_type = 0;
2707                                 }
2708                                 break;
2709                         case 2:
2710                                 pop_tag(os, "sl", stack_num, stack);
2711                                 if (font2.shape() == LyXFont::ITALIC_SHAPE) {
2712                                         push_tag(os, "it", stack_num, stack);
2713                                         shape_type = 1;
2714                                 } else {
2715                                         shape_type = 0;
2716                                 }
2717                         }
2718                 }
2719                 // handle <em> tag
2720                 if (font1.emph() != font2.emph()) {
2721                         if (font2.emph() == LyXFont::ON) {
2722                                 push_tag(os, "em", stack_num, stack);
2723                                 is_em = true;
2724                         } else if (is_em) {
2725                                 pop_tag(os, "em", stack_num, stack);
2726                                 is_em = false;
2727                         }
2728                 }
2729
2730                 c = par->GetChar(i);
2731
2732                 if (c == LyXParagraph::META_INSET) {
2733                         inset = par->GetInset(i);
2734                         inset->Linuxdoc(this, os);
2735                 }
2736
2737                 if (font2.latex() == LyXFont::ON) {
2738                         // "TeX"-Mode on == > SGML-Mode on.
2739                         if (c != '\0')
2740                                 os << c; // see LaTeX-Generation...
2741                         ++char_line_count;
2742                 } else {
2743                         string sgml_string;
2744                         if (par->linuxDocConvertChar(c, sgml_string)
2745                             && !style.free_spacing) { // in freespacing
2746                                                      // mode, spaces are
2747                                                      // non-breaking characters
2748                                 // char is ' '
2749                                 if (desc_on == 1) {
2750                                         ++char_line_count;
2751                                         linux_doc_line_break(os, char_line_count, 6);
2752                                         os << "</tag>";
2753                                         desc_on = 2;
2754                                 } else  {
2755                                         linux_doc_line_break(os, char_line_count, 1);
2756                                         os << c;
2757                                 }
2758                         } else {
2759                                 os << sgml_string;
2760                                 char_line_count += sgml_string.length();
2761                         }
2762                 }
2763                 font1 = font2;
2764         }
2765
2766         // needed if there is an optional argument but no contents
2767         if (main_body > 0 && main_body == par->size()) {
2768                 font1 = style.font;
2769         }
2770
2771         // pop all defined Styles
2772         for (j = stack_num; j >= 0; --j) {
2773                 linux_doc_line_break(os,
2774                                      char_line_count,
2775                                      3 + strlen(stack[j]));
2776                 os << "</" << stack[j] << ">";
2777         }
2778
2779         // resets description flag correctly
2780         switch (desc_on){
2781         case 1:
2782                 // <tag> not closed...
2783                 linux_doc_line_break(os, char_line_count, 6);
2784                 os << "</tag>";
2785                 break;
2786         case 2:
2787                 // fprintf(file, "</p>");
2788                 break;
2789         }
2790 }
2791
2792
2793 // Print an error message.
2794 void Buffer::LinuxDocError(LyXParagraph * par, int pos,
2795                            string const & message)
2796 {
2797         // insert an error marker in text
2798         InsetError * new_inset = new InsetError(message);
2799         par->InsertInset(pos, new_inset);
2800 }
2801
2802 // This constant defines the maximum number of
2803 // environment layouts that can be nesteded.
2804 // The same applies for command layouts.
2805 // These values should be more than enough.
2806 //           José Matos (1999/07/22)
2807
2808 enum { MAX_NEST_LEVEL = 25};
2809
2810 void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
2811 {
2812         LyXParagraph * par = paragraph;
2813
2814         niceFile = nice; // this will be used by Insetincludes.
2815
2816         string top_element= textclasslist.LatexnameOfClass(params.textclass);
2817         // Please use a real stack.
2818         string environment_stack[MAX_NEST_LEVEL];
2819         string environment_inner[MAX_NEST_LEVEL];
2820         // Please use a real stack.
2821         string command_stack[MAX_NEST_LEVEL];
2822         bool command_flag= false;
2823         int command_depth= 0, command_base= 0, cmd_depth= 0;
2824
2825         string item_name, command_name;
2826         string c_depth, c_params, tmps;
2827
2828         int depth = 0; // paragraph depth
2829         LyXTextClass const & tclass =
2830                 textclasslist.TextClass(params.textclass);
2831
2832         LaTeXFeatures features(params, tclass.numLayouts());
2833         validate(features);
2834
2835         //if (nice)
2836         tex_code_break_column = lyxrc.ascii_linelen;
2837         //else
2838         //tex_code_break_column = 0;
2839
2840         ofstream ofs(fname.c_str());
2841         if (!ofs) {
2842                 WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname);
2843                 return;
2844         }
2845
2846         texrow.reset();
2847
2848         if (!only_body) {
2849                 string sgml_includedfiles=features.getIncludedFiles(fname);
2850
2851                 ofs << "<!doctype " << top_element
2852                     << " public \"-//OASIS//DTD DocBook V3.1//EN\"";
2853
2854                 if (params.preamble.empty() && sgml_includedfiles.empty())
2855                         ofs << ">\n\n";
2856                 else
2857                         ofs << "\n [ " << params.preamble
2858                             << sgml_includedfiles << " \n]>\n\n";
2859         }
2860
2861         string top = top_element;
2862         top += " lang=\"";
2863         top += params.language->code();
2864         top += "\"";
2865
2866         if (!params.options.empty()) {
2867                 top += " ";
2868                 top += params.options;
2869         }
2870         sgmlOpenTag(ofs, 0, top);
2871
2872         ofs << "<!-- DocBook file was created by " << LYX_DOCVERSION
2873             << "\n  See http://www.lyx.org/ for more information -->\n";
2874
2875         while (par) {
2876                 int desc_on = 0; // description mode
2877                 LyXLayout const & style =
2878                         textclasslist.Style(params.textclass,
2879                                             par->layout);
2880
2881                 // environment tag closing
2882                 for (; depth > par->depth; --depth) {
2883                         if (environment_inner[depth] != "!-- --") {
2884                                 item_name= "listitem";
2885                                 sgmlCloseTag(ofs, command_depth + depth,
2886                                              item_name);
2887                                 if (environment_inner[depth] == "varlistentry")
2888                                         sgmlCloseTag(ofs, depth+command_depth,
2889                                                      environment_inner[depth]);
2890                         }
2891                         sgmlCloseTag(ofs, depth + command_depth,
2892                                      environment_stack[depth]);
2893                         environment_stack[depth].erase();
2894                         environment_inner[depth].erase();
2895                 }
2896
2897                 if (depth == par->depth
2898                    && environment_stack[depth] != style.latexname()
2899                    && !environment_stack[depth].empty()) {
2900                         if (environment_inner[depth] != "!-- --") {
2901                                 item_name= "listitem";
2902                                 sgmlCloseTag(ofs, command_depth+depth,
2903                                              item_name);
2904                                 if (environment_inner[depth] == "varlistentry")
2905                                         sgmlCloseTag(ofs,
2906                                                      depth + command_depth,
2907                                                      environment_inner[depth]);
2908                         }
2909
2910                         sgmlCloseTag(ofs, depth + command_depth,
2911                                      environment_stack[depth]);
2912
2913                         environment_stack[depth].erase();
2914                         environment_inner[depth].erase();
2915                 }
2916
2917                 // Write opening SGML tags.
2918                 switch (style.latextype) {
2919                 case LATEX_PARAGRAPH:
2920                         sgmlOpenTag(ofs, depth+command_depth, style.latexname());
2921                         break;
2922
2923                 case LATEX_COMMAND:
2924                         if (depth!= 0)
2925                                 LinuxDocError(par, 0,
2926                                               _("Error : Wrong depth for "
2927                                                 "LatexType Command.\n"));
2928
2929                         command_name = style.latexname();
2930
2931                         tmps = style.latexparam();
2932                         c_params = split(tmps, c_depth,'|');
2933
2934                         cmd_depth= lyx::atoi(c_depth);
2935
2936                         if (command_flag) {
2937                                 if (cmd_depth<command_base) {
2938                                         for (int j = command_depth;
2939                                             j >= command_base; --j)
2940                                                 if (!command_stack[j].empty())
2941                                                         sgmlCloseTag(ofs, j, command_stack[j]);
2942                                         command_depth= command_base= cmd_depth;
2943                                 } else if (cmd_depth <= command_depth) {
2944                                         for (int j = command_depth;
2945                                             j >= cmd_depth; --j)
2946
2947                                                 if (!command_stack[j].empty())
2948                                                         sgmlCloseTag(ofs, j, command_stack[j]);
2949                                         command_depth= cmd_depth;
2950                                 } else
2951                                         command_depth= cmd_depth;
2952                         } else {
2953                                 command_depth = command_base = cmd_depth;
2954                                 command_flag = true;
2955                         }
2956                         command_stack[command_depth]= command_name;
2957
2958                         // treat label as a special case for
2959                         // more WYSIWYM handling.
2960                         if (par->GetChar(0) == LyXParagraph::META_INSET) {
2961                                 Inset * inset = par->GetInset(0);
2962                                 Inset::Code lyx_code = inset->LyxCode();
2963                                 if (lyx_code == Inset::LABEL_CODE){
2964                                         command_name += " id=\"";
2965                                         command_name += (static_cast<InsetCommand *>(inset))->getContents();
2966                                         command_name += "\"";
2967                                         desc_on = 3;
2968                                 }
2969                         }
2970
2971                         sgmlOpenTag(ofs, depth + command_depth, command_name);
2972                         if (c_params.empty())
2973                                 item_name = "title";
2974                         else
2975                                 item_name = c_params;
2976                         sgmlOpenTag(ofs, depth + 1 + command_depth, item_name);
2977                         break;
2978
2979                 case LATEX_ENVIRONMENT:
2980                 case LATEX_ITEM_ENVIRONMENT:
2981                         if (depth < par->depth) {
2982                                 depth = par->depth;
2983                                 environment_stack[depth].erase();
2984                         }
2985
2986                         if (environment_stack[depth] != style.latexname()) {
2987                                 environment_stack[depth] = style.latexname();
2988                                 environment_inner[depth] = "!-- --";
2989                                 sgmlOpenTag(ofs, depth + command_depth,
2990                                             environment_stack[depth]);
2991                         } else {
2992                                 if (environment_inner[depth] != "!-- --") {
2993                                         item_name= "listitem";
2994                                         sgmlCloseTag(ofs,
2995                                                      command_depth + depth,
2996                                                      item_name);
2997                                         if (environment_inner[depth] == "varlistentry")
2998                                                 sgmlCloseTag(ofs,
2999                                                              depth + command_depth,
3000                                                              environment_inner[depth]);
3001                                 }
3002                         }
3003
3004                         if (style.latextype == LATEX_ENVIRONMENT) {
3005                                 if (!style.latexparam().empty()) {
3006                                         if(style.latexparam() == "CDATA")
3007                                                 ofs << "<![ CDATA [";
3008                                         else
3009                                                 sgmlOpenTag(ofs, depth + command_depth,
3010                                                             style.latexparam());
3011                                 }
3012                                 break;
3013                         }
3014
3015                         desc_on = (style.labeltype == LABEL_MANUAL);
3016
3017                         if (desc_on)
3018                                 environment_inner[depth]= "varlistentry";
3019                         else
3020                                 environment_inner[depth]= "listitem";
3021
3022                         sgmlOpenTag(ofs, depth + 1 + command_depth,
3023                                     environment_inner[depth]);
3024
3025                         if (desc_on) {
3026                                 item_name= "term";
3027                                 sgmlOpenTag(ofs, depth + 1 + command_depth,
3028                                             item_name);
3029                         } else {
3030                                 item_name= "para";
3031                                 sgmlOpenTag(ofs, depth + 1 + command_depth,
3032                                             item_name);
3033                         }
3034                         break;
3035                 default:
3036                         sgmlOpenTag(ofs, depth + command_depth,
3037                                     style.latexname());
3038                         break;
3039                 }
3040
3041 #ifndef NEW_INSETS
3042                 do {
3043 #endif
3044                         string extra_par;
3045                         SimpleDocBookOnePar(ofs, extra_par, par, desc_on,
3046                                             depth + 1 + command_depth);
3047                         par = par->next;
3048 #ifndef NEW_INSETS
3049                         DocBookHandleFootnote(ofs, par,
3050                                               depth + 1 + command_depth);
3051                 }
3052                 while(par && par->IsDummy());
3053 #endif
3054                 string end_tag;
3055                 // write closing SGML tags
3056                 switch (style.latextype) {
3057                 case LATEX_COMMAND:
3058                         if (c_params.empty())
3059                                 end_tag = "title";
3060                         else
3061                                 end_tag = c_params;
3062                         sgmlCloseTag(ofs, depth + command_depth, end_tag);
3063                         break;
3064                 case LATEX_ENVIRONMENT:
3065                         if (!style.latexparam().empty()) {
3066                                 if(style.latexparam() == "CDATA")
3067                                         ofs << "]]>";
3068                                 else
3069                                         sgmlCloseTag(ofs, depth + command_depth,
3070                                                      style.latexparam());
3071                         }
3072                         break;
3073                 case LATEX_ITEM_ENVIRONMENT:
3074                         if (desc_on == 1) break;
3075                         end_tag= "para";
3076                         sgmlCloseTag(ofs, depth + 1 + command_depth, end_tag);
3077                         break;
3078                 case LATEX_PARAGRAPH:
3079                         sgmlCloseTag(ofs, depth + command_depth, style.latexname());
3080                         break;
3081                 default:
3082                         sgmlCloseTag(ofs, depth + command_depth, style.latexname());
3083                         break;
3084                 }
3085         }
3086
3087         // Close open tags
3088         for (; depth >= 0; --depth) {
3089                 if (!environment_stack[depth].empty()) {
3090                         if (environment_inner[depth] != "!-- --") {
3091                                 item_name= "listitem";
3092                                 sgmlCloseTag(ofs, command_depth + depth,
3093                                              item_name);
3094                                if (environment_inner[depth] == "varlistentry")
3095                                        sgmlCloseTag(ofs, depth + command_depth,
3096                                                     environment_inner[depth]);
3097                         }
3098
3099                         sgmlCloseTag(ofs, depth + command_depth,
3100                                      environment_stack[depth]);
3101                 }
3102         }
3103
3104         for (int j = command_depth; j >= command_base; --j)
3105                 if (!command_stack[j].empty())
3106                         sgmlCloseTag(ofs, j, command_stack[j]);
3107
3108         ofs << "\n\n";
3109         sgmlCloseTag(ofs, 0, top_element);
3110
3111         ofs.close();
3112         // How to check for successful close
3113 }
3114
3115
3116 void Buffer::SimpleDocBookOnePar(ostream & os, string & extra,
3117                                  LyXParagraph * par, int & desc_on,
3118                                  int depth) const
3119 {
3120         bool emph_flag = false;
3121
3122         LyXLayout const & style = textclasslist.Style(params.textclass,
3123                                                       par->GetLayout());
3124
3125         LyXParagraph::size_type main_body;
3126         if (style.labeltype != LABEL_MANUAL)
3127                 main_body = 0;
3128         else
3129                 main_body = par->BeginningOfMainBody();
3130
3131         // gets paragraph main font
3132         LyXFont font1 = main_body > 0 ? style.labelfont : style.font;
3133
3134         int char_line_count = depth;
3135         if (!style.free_spacing)
3136                 for (int j = 0; j < depth; ++j)
3137                         os << ' ';
3138
3139         // parsing main loop
3140         for (LyXParagraph::size_type i = 0;
3141              i < par->size(); ++i) {
3142                 LyXFont font2 = par->getFont(params, i);
3143
3144                 // handle <emphasis> tag
3145                 if (font1.emph() != font2.emph() && i) {
3146                         if (font2.emph() == LyXFont::ON) {
3147                                 os << "<emphasis>";
3148                                 emph_flag = true;
3149                         }else {
3150                                 os << "</emphasis>";
3151                                 emph_flag = false;
3152                         }
3153                 }
3154
3155                 char c = par->GetChar(i);
3156
3157                 if (c == LyXParagraph::META_INSET) {
3158                         Inset * inset = par->GetInset(i);
3159                         std::ostringstream ost;
3160                         inset->DocBook(this, ost);
3161                         string tmp_out = ost.str().c_str();
3162
3163                         //
3164                         // This code needs some explanation:
3165                         // Two insets are treated specially
3166                         //   label if it is the first element in a command paragraph
3167                         //         desc_on == 3
3168                         //   graphics inside tables or figure floats can't go on
3169                         //   title (the equivalente in latex for this case is caption
3170                         //   and title should come first
3171                         //         desc_on == 4
3172                         //
3173                         if (desc_on!= 3 || i!= 0) {
3174                                 if (!tmp_out.empty() && tmp_out[0] == '@') {
3175                                         if (desc_on == 4)
3176                                                 extra += frontStrip(tmp_out, '@');
3177                                         else
3178                                                 os << frontStrip(tmp_out, '@');
3179                                 }
3180                                 else
3181                                         os << tmp_out;
3182                         }
3183                 } else if (font2.latex() == LyXFont::ON) {
3184                         // "TeX"-Mode on ==> SGML-Mode on.
3185                         if (c != '\0')
3186                                 os << c;
3187                         ++char_line_count;
3188                 } else {
3189                         string sgml_string;
3190                         if (par->linuxDocConvertChar(c, sgml_string)
3191                             && !style.free_spacing) { // in freespacing
3192                                                      // mode, spaces are
3193                                                      // non-breaking characters
3194                                 // char is ' '
3195                                 if (desc_on == 1) {
3196                                         ++char_line_count;
3197                                         os << "\n</term><listitem><para>";
3198                                         desc_on = 2;
3199                                 } else {
3200                                         os << c;
3201                                 }
3202                         } else {
3203                                 os << sgml_string;
3204                         }
3205                 }
3206                 font1 = font2;
3207         }
3208
3209         // needed if there is an optional argument but no contents
3210         if (main_body > 0 && main_body == par->size()) {
3211                 font1 = style.font;
3212         }
3213         if (emph_flag) {
3214                 os << "</emphasis>";
3215         }
3216
3217         // resets description flag correctly
3218         switch (desc_on){
3219         case 1:
3220                 // <term> not closed...
3221                 os << "</term>";
3222                 break;
3223         }
3224         os << '\n';
3225 }
3226
3227
3228 // This should be enabled when the Chktex class is implemented. (Asger)
3229 // chktex should be run with these flags disabled: 3, 22, 25, 30, 38(?)
3230 // Other flags: -wall -v0 -x
3231 int Buffer::runChktex()
3232 {
3233         if (!users->text) return 0;
3234
3235         ProhibitInput(users);
3236
3237         // get LaTeX-Filename
3238         string const name = getLatexName();
3239         string path = OnlyPath(filename);
3240
3241         string const org_path = path;
3242         if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) {
3243                 path = tmppath;
3244         }
3245
3246         Path p(path); // path to LaTeX file
3247         users->owner()->getMiniBuffer()->Set(_("Running chktex..."));
3248
3249         // Remove all error insets
3250         bool const removedErrorInsets = users->removeAutoInsets();
3251
3252         // Generate the LaTeX file if neccessary
3253         makeLaTeXFile(name, org_path, false);
3254
3255         TeXErrors terr;
3256         Chktex chktex(lyxrc.chktex_command, name, filepath);
3257         int res = chktex.run(terr); // run chktex
3258
3259         if (res == -1) {
3260                 WriteAlert(_("chktex did not work!"),
3261                            _("Could not run with file:"), name);
3262         } else if (res > 0) {
3263                 // Insert all errors as errors boxes
3264                 users->insertErrors(terr);
3265         }
3266
3267         // if we removed error insets before we ran chktex or if we inserted
3268         // error insets after we ran chktex, this must be run:
3269         if (removedErrorInsets || res){
3270                 users->redraw();
3271                 users->fitCursor(users->text);
3272         }
3273         AllowInput(users);
3274
3275         return res;
3276 }
3277
3278
3279 void Buffer::validate(LaTeXFeatures & features) const
3280 {
3281         LyXParagraph * par = paragraph;
3282         LyXTextClass const & tclass =
3283                 textclasslist.TextClass(params.textclass);
3284
3285         // AMS Style is at document level
3286
3287         features.amsstyle = (params.use_amsmath ||
3288                              tclass.provides(LyXTextClass::amsmath));
3289
3290         while (par) {
3291                 // We don't use "lyxerr.debug" because of speed. (Asger)
3292                 if (lyxerr.debugging(Debug::LATEX))
3293                         lyxerr << "Paragraph: " <<  par << endl;
3294
3295                 // Now just follow the list of paragraphs and run
3296                 // validate on each of them.
3297                 par->validate(features);
3298
3299                 // and then the next paragraph
3300                 par = par->next;
3301         }
3302
3303         // the bullet shapes are buffer level not paragraph level
3304         // so they are tested here
3305         for (int i = 0; i < 4; ++i) {
3306                 if (params.user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) {
3307                         int const font = params.user_defined_bullets[i].getFont();
3308                         if (font == 0) {
3309                                 int const c = params
3310                                         .user_defined_bullets[i]
3311                                         .getCharacter();
3312                                 if (c == 16
3313                                    || c == 17
3314                                    || c == 25
3315                                    || c == 26
3316                                    || c == 31) {
3317                                         features.latexsym = true;
3318                                 }
3319                         } else if (font == 1) {
3320                                 features.amssymb = true;
3321                         } else if ((font >= 2 && font <= 5)) {
3322                                 features.pifont = true;
3323                         }
3324                 }
3325         }
3326
3327         if (lyxerr.debugging(Debug::LATEX)) {
3328                 features.showStruct();
3329         }
3330 }
3331
3332
3333 void Buffer::setPaperStuff()
3334 {
3335         params.papersize = BufferParams::PAPER_DEFAULT;
3336         char const c1 = params.paperpackage;
3337         if (c1 == BufferParams::PACKAGE_NONE) {
3338                 char const c2 = params.papersize2;
3339                 if (c2 == BufferParams::VM_PAPER_USLETTER)
3340                         params.papersize = BufferParams::PAPER_USLETTER;
3341                 else if (c2 == BufferParams::VM_PAPER_USLEGAL)
3342                         params.papersize = BufferParams::PAPER_LEGALPAPER;
3343                 else if (c2 == BufferParams::VM_PAPER_USEXECUTIVE)
3344                         params.papersize = BufferParams::PAPER_EXECUTIVEPAPER;
3345                 else if (c2 == BufferParams::VM_PAPER_A3)
3346                         params.papersize = BufferParams::PAPER_A3PAPER;
3347                 else if (c2 == BufferParams::VM_PAPER_A4)
3348                         params.papersize = BufferParams::PAPER_A4PAPER;
3349                 else if (c2 == BufferParams::VM_PAPER_A5)
3350                         params.papersize = BufferParams::PAPER_A5PAPER;
3351                 else if ((c2 == BufferParams::VM_PAPER_B3) || (c2 == BufferParams::VM_PAPER_B4) ||
3352                          (c2 == BufferParams::VM_PAPER_B5))
3353                         params.papersize = BufferParams::PAPER_B5PAPER;
3354         } else if ((c1 == BufferParams::PACKAGE_A4) || (c1 == BufferParams::PACKAGE_A4WIDE) ||
3355                    (c1 == BufferParams::PACKAGE_WIDEMARGINSA4))
3356                 params.papersize = BufferParams::PAPER_A4PAPER;
3357 }
3358
3359
3360 // This function should be in Buffer because it's a buffer's property (ale)
3361 string const Buffer::getIncludeonlyList(char delim)
3362 {
3363         string lst;
3364         for (inset_iterator it = inset_iterator_begin();
3365             it != inset_iterator_end(); ++it) {
3366                 if ((*it)->LyxCode() == Inset::INCLUDE_CODE) {
3367                         InsetInclude * insetinc =
3368                                 static_cast<InsetInclude *>(*it);
3369                         if (insetinc->isInclude()
3370                             && insetinc->isNoLoad()) {
3371                                 if (!lst.empty())
3372                                         lst += delim;
3373                                 lst += OnlyFilename(ChangeExtension(insetinc->getContents(), string()));
3374                         }
3375                 }
3376         }
3377         lyxerr.debug() << "Includeonly(" << lst << ')' << endl;
3378         return lst;
3379 }
3380
3381
3382 vector<string> const Buffer::getLabelList()
3383 {
3384         /// if this is a child document and the parent is already loaded
3385         /// Use the parent's list instead  [ale990407]
3386         if (!params.parentname.empty()
3387             && bufferlist.exists(params.parentname)) {
3388                 Buffer * tmp = bufferlist.getBuffer(params.parentname);
3389                 if (tmp)
3390                         return tmp->getLabelList();
3391         }
3392
3393         vector<string> label_list;
3394         for (inset_iterator it = inset_iterator_begin();
3395              it != inset_iterator_end(); ++it) {
3396                 vector<string> const l = (*it)->getLabelList();
3397                 label_list.insert(label_list.end(), l.begin(), l.end());
3398         }
3399         return label_list;
3400 }
3401
3402
3403 vector<vector<Buffer::TocItem> > const Buffer::getTocList() const
3404 {
3405         int figs = 0;
3406         int tables = 0;
3407         int algs = 0;
3408         vector<vector<TocItem> > l(4);
3409         LyXParagraph * par = paragraph;
3410         while (par) {
3411 #ifndef NEW_INSETS
3412                 if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
3413                         if (textclasslist.Style(params.textclass,
3414                                                 par->GetLayout()).labeltype
3415                             == LABEL_SENSITIVE) {
3416                                 TocItem tmp;
3417                                 tmp.par = par;
3418                                 tmp.depth = 0;
3419                                 tmp.str =  par->String(this, false);
3420                                 switch (par->footnotekind) {
3421                                 case LyXParagraph::FIG:
3422                                 case LyXParagraph::WIDE_FIG:
3423                                         tmp.str = tostr(++figs) + ". "
3424                                                 + tmp.str;
3425                                         l[TOC_LOF].push_back(tmp);
3426                                         break;
3427                                 case LyXParagraph::TAB:
3428                                 case LyXParagraph::WIDE_TAB:
3429                                         tmp.str = tostr(++tables) + ". "
3430                                                 + tmp.str;
3431                                         l[TOC_LOT].push_back(tmp);
3432                                         break;
3433                                 case LyXParagraph::ALGORITHM:
3434                                         tmp.str = tostr(++algs) + ". "
3435                                                 + tmp.str;
3436                                         l[TOC_LOA].push_back(tmp);
3437                                         break;
3438                                 case LyXParagraph::FOOTNOTE:
3439                                 case LyXParagraph::MARGIN:
3440                                         break;
3441                                 }
3442                         }
3443                 } else if (!par->IsDummy()) {
3444 #endif
3445                         char const labeltype =
3446                                 textclasslist.Style(params.textclass,
3447                                                     par->GetLayout()).labeltype;
3448
3449                         if (labeltype >= LABEL_COUNTER_CHAPTER
3450                             && labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) {
3451                                 // insert this into the table of contents
3452                                 TocItem tmp;
3453                                 tmp.par = par;
3454                                 tmp.depth = max(0,
3455                                                 labeltype -
3456                                                 textclasslist.TextClass(params.textclass).maxcounter());
3457                                 tmp.str =  par->String(this, true);
3458                                 l[TOC_TOC].push_back(tmp);
3459                         }
3460 #ifndef NEW_INSETS
3461                 }
3462 #endif
3463                 par = par->next;
3464         }
3465         return l;
3466 }
3467
3468
3469 // This is also a buffer property (ale)
3470 vector<pair<string,string> > const Buffer::getBibkeyList()
3471 {
3472         /// if this is a child document and the parent is already loaded
3473         /// Use the parent's list instead  [ale990412]
3474         if (!params.parentname.empty() && bufferlist.exists(params.parentname)) {
3475                 Buffer * tmp = bufferlist.getBuffer(params.parentname);
3476                 if (tmp)
3477                         return tmp->getBibkeyList();
3478         }
3479
3480         vector<pair<string, string> > keys;
3481         LyXParagraph * par = paragraph;
3482         while (par) {
3483                 if (par->bibkey)
3484                         keys.push_back(pair<string, string>(par->bibkey->getContents(),
3485                                                            par->String(this, false)));
3486                 par = par->next;
3487         }
3488
3489         // Might be either using bibtex or a child has bibliography
3490         if (keys.empty()) {
3491                 for (inset_iterator it = inset_iterator_begin();
3492                         it != inset_iterator_end(); ++it) {
3493                         // Search for Bibtex or Include inset
3494                         if ((*it)->LyxCode() == Inset::BIBTEX_CODE) {
3495                                 vector<pair<string,string> > tmp =
3496                                         static_cast<InsetBibtex*>(*it)->getKeys(this);
3497                                 keys.insert(keys.end(), tmp.begin(), tmp.end());
3498                         } else if ((*it)->LyxCode() == Inset::INCLUDE_CODE) {
3499                                 vector<pair<string,string> > const tmp =
3500                                         static_cast<InsetInclude*>(*it)->getKeys();
3501                                 keys.insert(keys.end(), tmp.begin(), tmp.end());
3502                         }
3503                 }
3504         }
3505
3506         return keys;
3507 }
3508
3509
3510 bool Buffer::isDepClean(string const & name) const
3511 {
3512         DEPCLEAN * item = dep_clean;
3513         while (item && item->master != name)
3514                 item = item->next;
3515         if (!item) return true;
3516         return item->clean;
3517 }
3518
3519
3520 void Buffer::markDepClean(string const & name)
3521 {
3522         if (!dep_clean) {
3523                 dep_clean = new DEPCLEAN;
3524                 dep_clean->clean = true;
3525                 dep_clean->master = name;
3526                 dep_clean->next = 0;
3527         } else {
3528                 DEPCLEAN * item = dep_clean;
3529                 while (item && item->master != name)
3530                         item = item->next;
3531                 if (item) {
3532                         item->clean = true;
3533                 } else {
3534                         item = new DEPCLEAN;
3535                         item->clean = true;
3536                         item->master = name;
3537                         item->next = 0;
3538                 }
3539         }
3540 }
3541
3542
3543 bool Buffer::Dispatch(string const & command)
3544 {
3545         // Split command string into command and argument
3546         string cmd;
3547         string line = frontStrip(command);
3548         string const arg = strip(frontStrip(split(line, cmd, ' ')));
3549
3550         return Dispatch(lyxaction.LookupFunc(cmd), arg);
3551 }
3552
3553
3554 bool Buffer::Dispatch(int action, string const & argument)
3555 {
3556         bool dispatched = true;
3557         switch (action) {
3558                 case LFUN_EXPORT:
3559                         Exporter::Export(this, argument, false);
3560                         break;
3561
3562                 default:
3563                         dispatched = false;
3564         }
3565         return dispatched;
3566 }
3567
3568
3569 void Buffer::resize()
3570 {
3571         /// resize the BufferViews!
3572         if (users)
3573                 users->resize();
3574 }
3575
3576
3577 void Buffer::resizeInsets(BufferView * bv)
3578 {
3579         /// then remove all LyXText in text-insets
3580         LyXParagraph * par = paragraph;
3581         for (; par; par = par->next) {
3582             par->resizeInsetsLyXText(bv);
3583         }
3584 }
3585
3586 void Buffer::ChangeLanguage(Language const * from, Language const * to)
3587 {
3588
3589         LyXParagraph * par = paragraph;
3590         while (par) {
3591                 par->ChangeLanguage(params, from, to);
3592                 par = par->next;
3593         }
3594 }
3595
3596
3597 bool Buffer::isMultiLingual()
3598 {
3599         LyXParagraph * par = paragraph;
3600         while (par) {
3601                 if (par->isMultiLingual(params))
3602                         return true;
3603                 par = par->next;
3604         }
3605         return false;
3606 }
3607
3608
3609 Buffer::inset_iterator::inset_iterator(LyXParagraph * paragraph,
3610                                        LyXParagraph::size_type pos)
3611         : par(paragraph)
3612 {
3613         it = par->InsetIterator(pos);
3614         if (it == par->inset_iterator_end()) {
3615                 par = par->next;
3616                 SetParagraph();
3617         }
3618 }
3619
3620
3621 void Buffer::inset_iterator::SetParagraph()
3622 {
3623         while (par) {
3624                 it = par->inset_iterator_begin();
3625                 if (it != par->inset_iterator_end())
3626                         return;
3627                 par = par->next;
3628         }
3629         //it = 0;
3630         // We maintain an invariant that whenever par = 0 then it = 0
3631 }