X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.C;h=62750128c60941c70bda4896eb53bf3539415296;hb=dacb5be6462e278d769686b7380984b584dd86ac;hp=41ff8b4f938463626e8c1b894f885355479bee0a;hpb=132fe5e1322fbc86a32692df51eba78d6b4e479c;p=lyx.git diff --git a/src/buffer.C b/src/buffer.C index 41ff8b4f93..62750128c6 100644 --- a/src/buffer.C +++ b/src/buffer.C @@ -4,7 +4,7 @@ * LyX, The Document Processor * * Copyright 1995 Matthias Ettrich - * Copyright 1995-1999 The LyX Team. + * Copyright 1995-2000 The LyX Team. * * This file is Copyright 1996-1999 * Lars Gullik Bjønnes @@ -12,31 +12,22 @@ * ====================================================== */ -// Change Log: -// =========== -// 23/03/98 Heinrich Bauer (heinrich.bauer@t-mobil.de) -// Spots marked "changed Heinrich Bauer, 23/03/98" modified due to the -// following bug: dvi file export did not work after printing (or previewing) -// and vice versa as long as the same file was concerned. This happened -// every time the LyX-file was left unchanged between the two actions mentioned -// above. - #include #include #include -using std::ofstream; -using std::ifstream; -using std::fstream; -using std::ios; -using std::setw; - #include #include #include #include +#include + +#ifdef HAVE_LOCALE +#include +#endif + #ifdef __GNUG__ #pragma implementation "buffer.h" #endif @@ -50,7 +41,7 @@ using std::setw; #include "lyxlex.h" #include "tex-strings.h" #include "layout.h" -#include "lyx_cb.h" +#include "bufferview_funcs.h" #include "minibuffer.h" #include "lyxfont.h" #include "version.h" @@ -64,12 +55,11 @@ using std::setw; #include "insets/insetquotes.h" #include "insets/insetlatexaccent.h" #include "insets/insetbib.h" +#include "insets/insetcite.h" +#include "insets/insetexternal.h" #include "insets/insetindex.h" #include "insets/insetinclude.h" #include "insets/insettoc.h" -#include "insets/insetlof.h" -#include "insets/insetlot.h" -#include "insets/insetloa.h" #include "insets/insetparent.h" #include "insets/insetspecialchar.h" #include "insets/figinset.h" @@ -77,10 +67,16 @@ using std::setw; #include "insets/insetert.h" #include "insets/insetgraphics.h" #include "insets/insetfoot.h" +#include "insets/insetmarginal.h" +#include "insets/insetminipage.h" +#include "insets/insetfloat.h" +#include "insets/insetlist.h" +#include "insets/insettabular.h" +#include "insets/insettheorem.h" +#include "insets/insetcaption.h" #include "support/filetools.h" #include "support/path.h" #include "LaTeX.h" -#include "Literate.h" #include "Chktex.h" #include "LyXView.h" #include "debug.h" @@ -88,35 +84,40 @@ using std::setw; #include "support/syscall.h" #include "support/lyxlib.h" #include "support/FileInfo.h" +#include "support/lyxmanip.h" #include "lyxtext.h" #include "gettext.h" - -// Uncomment this line to enable a workaround for the weird behaviour -// of the cursor between a displayed inset and last character -// at the upper line. (Alejandro 20.9.96) -// #define BREAK_BEFORE_INSET - -/* Lars, when changing this file sometime in the future to a list, - * please check out the figinsets-sideeffects described at the - * beginning of figinset.C Matthias (04.07.1996) - */ - +#include "language.h" +#include "lyx_gui_misc.h" // WarnReadonly() +#include "frontends/Dialogs.h" +#include "encoding.h" +#include "exporter.h" +#include "Lsstream.h" + +using std::ostream; +using std::ofstream; +using std::ifstream; +using std::fstream; +using std::ios; +using std::setw; +using std::endl; +using std::pair; +using std::vector; +using std::max; +using std::set; // all these externs should eventually be removed. extern BufferList bufferlist; -extern void MenuExport(Buffer *, string const &); extern LyXAction lyxaction; -static const float LYX_FORMAT = 2.15; +static const float LYX_FORMAT = 2.17; extern int tex_code_break_column; -extern void FreeUpdateTimer(); - -Buffer::Buffer(string const & file, LyXRC * lyxrc, bool ronly) +Buffer::Buffer(string const & file, bool ronly) { lyxerr[Debug::INFO] << "Buffer::Buffer()" << endl; filename = file; @@ -124,15 +125,14 @@ Buffer::Buffer(string const & file, LyXRC * lyxrc, bool ronly) paragraph = 0; lyx_clean = true; bak_clean = true; - dvi_clean_orgd = false; // Heinrich Bauer, 23/03/98 - dvi_clean_tmpd = false; // Heinrich Bauer, 23/03/98 dep_clean = 0; read_only = ronly; + unnamed = false; users = 0; lyxvc.buffer(this); - if (read_only || (lyxrc && lyxrc->use_tempdir)) { + if (read_only || (lyxrc.use_tempdir)) { tmppath = CreateBufferTmpDir(); - } else tmppath.clear(); + } else tmppath.erase(); } @@ -162,10 +162,34 @@ Buffer::~Buffer() } -bool Buffer::saveParamsAsDefaults() +string const Buffer::getLatexName(bool no_path) const +{ + if (no_path) + return OnlyFilename(ChangeExtension(MakeLatexName(filename), + ".tex")); + else + return ChangeExtension(MakeLatexName(filename), + ".tex"); +} + + +void Buffer::setReadonly(bool flag) +{ + if (read_only != flag) { + read_only = flag; + updateTitles(); + users->owner()->getDialogs()->updateBufferDependent(false); + } + if (read_only) { + WarnReadonly(filename); + } +} + + +bool Buffer::saveParamsAsDefaults() // const { - string fname = AddName(AddPath(user_lyxdir, "templates/"), - "defaults.lyx"); + string const fname = AddName(AddPath(user_lyxdir, "templates/"), + "defaults.lyx"); Buffer defaults = Buffer(fname); // Use the current buffer's parameters as default @@ -194,7 +218,7 @@ void Buffer::resetAutosaveTimers() const } -void Buffer::fileName(string const & newfile) +void Buffer::setFileName(string const & newfile) { filename = MakeAbsPath(newfile); filepath = OnlyPath(filename); @@ -211,27 +235,29 @@ void Buffer::fileName(string const & newfile) // if par = 0 normal behavior // else insert behavior // Returns false if "\the_end" is not read for formats >= 2.13. (Asger) -#define USE_PARSE_FUNCTION 1 bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par) { - string tmptok; int pos = 0; char depth = 0; // signed or unsigned? +#ifndef NEW_INSETS LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE; LyXParagraph::footnote_kind footnotekind = LyXParagraph::FOOTNOTE; +#endif bool the_end_read = false; LyXParagraph * return_par = 0; - LyXFont font(LyXFont::ALL_INHERIT); + LyXFont font(LyXFont::ALL_INHERIT, params.language); + if (format < 2.16 && params.language->lang() == "hebrew") + font.setLanguage(default_language); // If we are inserting, we cheat and get a token in advance bool has_token = false; string pretoken; - if(!par) { + if (!par) { par = new LyXParagraph; } else { - users->text->BreakParagraph(); + users->text->BreakParagraph(users); return_par = users->text->FirstParagraph(); pos = 0; markDirty(); @@ -255,15 +281,17 @@ bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par) pretoken = lex.GetString(); } - // Profiling show this should give a lot: (Asger) - string const token = pretoken; - - if (token.empty()) - continue; - the_end_read = parseSingleLyXformat2Token(lex, par, return_par, - token, pos, depth, - font, footnoteflag, - footnotekind); + if (pretoken.empty()) continue; + + the_end_read = + parseSingleLyXformat2Token(lex, par, return_par, + pretoken, pos, depth, + font +#ifndef NEW_INSETS + , footnoteflag, + footnotekind +#endif + ); } if (!return_par) @@ -275,50 +303,51 @@ bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par) } -bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, - LyXParagraph *& return_par, - const string & token, int & pos, - char & depth, LyXFont & font, - LyXParagraph::footnote_flag & footnoteflag, - LyXParagraph::footnote_kind & footnotekind) +// We'll remove this later. (Lgb) +static string last_inset_read; + + +bool +Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, + LyXParagraph *& return_par, + string const & token, int & pos, + char & depth, LyXFont & font +#ifndef NEW_INSETS + , LyXParagraph::footnote_flag & footnoteflag, + LyXParagraph::footnote_kind & footnotekind +#endif + ) { - Inset * inset = 0; - int tmpret, tmpret2; - string tmptok; bool the_end_read = false; if (token[0] != '\\') { - int n = token.length(); - for (int i = 0; i < n; ++i) { - par->InsertChar(pos, token[i]); - par->SetFont(pos, font); + for (string::const_iterator cit = token.begin(); + cit != token.end(); ++cit) { + par->InsertChar(pos, (*cit), font); ++pos; } } else if (token == "\\i") { - inset = new InsetLatexAccent; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - - par->InsertInset(pos, inset); - par->SetFont(pos, font); + Inset * inset = new InsetLatexAccent; + inset->Read(this, lex); + par->InsertInset(pos, inset, font); ++pos; } else if (token == "\\layout") { if (!return_par) return_par = par; else { - par->text.resize(par->text.size()); + par->fitToSize(); par = new LyXParagraph(par); } pos = 0; lex.EatLine(); - string layoutname = lex.GetString(); + string const layoutname = lex.GetString(); pair pp = textclasslist.NumberOfLayout(params.textclass, layoutname); if (pp.first) { par->layout = pp.second; } else { // layout not found - // use default layout "Standard" (0) + // use default layout "Standard" (0) par->layout = 0; } // Test whether the layout is obsolete. @@ -329,15 +358,20 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, par->layout = textclasslist.NumberOfLayout(params.textclass, layout.obsoleted_by()).second; +#ifndef NEW_INSETS par->footnoteflag = footnoteflag; par->footnotekind = footnotekind; +#endif par->depth = depth; - font = LyXFont(LyXFont::ALL_INHERIT); + font = LyXFont(LyXFont::ALL_INHERIT, params.language); + if (format < 2.16 && params.language->lang() == "hebrew") + font.setLanguage(default_language); +#ifndef NEW_INSETS } else if (token == "\\end_float") { if (!return_par) return_par = par; else { - par->text.resize(par->text.size()); + par->fitToSize(); par = new LyXParagraph(par); } footnotekind = LyXParagraph::FOOTNOTE; @@ -345,9 +379,11 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, pos = 0; lex.EatLine(); par->layout = LYX_DUMMY_LAYOUT; - font = LyXFont(LyXFont::ALL_INHERIT); + font = LyXFont(LyXFont::ALL_INHERIT, params.language); + if (format < 2.16 && params.language->lang() == "hebrew") + font.setLanguage(default_language); } else if (token == "\\begin_float") { - tmpret = lex.FindToken(string_footnotekinds); + int tmpret = lex.FindToken(string_footnotekinds); if (tmpret == -1) ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) footnotekind = static_cast(tmpret); // bad @@ -356,6 +392,80 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, footnoteflag = LyXParagraph::CLOSED_FOOTNOTE; else footnoteflag = LyXParagraph::OPEN_FOOTNOTE; +#else + } else if (token == "\\begin_float") { + // This is the compability reader, unfinished but tested. + // (Lgb) + lex.next(); + string const tmptok = lex.GetString(); + //lyxerr << "old float: " << tmptok << endl; + + Inset * inset = 0; + string old_float; + + if (tmptok == "footnote") { + inset = new InsetFoot; + } else if (tmptok == "margin") { + inset = new InsetMarginal; + } else if (tmptok == "fig") { + inset = new InsetFloat("figure"); + old_float += "placement htbp\n"; + } else if (tmptok == "tab") { + inset = new InsetFloat("table"); + old_float += "placement htbp\n"; + } else if (tmptok == "alg") { + inset = new InsetFloat("algorithm"); + old_float += "placement htbp\n"; + } else if (tmptok == "wide-fig") { + InsetFloat * tmp = new InsetFloat("figure"); + tmp->wide(true); + inset = tmp; + old_float += "placement htbp\n"; + } else if (tmptok == "wide-tab") { + InsetFloat * tmp = new InsetFloat("table"); + tmp->wide(true); + inset = tmp; + old_float += "placement htbp\n"; + } + + if (!inset) return false; // no end read yet + + old_float += "collapsed true\n"; + + // Here we need to check for \end_deeper and handle that + // before we do the footnote parsing. + // This _is_ a hack! (Lgb) + while(true) { + lex.next(); + string const tmp = lex.GetString(); + if (tmp == "\\end_deeper") { + lyxerr << "\\end_deeper caught!" << endl; + if (!depth) { + lex.printError("\\end_deeper: " + "depth is already null"); + } else + --depth; + + } else { + old_float += tmp; + old_float += ' '; + break; + } + } + + old_float += lex.getLongString("\\end_float"); + old_float += "\n\\end_inset\n"; + //lyxerr << "float body: " << old_float << endl; + + istringstream istr(old_float); + + LyXLex nylex(0, 0); + nylex.setStream(istr); + + inset->Read(this, nylex); + par->InsertInset(pos, inset, font); + ++pos; +#endif } else if (token == "\\begin_deeper") { ++depth; } else if (token == "\\end_deeper") { @@ -374,7 +484,7 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, if (pp.first) { params.textclass = pp.second; } else { - lex.printError("Unknown textclass `$$Token'"); + lex.printError("Unknown textclass `$$Token'"); params.textclass = 0; } if (!textclasslist.Load(params.textclass)) { @@ -421,7 +531,7 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } else if (token == "\\start_of_appendix") { par->start_of_appendix = true; } else if (token == "\\paragraph_separation") { - tmpret = lex.FindToken(string_paragraph_separation); + int tmpret = lex.FindToken(string_paragraph_separation); if (tmpret == -1) ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) params.paragraph_separation = @@ -429,24 +539,18 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } else if (token == "\\defskip") { lex.nextToken(); params.defskip = VSpace(lex.GetString()); - } else if (token == "\\no_isolatin1") { // obsolete - lex.nextToken(); - } else if (token == "\\no_babel") { // obsolete - lex.nextToken(); - } else if (token == "\\no_epsfig") { // obsolete - lex.nextToken(); } else if (token == "\\epsfig") { // obsolete // Indeed it is obsolete, but we HAVE to be backwards // compatible until 0.14, because otherwise all figures // in existing documents are irretrivably lost. (Asger) params.readGraphicsDriver(lex); } else if (token == "\\quotes_language") { - tmpret = lex.FindToken(string_quotes_language); + int tmpret = lex.FindToken(string_quotes_language); if (tmpret == -1) ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) { InsetQuotes::quote_language tmpl = InsetQuotes::EnglishQ; - switch(tmpret) { + switch (tmpret) { case 0: tmpl = InsetQuotes::EnglishQ; break; @@ -470,7 +574,7 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } } else if (token == "\\quotes_times") { lex.nextToken(); - switch(lex.GetInteger()) { + switch (lex.GetInteger()) { case 1: params.quotes_times = InsetQuotes::SingleQ; break; @@ -479,13 +583,13 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, break; } } else if (token == "\\papersize") { - tmpret = lex.FindToken(string_papersize); + int tmpret = lex.FindToken(string_papersize); if (tmpret == -1) ++tmpret; else params.papersize2 = tmpret; } else if (token == "\\paperpackage") { - tmpret = lex.FindToken(string_paperpackages); + int tmpret = lex.FindToken(string_paperpackages); if (tmpret == -1) { ++tmpret; params.paperpackage = BufferParams::PACKAGE_NONE; @@ -498,7 +602,7 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, lex.nextToken(); params.use_amsmath = lex.GetInteger(); } else if (token == "\\paperorientation") { - tmpret = lex.FindToken(string_orientation); + int tmpret = lex.FindToken(string_orientation); if (tmpret == -1) ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) params.orientation = static_cast(tmpret); @@ -537,7 +641,7 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, params.columns = lex.GetInteger(); } else if (token == "\\papersides") { lex.nextToken(); - switch(lex.GetInteger()) { + switch (lex.GetInteger()) { default: case 1: params.sides = LyXTextClass::OneSide; break; case 2: params.sides = LyXTextClass::TwoSides; break; @@ -547,7 +651,7 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, params.pagestyle = strip(lex.GetString()); } else if (token == "\\bullet") { lex.nextToken(); - int index = lex.GetInteger(); + int const index = lex.GetInteger(); lex.nextToken(); int temp_int = lex.GetInteger(); params.user_defined_bullets[index].setFont(temp_int); @@ -561,7 +665,7 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, params.user_defined_bullets[index].setSize(temp_int); params.temp_bullets[index].setSize(temp_int); lex.nextToken(); - string temp_str = lex.GetString(); + string const temp_str = lex.GetString(); if (temp_str != "\\end_bullet") { // this element isn't really necessary for // parsing but is easier for humans @@ -572,9 +676,10 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } } else if (token == "\\bulletLaTeX") { lex.nextToken(); - int index = lex.GetInteger(); + int const index = lex.GetInteger(); lex.next(); - string temp_str = lex.GetString(), sum_str; + string temp_str = lex.GetString(); + string sum_str; while (temp_str != "\\end_bullet") { // this loop structure is needed when user // enters an empty string since the first @@ -594,34 +699,50 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } else if (token == "\\tocdepth") { lex.nextToken(); params.tocdepth = lex.GetInteger(); - } else if (token == "\\baselinestretch") { // obsolete - lex.nextToken(); // should not be used directly - // anymore. - // Will probably keep a kind of support just for - // compability. - params.spacing.set(Spacing::Other, lex.GetFloat()); } else if (token == "\\spacing") { lex.next(); - string tmp = strip(lex.GetString()); + string const tmp = strip(lex.GetString()); + Spacing::Space tmp_space = Spacing::Default; + float tmp_val = 0.0; + if (tmp == "single") { + tmp_space = Spacing::Single; + } else if (tmp == "onehalf") { + tmp_space = Spacing::Onehalf; + } else if (tmp == "double") { + tmp_space = Spacing::Double; + } else if (tmp == "other") { + lex.next(); + tmp_space = Spacing::Other; + tmp_val = lex.GetFloat(); + } else { + lex.printError("Unknown spacing token: '$$Token'"); + } + // Small hack so that files written with klyx will be + // parsed correctly. + if (return_par) { + par->spacing.set(tmp_space, tmp_val); + } else { + params.spacing.set(tmp_space, tmp_val); + } + } else if (token == "\\paragraph_spacing") { + lex.next(); + string const tmp = strip(lex.GetString()); if (tmp == "single") { - params.spacing.set(Spacing::Single); + par->spacing.set(Spacing::Single); } else if (tmp == "onehalf") { - params.spacing.set(Spacing::Onehalf); + par->spacing.set(Spacing::Onehalf); } else if (tmp == "double") { - params.spacing.set(Spacing::Double); + par->spacing.set(Spacing::Double); } else if (tmp == "other") { lex.next(); - params.spacing.set(Spacing::Other, - lex.GetFloat()); + par->spacing.set(Spacing::Other, + lex.GetFloat()); } else { lex.printError("Unknown spacing token: '$$Token'"); } } else if (token == "\\float_placement") { lex.nextToken(); params.float_placement = lex.GetString(); - } else if (token == "\\cursor") { // obsolete - // this is obsolete, so we just skip it. - lex.nextToken(); } else if (token == "\\family") { lex.next(); font.setLyXFamily(lex.GetString()); @@ -636,7 +757,7 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, font.setLyXSize(lex.GetString()); } else if (token == "\\latex") { lex.next(); - string tok = lex.GetString(); + string const tok = lex.GetString(); // This is dirty, but gone with LyX3. (Asger) if (tok == "no_latex") font.setLatex(LyXFont::OFF); @@ -647,24 +768,25 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, else lex.printError("Unknown LaTeX font flag " "`$$Token'"); - } else if (token == "\\direction") { + } else if (token == "\\lang") { lex.next(); - string tok = lex.GetString(); - if (tok == "ltr") - font.setDirection(LyXFont::LTR_DIR); - else if (tok == "rtl") - font.setDirection(LyXFont::RTL_DIR); - else if (tok == "default") - font.setDirection(LyXFont::INHERIT_DIR); - else - lex.printError("Unknown font flag " - "`$$Token'"); + string const tok = lex.GetString(); + Language const * lang = languages.getLanguage(tok); + if (lang) { + font.setLanguage(lang); + } else { + font.setLanguage(params.language); + lex.printError("Unknown language `$$Token'"); + } + } else if (token == "\\numeric") { + lex.next(); + font.setNumber(font.setLyXMisc(lex.GetString())); } else if (token == "\\emph") { lex.next(); font.setEmph(font.setLyXMisc(lex.GetString())); } else if (token == "\\bar") { lex.next(); - string tok = lex.GetString(); + string const tok = lex.GetString(); // This is dirty, but gone with LyX3. (Asger) if (tok == "under") font.setUnderbar(LyXFont::ON); @@ -682,20 +804,20 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, lex.next(); font.setLyXColor(lex.GetString()); } else if (token == "\\align") { - tmpret = lex.FindToken(string_align); + int tmpret = lex.FindToken(string_align); if (tmpret == -1) ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) { // tmpret != 99 ??? - tmpret2 = 1; + int tmpret2 = 1; for (; tmpret > 0; --tmpret) tmpret2 = tmpret2 * 2; par->align = LyXAlignment(tmpret2); } } else if (token == "\\added_space_top") { lex.nextToken(); - par->added_space_top = lex.GetString(); + par->added_space_top = VSpace(lex.GetString()); } else if (token == "\\added_space_bottom") { lex.nextToken(); - par->added_space_bottom = lex.GetString(); + par->added_space_bottom = VSpace(lex.GetString()); } else if (token == "\\pextra_type") { lex.nextToken(); par->pextra_type = lex.GetInteger(); @@ -717,328 +839,220 @@ bool Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } else if (token == "\\labelwidthstring") { lex.EatLine(); par->labelwidthstring = lex.GetString(); - /* do not delete this token, it is still needed! */ + // do not delete this token, it is still needed! } else if (token == "\\end_inset") { - /* simple ignore this. The insets do not have - * to read this */ - // but insets should read it, it is a part of - //the inset isn't it? Lgb. + lyxerr << "Solitary \\end_inset. Missing \\begin_inset?.\n" + << "Last inset read was: " << last_inset_read + << endl; + // Simply ignore this. The insets do not have + // to read this. + // But insets should read it, it is a part of + // the inset isn't it? Lgb. } else if (token == "\\begin_inset") { - lex.next(); - tmptok = lex.GetString(); - /* test the different insets */ - if (tmptok == "Quotes") { - inset = new InsetQuotes; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "\\i") { - inset = new InsetLatexAccent; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "FormulaMacro") { - inset = new InsetFormulaMacro; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "Formula") { - inset = new InsetFormula; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "Figure") { - inset = new InsetFig(100, 100, this); - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "Info") { - inset = new InsetInfo; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "Include") { - inset = new InsetInclude(string(), this); - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "ERT") { - inset = new InsetERT(this); - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "Text") { - inset = new InsetText(this); - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "Foot") { - inset = new InsetFoot(this); - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (tmptok == "GRAPHICS") { - inset = new InsetGraphics; - //inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - } else if (tmptok == "LatexCommand") { - InsetCommand inscmd; - inscmd.Read(lex); - if (inscmd.getCmdName() == "cite") { - inset = new InsetCitation(inscmd.getContents(), inscmd.getOptions()); - } else if (inscmd.getCmdName() == "bibitem") { - lex.printError("Wrong place for bibitem"); - inset = inscmd.Clone(); - } else if (inscmd.getCmdName() == "BibTeX") { - inset = new InsetBibtex(inscmd.getContents(), inscmd.getOptions(), this); - } else if (inscmd.getCmdName() == "index") { - inset = new InsetIndex(inscmd.getContents()); - } else if (inscmd.getCmdName() == "include") { - inset = new InsetInclude(inscmd.getContents(), this); - } else if (inscmd.getCmdName() == "label") { - inset = new InsetLabel(inscmd.getCommand()); - } else if (inscmd.getCmdName() == "url" - || inscmd.getCmdName() == "htmlurl") { - inset = new InsetUrl(inscmd.getCommand()); - } else if (inscmd.getCmdName() == "ref" - || inscmd.getCmdName() == "pageref") { - if (!inscmd.getOptions().empty() || !inscmd.getContents().empty()) { - inset = new InsetRef(inscmd, this); - } -#warning Verify that this else clause is still needed. (Lgb) -#if 0 - // This condition comes from a - // temporary solution to the latexdel - // ref inset that was transformed to - // an empty ref inset plus the body - // surronded by latexdel insets - else { - string cont, opt, tmptmptok, cmdname; - lex.next(); - while(lex.IsOK() && lex.GetString() != "\\end_inset" ) { - lex.next(); - } - lex.next(); - while(lex.IsOK()) { - tmptmptok = lex.GetString(); - if(tmptmptok[0] == '\\') { - if( tmptmptok == "\\backslash") - opt += '\\'; - else - break; - } - else - opt += tmptmptok; - opt += ' '; - lex.next(); - } - while(lex.IsOK() && lex.GetString() != "\\end_inset" ) { - lex.next(); - } - lex.next(); - while(lex.IsOK()) { - tmptmptok = lex.GetString(); - if(tmptmptok[0] == '\\') { - if( tmptmptok == "\\backslash") - cont += '\\'; - else - break; - } - else - cont += tmptmptok; - cont += ' '; - lex.next(); - } - while(lex.IsOK() && lex.GetString() != "\\end_inset" ) { - lex.next(); - } - - cont = strip(cont); - opt = strip(opt); - cmdname = "\\" + inscmd.getCmdName(); - cmdname += "[" + cont + "]"; - cmdname += "{" + opt + "}"; - inset = new InsetRef(cmdname, this); - } -#endif - } else if (inscmd.getCmdName() == "tableofcontents") { - inset = new InsetTOC(this); - } else if (inscmd.getCmdName() == "listoffigures") { - inset = new InsetLOF(this); - } else if (inscmd.getCmdName() == "listofalgorithms") { - inset = new InsetLOA(this); - } else if (inscmd.getCmdName() == "listoftables") { - inset = new InsetLOT(this); - } else if (inscmd.getCmdName() == "printindex") { - inset = new InsetPrintIndex(this); - } else if (inscmd.getCmdName() == "lyxparent") { - inset = new InsetParent(inscmd.getContents(), this); - } - - if (inset) { - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } - } - } else if (token == "\\InsetQuotes") { - inset = new InsetQuotes; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; - } else if (token == "\\InsetFormula") { - inset = new InsetFormula; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - ++pos; + readInset(lex, par, pos, font); } else if (token == "\\SpecialChar") { LyXLayout const & layout = textclasslist.Style(params.textclass, par->GetLayout()); // Insets don't make sense in a free-spacing context! ---Kayvan - if (layout.free_spacing) - { + if (layout.free_spacing) { if (lex.IsOK()) { - string next_token; lex.next(); - next_token = lex.GetString(); + string next_token = lex.GetString(); if (next_token == "\\-") { - par->InsertChar(pos, '-'); - par->SetFont(pos, font); - } else if (next_token == "\\protected_separator") { - par->InsertChar(pos, ' '); - par->SetFont(pos, font); + par->InsertChar(pos, '-', font); + } else if (next_token == "\\protected_separator" + || next_token == "~") { + par->InsertChar(pos, ' ', font); } else { lex.printError("Token `$$Token' " "is in free space " "paragraph layout!"); - pos--; + --pos; } } + } else { + Inset * inset = new InsetSpecialChar; + inset->Read(this, lex); + par->InsertInset(pos, inset, font); } - else - { - inset = new InsetSpecialChar; - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); - } - ++pos; - } else if (token == "\\Figure") { - inset = new InsetFig(100, 100, this); - inset->Read(lex); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); ++pos; - } else if (token == "\\newline") { // soon obsolete -#if 1 - par->InsertChar(pos, LyXParagraph::META_NEWLINE); - par->SetFont(pos, font); -#else - inset = new InsetSpecialChar(InsetSpecialChar::NEWLINE); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); -#endif + } else if (token == "\\newline") { + par->InsertChar(pos, LyXParagraph::META_NEWLINE, font); ++pos; } else if (token == "\\LyXTable") { - par->table = new LyXTable(lex); + Inset * inset = new InsetTabular(*this); + inset->Read(this, lex); + par->InsertInset(pos, inset, font); + ++pos; } else if (token == "\\hfill") { - par->InsertChar(pos, LyXParagraph::META_HFILL); - par->SetFont(pos, font); + par->InsertChar(pos, LyXParagraph::META_HFILL, font); ++pos; } else if (token == "\\protected_separator") { // obsolete -#if 1 + // This is a backward compability thingie. (Lgb) + // Remove it later some time...introduced with fileformat + // 2.16. (Lgb) LyXLayout const & layout = textclasslist.Style(params.textclass, par->GetLayout()); if (layout.free_spacing) { - par->InsertChar(pos, ' '); - par->SetFont(pos, font); + par->InsertChar(pos, ' ', font); } else { - inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); - par->InsertChar(pos, LyXParagraph::META_INSET); - par->InsertInset(pos, inset); - par->SetFont(pos, font); + Inset * inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); + par->InsertInset(pos, inset, font); } -#else - par->InsertChar(pos, LyXParagraph::META_PROTECTED_SEPARATOR); - par->SetFont(pos, font); -#endif ++pos; } else if (token == "\\bibitem") { // ale970302 - if (!par->bibkey) - par->bibkey = new InsetBibKey; - par->bibkey->Read(lex); - }else if (token == "\\backslash") { - par->InsertChar(pos, '\\'); - par->SetFont(pos, font); + if (!par->bibkey) { + InsetCommandParams p( "bibitem" ); + par->bibkey = new InsetBibKey(p); + } + par->bibkey->Read(this, lex); + } else if (token == "\\backslash") { + par->InsertChar(pos, '\\', font); ++pos; - }else if (token == "\\the_end") { + } else if (token == "\\the_end") { the_end_read = true; } else { // This should be insurance for the future: (Asger) lex.printError("Unknown token `$$Token'. " "Inserting as text."); - int n = token.length(); - for (int i = 0; i < n; ++i) { - par->InsertChar(pos, token[i]); - par->SetFont(pos, font); + string::const_iterator cit = token.begin(); + string::const_iterator end = token.end(); + for (; cit != end; ++cit) { + par->InsertChar(pos, (*cit), font); ++pos; } } return the_end_read; } -bool Buffer::readFile(LyXLex & lex, LyXParagraph * par) + +void Buffer::readInset(LyXLex & lex, LyXParagraph *& par, + int & pos, LyXFont & font) { - string token; + // consistency check + if (lex.GetString() != "\\begin_inset") { + lyxerr << "Buffer::readInset: Consistency check failed." + << endl; + } + + Inset * inset = 0; + + lex.next(); + string const tmptok = lex.GetString(); + last_inset_read = tmptok; + + // test the different insets + if (tmptok == "LatexCommand") { + InsetCommandParams inscmd; + inscmd.Read(lex); + + if (inscmd.getCmdName() == "cite") { + inset = new InsetCitation(inscmd); + } else if (inscmd.getCmdName() == "bibitem") { + lex.printError("Wrong place for bibitem"); + inset = new InsetBibKey(inscmd); + } else if (inscmd.getCmdName() == "BibTeX") { + inset = new InsetBibtex(inscmd); + } else if (inscmd.getCmdName() == "index") { + inset = new InsetIndex(inscmd); + } else if (inscmd.getCmdName() == "include") { + inset = new InsetInclude(inscmd, *this); + } else if (inscmd.getCmdName() == "label") { + inset = new InsetLabel(inscmd); + } else if (inscmd.getCmdName() == "url" + || inscmd.getCmdName() == "htmlurl") { + inset = new InsetUrl(inscmd); + } else if (inscmd.getCmdName() == "ref" + || inscmd.getCmdName() == "pageref" + || inscmd.getCmdName() == "vref" + || inscmd.getCmdName() == "vpageref" + || inscmd.getCmdName() == "prettyref") { + if (!inscmd.getOptions().empty() + || !inscmd.getContents().empty()) { + inset = new InsetRef(inscmd, *this); + } + } else if (inscmd.getCmdName() == "tableofcontents" + || inscmd.getCmdName() == "listofalgorithms" + || inscmd.getCmdName() == "listoffigures" + || inscmd.getCmdName() == "listoftables") { + inset = new InsetTOC(inscmd); + } else if (inscmd.getCmdName() == "printindex") { + inset = new InsetPrintIndex(inscmd); + } else if (inscmd.getCmdName() == "lyxparent") { + inset = new InsetParent(inscmd, *this); + } + } else { + if (tmptok == "Quotes") { + inset = new InsetQuotes; + } else if (tmptok == "External") { + inset = new InsetExternal; + } else if (tmptok == "FormulaMacro") { + inset = new InsetFormulaMacro; + } else if (tmptok == "Formula") { + inset = new InsetFormula; + } else if (tmptok == "Figure") { + inset = new InsetFig(100, 100, *this); + } else if (tmptok == "Info") { + inset = new InsetInfo; + } else if (tmptok == "Include") { + InsetCommandParams p( "Include" ); + inset = new InsetInclude(p, *this); + } else if (tmptok == "ERT") { + inset = new InsetERT; + } else if (tmptok == "Tabular") { + inset = new InsetTabular(*this); + } else if (tmptok == "Text") { + inset = new InsetText; + } else if (tmptok == "Foot") { + inset = new InsetFoot; + } else if (tmptok == "Marginal") { + inset = new InsetMarginal; + } else if (tmptok == "Minipage") { + inset = new InsetMinipage; + } else if (tmptok == "Float") { + lex.next(); + string tmptok = lex.GetString(); + inset = new InsetFloat(tmptok); + } else if (tmptok == "List") { + inset = new InsetList; + } else if (tmptok == "Theorem") { + inset = new InsetList; + } else if (tmptok == "Caption") { + inset = new InsetCaption; + } else if (tmptok == "GRAPHICS") { + inset = new InsetGraphics; + } + + if (inset) inset->Read(this, lex); + } + + if (inset) { + par->InsertInset(pos, inset, font); + ++pos; + } +} + +bool Buffer::readFile(LyXLex & lex, LyXParagraph * par) +{ if (lex.IsOK()) { lex.next(); - token = lex.GetString(); + string const token(lex.GetString()); if (token == "\\lyxformat") { // the first token _must_ be... - lex.next(); + lex.EatLine(); format = lex.GetFloat(); - if (format > 1) { + if (format > 1.0) { if (LYX_FORMAT - format > 0.05) { - printf(_("Warning: need lyxformat %.2f but found %.2f\n"), - LYX_FORMAT, format); + lyxerr << fmt(_("Warning: need lyxformat %.2f but found %.2f"), + LYX_FORMAT, format) << endl; } if (format - LYX_FORMAT > 0.05) { - printf(_("ERROR: need lyxformat %.2f but found %.2f\n"), - LYX_FORMAT, format); + lyxerr << fmt(_("ERROR: need lyxformat %.2f but found %.2f"), + LYX_FORMAT, format) << endl; } bool the_end = readLyXformat2(lex, par); // Formats >= 2.13 support "\the_end" marker @@ -1054,7 +1068,7 @@ bool Buffer::readFile(LyXLex & lex, LyXParagraph * par) // We simulate a safe reading anyways to allow // users to take the chance... (Asger) return true; - } // format < 1 + } // format < 1.0 else { WriteAlert(_("ERROR!"), _("Old LyX file format found. " @@ -1073,14 +1087,19 @@ bool Buffer::readFile(LyXLex & lex, LyXParagraph * par) // Should probably be moved to somewhere else: BufferView? LyXView? -bool Buffer::save(bool makeBackup) const +bool Buffer::save() const { // We don't need autosaves in the immediate future. (Asger) resetAutosaveTimers(); // make a backup - if (makeBackup) { - string s = fileName() + '~'; + string s; + if (lyxrc.make_backup) { + s = fileName() + '~'; + if (!lyxrc.backupdir_path.empty()) + s = AddName(lyxrc.backupdir_path, + subst(CleanupPath(s),'/','!')); + // Rename is the wrong way of making a backup, // this is the correct way. /* truss cp fil fil2: @@ -1108,10 +1127,10 @@ bool Buffer::save(bool makeBackup) const FileInfo finfo(fileName()); if (finfo.exist()) { mode_t fmode = finfo.getMode(); - struct utimbuf * times = new struct utimbuf; + struct utimbuf times = { + finfo.getAccessTime(), + finfo.getModificationTime() }; - times->actime = finfo.getAccessTime(); - times->modtime = finfo.getModificationTime(); ifstream ifs(fileName().c_str()); ofstream ofs(s.c_str(), ios::out|ios::trunc); if (ifs && ofs) { @@ -1120,37 +1139,23 @@ bool Buffer::save(bool makeBackup) const ofs.close(); ::chmod(s.c_str(), fmode); - if (::utime(s.c_str(), times)) { + if (::utime(s.c_str(), ×)) { lyxerr << "utime error." << endl; } } else { lyxerr << "LyX was not able to make " "backupcopy. Beware." << endl; } - delete times; } } if (writeFile(fileName(), false)) { markLyxClean(); - - // now delete the autosavefile - string a = OnlyPath(fileName()); - a += '#'; - a += OnlyFilename(fileName()); - a += '#'; - FileInfo fileinfo(a); - if (fileinfo.exist()) { - if (::remove(a.c_str()) != 0) { - WriteFSAlert(_("Could not delete " - "auto-save file!"), a); - } - } + removeAutosaveFile(fileName()); } else { // Saving failed, so backup is not backup - if (makeBackup) { - string s = fileName() + '~'; - ::rename(s.c_str(), fileName().c_str()); + if (lyxrc.make_backup) { + lyx::rename(s, fileName()); } return false; } @@ -1200,6 +1205,12 @@ bool Buffer::writeFile(string const & fname, bool flag) const fname); return false; } + +#ifdef HAVE_LOCALE + // Use the standard "C" locale for file output. + ofs.imbue(std::locale::classic()); +#endif + // The top of the file should not be written by params. // write out a comment in the top of the file @@ -1207,8 +1218,13 @@ bool Buffer::writeFile(string const & fname, bool flag) const << " created this file. For more info see http://www.lyx.org/\n"; ofs.setf(ios::showpoint|ios::fixed); ofs.precision(2); +#ifndef HAVE_LOCALE + char dummy_format[512]; + sprintf(dummy_format, "%.2f", LYX_FORMAT); + ofs << "\\lyxformat " << dummy_format << "\n"; +#else ofs << "\\lyxformat " << setw(4) << LYX_FORMAT << "\n"; - +#endif // now write out the buffer paramters. params.writeFile(ofs); @@ -1217,27 +1233,54 @@ bool Buffer::writeFile(string const & fname, bool flag) const // this will write out all the paragraphs // using recursive descent. - paragraph->writeFile(ofs, params, footnoteflag, depth); + paragraph->writeFile(this, ofs, params, footnoteflag, depth); // Write marker that shows file is complete ofs << "\n\\the_end" << endl; + ofs.close(); + // how to check if close went ok? - return true; + // Following is an attempt... (BE 20001011) + + // good() returns false if any error occured, including some + // formatting error. + // bad() returns true if something bad happened in the buffer, + // which should include file system full errors. + + bool status = true; + if (!ofs.good()) { + status = false; +#if 0 + if (ofs.bad()) { + lyxerr << "Buffer::writeFile: BAD ERROR!" << endl; + } else { + lyxerr << "Buffer::writeFile: NOT SO BAD ERROR!" + << endl; + } +#endif + } + + return status; } +#if 0 void Buffer::writeFileAscii(string const & fname, int linelen) { - LyXFont font1, font2; Inset * inset; - char c, footnoteflag = 0, depth = 0; + char c; + char footnoteflag = 0; + char depth = 0; string tmp; LyXParagraph::size_type i; - int j, h, ltype = 0, ltype_depth = 0, - * clen = 0, actcell = 0, actpos = 0, cell = 0, cells = 0, - currlinelen = 0; - long fpos = 0; + int j; + int ltype = 0; + int ltype_depth = 0; + int actcell = 0; + int actpos = 0; + int currlinelen = 0; + int fpos = 0; bool ref_printed = false; ofstream ofs(fname.c_str()); @@ -1246,15 +1289,22 @@ void Buffer::writeFileAscii(string const & fname, int linelen) return; } - string fname1 = TmpFileName(); + string const fname1 = lyx::tempName(); //TmpFileName(); LyXParagraph * par = paragraph; while (par) { int noparbreak = 0; int islatex = 0; - if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE || - !par->previous || - par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE){ - + if ( +#ifndef NEW_INSETS + par->footnoteflag != LyXParagraph::NO_FOOTNOTE || +#endif + !par->previous +#ifndef NEW_INSETS + || par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE +#endif + ){ + +#ifndef NEW_INSETS /* begins a footnote environment ? */ if (footnoteflag != par->footnoteflag) { footnoteflag = par->footnoteflag; @@ -1267,6 +1317,7 @@ void Buffer::writeFileAscii(string const & fname, int linelen) currlinelen += j; } } +#endif /* begins or ends a deeper area ?*/ if (depth != par->depth) { @@ -1290,10 +1341,10 @@ void Buffer::writeFileAscii(string const & fname, int linelen) } else if (tmp == "Enumerate") { ltype = 2; ltype_depth = depth+1; - } else if (strstr(tmp.c_str(), "ection")) { + } else if (contains(tmp, "ection")) { ltype = 3; ltype_depth = depth+1; - } else if (strstr(tmp.c_str(), "aragraph")) { + } else if (contains(tmp, "aragraph")) { ltype = 4; ltype_depth = depth+1; } else if (tmp == "Description") { @@ -1321,85 +1372,27 @@ void Buffer::writeFileAscii(string const & fname, int linelen) /* noindent ? */ /* what about the alignment */ - } - else { + } else { +#ifndef NEW_INSETS /* dummy layout, that means a footnote ended */ footnoteflag = LyXParagraph::NO_FOOTNOTE; ofs << ") "; noparbreak = 1; - } - - LyXLayout const & layout = - textclasslist.Style(params.textclass, - par->GetLayout()); - bool free_spc = layout.free_spacing; - - /* It might be a table */ - if (par->table){ -#if 0 - if (!lyxrc->ascii_roff_command.empty() && - lyxrc->ascii_roff_command != "none") { - RoffAsciiTable(ofs, par); - par = par->next; - continue; - } -#endif - cell = 1; - actcell = 0; - cells = par->table->columns; - clen = new int [cells]; - memset(clen, 0, sizeof(int) * cells); - - for (i = 0, j = 0, h = 1; i < par->size(); ++i, ++h) { - c = par->GetChar(i); - if (c == LyXParagraph::META_INSET) { - if ((inset = par->GetInset(i))) { -#if 1 -#ifdef HAVE_SSTREAM - ostringstream ost; - inset->Latex(ost, -1, free_spc); - h += ost.str().length(); -#else - ostrstream ost; - inset->Latex(ost, -1, free_spc); - ost << '\0'; - char * tmp = ost.str(); - string tstr(tmp); - h += tstr.length(); - delete [] tmp; -#endif #else - ofstream fs(fname1.c_str()); - if (!fs) { - WriteFSAlert(_("Error: Cannot open temporary file:"), fname1); - return; - } - inset->Latex(fs, -1, free_spc); - h += fs.tellp() - 1; - ::remove(fname1.c_str()); + lyxerr << "Should this ever happen?" << endl; #endif - } - } else if (c == LyXParagraph::META_NEWLINE) { - if (clen[j] < h) - clen[j] = h; - h = 0; - j = (++j) % par->table->NumberOfCellsInRow(actcell); - ++actcell; - } - } - if (clen[j] < h) - clen[j] = h; } - font1 = LyXFont(LyXFont::ALL_INHERIT); + LyXFont font1 = + LyXFont(LyXFont::ALL_INHERIT, params.language); actcell = 0; for (i = 0, actpos = 1; i < par->size(); ++i, ++actpos) { if (!i && !footnoteflag && !noparbreak){ ofs << "\n\n"; - for(j = 0; j < depth; ++j) + for (j = 0; j < depth; ++j) ofs << " "; currlinelen = depth * 2; - switch(ltype) { + switch (ltype) { case 0: /* Standard */ case 4: /* (Sub)Paragraph */ case 5: /* Description */ @@ -1418,38 +1411,18 @@ void Buffer::writeFileAscii(string const & fname, int linelen) break; } if (ltype_depth > depth) { - for(j = ltype_depth - 1; j > depth; --j) + for (j = ltype_depth - 1; j > depth; --j) ofs << " "; currlinelen += (ltype_depth-depth)*2; } - if (par->table) { - for(j = 0; j < cells; ++j) { - ofs << '+'; - for(h = 0; h < (clen[j] + 1); - ++h) - ofs << '-'; - } - ofs << "+\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for(j = ltype_depth; - j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth-depth)*2; - } - ofs << "| "; - } } - font2 = par->GetFontSettings(i); + LyXFont font2 = par->GetFontSettings(params, i); if (font1.latex() != font2.latex()) { if (font2.latex() == LyXFont::OFF) islatex = 0; else islatex = 1; - } - else { + } else { islatex = 0; } c = par->GetChar(i); @@ -1459,72 +1432,26 @@ void Buffer::writeFileAscii(string const & fname, int linelen) case LyXParagraph::META_INSET: if ((inset = par->GetInset(i))) { fpos = ofs.tellp(); - inset->Latex(ofs, -1, free_spc); + inset->Ascii(this, ofs); currlinelen += (ofs.tellp() - fpos); actpos += (ofs.tellp() - fpos) - 1; } break; case LyXParagraph::META_NEWLINE: - if (par->table) { - if (par->table->NumberOfCellsInRow(actcell) <= cell) { - for(j = actpos; j < clen[cell - 1]; ++j) - ofs << ' '; - ofs << " |\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth*2; - if (ltype_depth > depth) { - for(j = ltype_depth; j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth-depth) * 2; - } - for(j = 0; j < cells; ++j) { - ofs << '+'; - for(h = 0; h < (clen[j] + 1); ++h) - ofs << '-'; - } - ofs << "+\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for(j = ltype_depth; - j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth-depth)*2; - } - ofs << "| "; - cell = 1; - } else { - for(j = actpos; - j < clen[cell - 1]; ++j) - ofs << ' '; - ofs << " | "; - ++cell; - } - ++actcell; - currlinelen = actpos = 0; - } else { - ofs << "\n"; - for(j = 0; j < depth; ++j) + ofs << "\n"; + for (j = 0; j < depth; ++j) + ofs << " "; + currlinelen = depth * 2; + if (ltype_depth > depth) { + for (j = ltype_depth; + j > depth; --j) ofs << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for(j = ltype_depth; - j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth - depth) * 2; - } + currlinelen += (ltype_depth - depth) * 2; } break; case LyXParagraph::META_HFILL: ofs << "\t"; break; -#if 0 - case LyXParagraph::META_PROTECTED_SEPARATOR: - ofs << " "; - break; -#endif case '\\': ofs << "\\"; break; @@ -1532,11 +1459,11 @@ void Buffer::writeFileAscii(string const & fname, int linelen) if (currlinelen > linelen - 10 && c == ' ' && i + 2 < par->size()) { ofs << "\n"; - for(j = 0; j < depth; ++j) + for (j = 0; j < depth; ++j) ofs << " "; currlinelen = depth * 2; if (ltype_depth > depth) { - for(j = ltype_depth; + for (j = ltype_depth; j > depth; --j) ofs << " "; currlinelen += (ltype_depth-depth)*2; @@ -1549,34 +1476,254 @@ void Buffer::writeFileAscii(string const & fname, int linelen) break; } } - if (par->table) { - for(j = actpos; j < clen[cell - 1]; ++j) - ofs << ' '; - ofs << " |\n"; - for(j = 0; j < depth; ++j) - ofs << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for(j = ltype_depth; j > depth; --j) - ofs << " "; - currlinelen += (ltype_depth - depth) * 2; - } - for(j = 0; j < cells; ++j) { - ofs << '+'; - for(h = 0; h < (clen[j] + 1); ++h) - ofs << '-'; - } - ofs << "+\n"; - delete [] clen; - } par = par->next; } ofs << "\n"; } +//---------------------------------------------------------------------------- +#else +//---------------------------------------------------------------------------- +string const Buffer::asciiParagraph(LyXParagraph const * par, + unsigned int linelen) const +{ + ostringstream buffer; + LyXFont font1; + LyXFont font2; + Inset const * inset; + char c; + LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE; + char depth = 0; + int ltype = 0; + int ltype_depth = 0; + unsigned int currlinelen = 0; + bool ref_printed = false; + + int noparbreak = 0; + int islatex = 0; + if ( +#ifndef NEW_INSETS + par->footnoteflag != LyXParagraph::NO_FOOTNOTE || +#endif + !par->previous +#ifndef NEW_INSETS + || par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE +#endif + ){ +#ifndef NEW_INSETS + /* begins a footnote environment ? */ + if (footnoteflag != par->footnoteflag) { + footnoteflag = par->footnoteflag; + if (footnoteflag) { + size_t const j = strlen(string_footnotekinds[par->footnotekind]) + 4; + if ((linelen > 0) && + ((currlinelen + j) > linelen)) { + buffer << "\n"; + currlinelen = 0; + } + buffer << "([" + << string_footnotekinds[par->footnotekind] + << "] "; + currlinelen += j; + } + } +#endif + /* begins or ends a deeper area ?*/ + if (depth != par->depth) { + if (par->depth > depth) { + while (par->depth > depth) { + ++depth; + } + } + else { + while (par->depth < depth) { + --depth; + } + } + } + + /* First write the layout */ + string const tmp = textclasslist.NameOfLayout(params.textclass, par->layout); + if (tmp == "Itemize") { + ltype = 1; + ltype_depth = depth+1; + } else if (tmp == "Enumerate") { + ltype = 2; + ltype_depth = depth+1; + } else if (strstr(tmp.c_str(), "ection")) { + ltype = 3; + ltype_depth = depth+1; + } else if (strstr(tmp.c_str(), "aragraph")) { + ltype = 4; + ltype_depth = depth+1; + } else if (tmp == "Description") { + ltype = 5; + ltype_depth = depth+1; + } else if (tmp == "Abstract") { + ltype = 6; + ltype_depth = 0; + } else if (tmp == "Bibliography") { + ltype = 7; + ltype_depth = 0; + } else { + ltype = 0; + ltype_depth = 0; + } + + /* maybe some vertical spaces */ + + /* the labelwidthstring used in lists */ + + /* some lines? */ + + /* some pagebreaks? */ + + /* noindent ? */ + + /* what about the alignment */ + } else { +#ifndef NEW_INSETS + /* dummy layout, that means a footnote ended */ + footnoteflag = LyXParagraph::NO_FOOTNOTE; + buffer << ") "; + noparbreak = 1; +#else + lyxerr << "Should this ever happen?" << endl; +#endif + } + + font1 = LyXFont(LyXFont::ALL_INHERIT, params.language); + for (LyXParagraph::size_type i = 0; i < par->size(); ++i) { + if (!i && !footnoteflag && !noparbreak){ + if (linelen > 0) + buffer << "\n\n"; + for (char j = 0; j < depth; ++j) + buffer << " "; + currlinelen = depth * 2; + switch (ltype) { + case 0: /* Standard */ + case 4: /* (Sub)Paragraph */ + case 5: /* Description */ + break; + case 6: /* Abstract */ + if (linelen > 0) + buffer << "Abstract\n\n"; + else + buffer << "Abstract: "; + break; + case 7: /* Bibliography */ + if (!ref_printed) { + if (linelen > 0) + buffer << "References\n\n"; + else + buffer << "References: "; + ref_printed = true; + } + break; + default: + buffer << par->labelstring << " "; + break; + } + if (ltype_depth > depth) { + for (char j = ltype_depth - 1; j > depth; --j) + buffer << " "; + currlinelen += (ltype_depth-depth)*2; + } + } + font2 = par->GetFontSettings(params, i); + if (font1.latex() != font2.latex()) { + if (font2.latex() == LyXFont::OFF) + islatex = 0; + else + islatex = 1; + } else { + islatex = 0; + } + c = par->GetChar(i); + if (islatex) + continue; + switch (c) { + case LyXParagraph::META_INSET: + if ((inset = par->GetInset(i))) { + if (!inset->Ascii(this, buffer)) { + string dummy; + string s = rsplit(buffer.str().c_str(), + dummy, '\n'); + currlinelen += s.length(); + } else { + // to be sure it breaks paragraph + currlinelen += linelen; + } + } + break; + case LyXParagraph::META_NEWLINE: + if (linelen > 0) { + buffer << "\n"; + for (char j = 0; j < depth; ++j) + buffer << " "; + } + currlinelen = depth * 2; + if (ltype_depth > depth) { + for (char j = ltype_depth; + j > depth; --j) + buffer << " "; + currlinelen += (ltype_depth - depth) * 2; + } + break; + case LyXParagraph::META_HFILL: + buffer << "\t"; + break; + case '\\': + buffer << "\\"; + break; + default: + if ((linelen > 0) && (currlinelen > (linelen - 10)) && + (c == ' ') && ((i + 2) < par->size())) + { + buffer << "\n"; + for (char j = 0; j < depth; ++j) + buffer << " "; + currlinelen = depth * 2; + if (ltype_depth > depth) { + for (char j = ltype_depth; + j > depth; --j) + buffer << " "; + currlinelen += (ltype_depth-depth)*2; + } + } else if (c != '\0') + buffer << c; + else if (c == '\0') + lyxerr.debug() << "writeAsciiFile: NULL char in structure." << endl; + ++currlinelen; + break; + } + } + return buffer.str().c_str(); +} + + +void Buffer::writeFileAscii(string const & fname, int linelen) +{ + ofstream ofs(fname.c_str()); + if (!ofs) { + WriteFSAlert(_("Error: Cannot write file:"), fname); + return; + } + writeFileAscii(ofs, linelen); +} -#ifdef USE_OSTREAM_ONLY +void Buffer::writeFileAscii(ostream & ofs, int linelen) +{ + LyXParagraph * par = paragraph; + while (par) { + ofs << asciiParagraph(par, linelen); + par = par->next; + } + ofs << "\n"; +} +#endif + void Buffer::makeLaTeXFile(string const & fname, string const & original_path, bool nice, bool only_body) @@ -1585,7 +1732,7 @@ void Buffer::makeLaTeXFile(string const & fname, niceFile = nice; // this will be used by Insetincludes. - tex_code_break_column = lyxrc->ascii_linelen; + tex_code_break_column = lyxrc.ascii_linelen; LyXTextClass const & tclass = textclasslist.TextClass(params.textclass); @@ -1598,7 +1745,7 @@ void Buffer::makeLaTeXFile(string const & fname, // validate the buffer. lyxerr[Debug::LATEX] << " Validating buffer..." << endl; - LaTeXFeatures features(tclass.numLayouts()); + LaTeXFeatures features(params, tclass.numLayouts()); validate(features); lyxerr[Debug::LATEX] << " Buffer validation done." << endl; @@ -1646,7 +1793,8 @@ void Buffer::makeLaTeXFile(string const & fname, string options; // the document class options. - if (tokenPos(tclass.opt_fontsize(), '|', params.fontsize) >= 0) { + if (tokenPos(tclass.opt_fontsize(), + '|', params.fontsize) >= 0) { // only write if existing in list (and not default) options += params.fontsize; options += "pt,"; @@ -1702,15 +1850,23 @@ void Buffer::makeLaTeXFile(string const & fname, && params.orientation == BufferParams::ORIENTATION_LANDSCAPE) options += "landscape,"; - // language should be a parameter to \documentclass - if (params.language != "default") { - if (params.language == "hebrew") - options += "english,"; - else if (lyxrc->rtl_support) - options += "hebrew,"; - options += params.language + ','; - } else if (lyxrc->rtl_support) - options += "hebrew,english,"; + // language should be a parameter to \documentclass + bool use_babel = false; + if (params.language->babel() == "hebrew") // This seems necessary + features.UsedLanguages.insert(default_language); +#ifdef DO_USE_DEFAULT_LANGUAGE + if (params.language->lang() != "default" || + !features.UsedLanguages.empty()) { +#endif + use_babel = true; + for (LaTeXFeatures::LanguageList::const_iterator cit = + features.UsedLanguages.begin(); + cit != features.UsedLanguages.end(); ++cit) + options += (*cit)->babel() + ","; + options += params.language->babel() + ','; +#ifdef DO_USE_DEFAULT_LANGUAGE + } +#endif // the user-defined options if (!params.options.empty()) { @@ -1734,18 +1890,37 @@ void Buffer::makeLaTeXFile(string const & fname, texrow.newline(); } // this one is not per buffer - if (lyxrc->fontenc != "default") { - ofs << "\\usepackage[" << lyxrc->fontenc + if (lyxrc.fontenc != "default") { + ofs << "\\usepackage[" << lyxrc.fontenc << "]{fontenc}\n"; texrow.newline(); } - if (params.inputenc != "default") { + + if (params.inputenc == "auto") { + string const doc_encoding = + params.language->encoding()->LatexName(); + + // Create a list with all the input encodings used + // in the document + set encodings; + for (LaTeXFeatures::LanguageList::const_iterator it = + features.UsedLanguages.begin(); + it != features.UsedLanguages.end(); ++it) + if ((*it)->encoding()->LatexName() != doc_encoding) + encodings.insert((*it)->encoding()->LatexName()); + + ofs << "\\usepackage["; + std::copy(encodings.begin(), encodings.end(), + std::ostream_iterator(ofs, ",")); + ofs << doc_encoding << "]{inputenc}\n"; + texrow.newline(); + } else if (params.inputenc != "default") { ofs << "\\usepackage[" << params.inputenc << "]{inputenc}\n"; texrow.newline(); } - - /* at the very beginning the text parameters */ + + // At the very beginning the text parameters. if (params.paperpackage != BufferParams::PACKAGE_NONE) { switch (params.paperpackage) { case BufferParams::PACKAGE_A4: @@ -1806,7 +1981,7 @@ void Buffer::makeLaTeXFile(string const & fname, break; default: // default papersize ie BufferParams::VM_PAPER_DEFAULT - switch (lyxrc->default_papersize) { + switch (lyxrc.default_papersize) { case BufferParams::PAPER_DEFAULT: // keep compiler happy case BufferParams::PAPER_USLETTER: ofs << ",letterpaper"; @@ -1849,12 +2024,13 @@ void Buffer::makeLaTeXFile(string const & fname, texrow.newline(); } if (params.use_amsmath - && !prefixIs(textclasslist.LatexnameOfClass(params.textclass), "ams")) { + && !tclass.provides(LyXTextClass::amsmath)) { ofs << "\\usepackage{amsmath}\n"; texrow.newline(); } - if (tokenPos(tclass.opt_pagestyle(), '|', params.pagestyle) >= 0) { + if (tokenPos(tclass.opt_pagestyle(), + '|', params.pagestyle) >= 0) { if (params.pagestyle == "fancy") { ofs << "\\usepackage{fancyhdr}\n"; texrow.newline(); @@ -1865,8 +2041,8 @@ void Buffer::makeLaTeXFile(string const & fname, // We try to load babel late, in case it interferes // with other packages. - if (params.language != "default" || lyxrc->rtl_support ) { - ofs << "\\usepackage{babel}\n"; + if (use_babel) { + ofs << lyxrc.language_package << endl; texrow.newline(); } @@ -1910,16 +2086,15 @@ void Buffer::makeLaTeXFile(string const & fname, } // Now insert the LyX specific LaTeX commands... - string preamble, tmppreamble; // The optional packages; - preamble = features.getPackages(params); + string preamble(features.getPackages()); // this might be useful... - preamble += "\n\\makeatletter\n\n"; + preamble += "\n\\makeatletter\n"; // Some macros LyX will need - tmppreamble = features.getMacros(params); + string tmppreamble(features.getMacros()); if (!tmppreamble.empty()) { preamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " @@ -1928,7 +2103,7 @@ void Buffer::makeLaTeXFile(string const & fname, } // the text class specific preamble - tmppreamble = features.getTClassPreamble(params); + tmppreamble = features.getTClassPreamble(); if (!tmppreamble.empty()) { preamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " "Textclass specific LaTeX commands.\n" @@ -1942,7 +2117,7 @@ void Buffer::makeLaTeXFile(string const & fname, + params.preamble + '\n'; } - preamble += "\\makeatother\n\n"; + preamble += "\\makeatother\n"; // Itemize bullet settings need to be last in case the user // defines their own bullets that use a package included @@ -1986,44 +2161,92 @@ void Buffer::makeLaTeXFile(string const & fname, ofs << preamble; // make the body. - ofs << "\\begin{document}\n\n"; - texrow.newline(); + ofs << "\\begin{document}\n"; texrow.newline(); } // only_body lyxerr.debug() << "preamble finished, now the body." << endl; +#ifdef DO_USE_DEFAULT_LANGUAGE + if (!lyxrc.language_auto_begin && params.language->lang() != "default") { +#else + if (!lyxrc.language_auto_begin) { +#endif + ofs << subst(lyxrc.language_command_begin, "$$lang", + params.language->babel()) + << endl; + texrow.newline(); + } - bool was_title = false; - bool already_title = false; -#ifdef HAVE_SSTREAM - ostringstream ftnote; + latexParagraphs(ofs, paragraph, 0, texrow); + + // add this just in case after all the paragraphs + ofs << endl; + texrow.newline(); + +#ifdef DO_USE_DEFAULT_LANGUAGE + if (!lyxrc.language_auto_end && params.language->lang() != "default") { #else - char * tmpholder = 0; + if (!lyxrc.language_auto_end) { #endif + ofs << subst(lyxrc.language_command_end, "$$lang", + params.language->babel()) + << endl; + texrow.newline(); + } + + if (!only_body) { + ofs << "\\end{document}\n"; + texrow.newline(); + + lyxerr[Debug::LATEX] << "makeLaTeXFile...done" << endl; + } else { + lyxerr[Debug::LATEX] << "LaTeXFile for inclusion made." + << endl; + } + + // Just to be sure. (Asger) + texrow.newline(); + + // tex_code_break_column's value is used to decide + // if we are in batchmode or not (within mathed_write() + // in math_write.C) so we must set it to a non-zero + // value when we leave otherwise we save incorrect .lyx files. + tex_code_break_column = lyxrc.ascii_linelen; + + ofs.close(); + if (ofs.fail()) { + lyxerr << "File was not closed properly." << endl; + } + + lyxerr.debug() << "Finished making latex file." << endl; +} + + +// +// LaTeX all paragraphs from par to endpar, if endpar == 0 then to the end +// +void Buffer::latexParagraphs(ostream & ofs, LyXParagraph * par, + LyXParagraph * endpar, TexRow & texrow) const +{ + bool was_title = false; + bool already_title = false; + std::ostringstream ftnote; TexRow ft_texrow; int ftcount = 0; - LyXParagraph * par = paragraph; - // if only_body - while (par) { -#ifndef HAVE_SSTREAM - ostrstream ftnote; - if (tmpholder) { - ftnote << tmpholder; - delete [] tmpholder; - tmpholder = 0; - } -#endif + while (par != endpar) { +#ifndef NEW_INSETS if (par->IsDummy()) - lyxerr[Debug::LATEX] << "Error in MakeLateXFile." + lyxerr[Debug::LATEX] << "Error in latexParagraphs." << endl; +#endif LyXLayout const & layout = textclasslist.Style(params.textclass, par->layout); if (layout.intitle) { if (already_title) { - lyxerr <<"Error in MakeLatexFile: You" + lyxerr <<"Error in latexParagraphs: You" " should not mix title layouts" " with normal ones." << endl; } else @@ -2040,11 +2263,18 @@ void Buffer::makeLaTeXFile(string const & fname, ftcount = -1; if (layout.isEnvironment() || par->pextra_type != LyXParagraph::PEXTRA_NONE) { - par = par->TeXEnvironment(ofs, texrow, - ftnote, ft_texrow, ftcount); + par = par->TeXEnvironment(this, params, ofs, texrow +#ifndef NEW_INSETS + ,ftnote, ft_texrow, ftcount +#endif + ); } else { - par = par->TeXOnePar(ofs, texrow, - ftnote, ft_texrow, ftcount); + par = par->TeXOnePar(this, params, ofs, texrow, false +#ifndef NEW_INSETS + , + ftnote, ft_texrow, ftcount +#endif + ); } // Write out what we've generated... @@ -2056,706 +2286,159 @@ void Buffer::makeLaTeXFile(string const & fname, } ofs << ftnote.str(); texrow += ft_texrow; -#ifdef HAVE_SSTREAM + // The extra .c_str() is needed when we use // lyxstring instead of the STL string class. ftnote.str(string().c_str()); -#else - delete [] ftnote.str(); -#endif ft_texrow.reset(); ftcount = 0; } -#ifndef HAVE_SSTREAM - else { - // I hate strstreams - tmpholder = ftnote.str(); - } -#endif } -#ifndef HAVE_SSTREAM - delete [] tmpholder; -#endif // It might be that we only have a title in this document if (was_title && !already_title) { ofs << "\\maketitle\n"; texrow.newline(); } +} - if (!only_body) { - ofs << "\\end{document}\n"; - texrow.newline(); - - lyxerr[Debug::LATEX] << "makeLaTeXFile...done" << endl; - } else { - lyxerr[Debug::LATEX] << "LaTeXFile for inclusion made." - << endl; - } - // Just to be sure. (Asger) - texrow.newline(); +bool Buffer::isLatex() const +{ + return textclasslist.TextClass(params.textclass).outputType() == LATEX; +} - // tex_code_break_column's value is used to decide - // if we are in batchmode or not (within mathed_write() - // in math_write.C) so we must set it to a non-zero - // value when we leave otherwise we save incorrect .lyx files. - tex_code_break_column = lyxrc->ascii_linelen; - ofs.close(); - if (ofs.fail()) { - lyxerr << "File was not closed properly." << endl; - } - - lyxerr.debug() << "Finished making latex file." << endl; +bool Buffer::isLinuxDoc() const +{ + return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC; } -#else -void Buffer::makeLaTeXFile(string const & fname, - string const & original_path, - bool nice, bool only_body) + + +bool Buffer::isLiterate() const { - lyxerr[Debug::LATEX] << "makeLaTeXFile..." << endl; - + return textclasslist.TextClass(params.textclass).outputType() == LITERATE; +} + + +bool Buffer::isDocBook() const +{ + return textclasslist.TextClass(params.textclass).outputType() == DOCBOOK; +} + + +bool Buffer::isSGML() const +{ + return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC || + textclasslist.TextClass(params.textclass).outputType() == DOCBOOK; +} + + +void Buffer::sgmlOpenTag(ostream & os, int depth, + string const & latexname) const +{ + os << string(depth, ' ') << "<" << latexname << ">\n"; +} + + +void Buffer::sgmlCloseTag(ostream & os, int depth, + string const & latexname) const +{ + os << string(depth, ' ') << "\n"; +} + + +void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) +{ + LyXParagraph * par = paragraph; + niceFile = nice; // this will be used by Insetincludes. - tex_code_break_column = lyxrc->ascii_linelen; + string top_element = textclasslist.LatexnameOfClass(params.textclass); + string environment_stack[10]; + string item_name; - LyXTextClass const & tclass = - textclasslist.TextClass(params.textclass); + int depth = 0; // paragraph depth ofstream ofs(fname.c_str()); + if (!ofs) { - WriteFSAlert(_("Error: Cannot open file: "), fname); + WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname); return; } - - // validate the buffer. - lyxerr[Debug::LATEX] << " Validating buffer..." << endl; - LaTeXFeatures features(tclass.numLayouts()); - validate(features); - lyxerr[Debug::LATEX] << " Buffer validation done." << endl; - - texrow.reset(); - // The starting paragraph of the coming rows is the - // first paragraph of the document. (Asger) - texrow.start(paragraph, 0); - - string LFile; - - if (!only_body && nice) { - LFile += "%% " LYX_DOCVERSION " created this file. " - "For more info, see http://www.lyx.org/.\n"; - LFile += "%% Do not edit unless you really know what you are doing.\n"; - texrow.newline(); - texrow.newline(); - } - lyxerr.debug() << "lyx header finished" << endl; - // There are a few differences between nice LaTeX and usual files: - // usual is \batchmode and has a - // special input@path to allow the including of figures - // with either \input or \includegraphics (what figinsets do). - // batchmode is not set if there is a tex_code_break_column. - // In this case somebody is interested in the generated LaTeX, - // so this is OK. input@path is set when the actual parameter - // original_path is set. This is done for usual tex-file, but not - // for nice-latex-file. (Matthias 250696) - if (!only_body) { - if (!nice){ - // code for usual, NOT nice-latex-file - LFile += "\\batchmode\n"; // changed - // from \nonstopmode - texrow.newline(); - } - if (!original_path.empty()) { - LFile += "\\makeatletter\n"; - texrow.newline(); - LFile += "\\def\\input@path{{" + original_path - + "/}}\n"; - texrow.newline(); - LFile += "\\makeatother\n"; - texrow.newline(); - } - - LFile += "\\documentclass"; - - string options; // the document class options. - - if (tokenPos(tclass.opt_fontsize(), '|', params.fontsize) >= 0) { - // only write if existing in list (and not default) - options += params.fontsize; - options += "pt,"; - } - - - if (!params.use_geometry && - (params.paperpackage == BufferParams::PACKAGE_NONE)) { - switch (params.papersize) { - case BufferParams::PAPER_A4PAPER: - options += "a4paper,"; - break; - case BufferParams::PAPER_USLETTER: - options += "letterpaper,"; - break; - case BufferParams::PAPER_A5PAPER: - options += "a5paper,"; - break; - case BufferParams::PAPER_B5PAPER: - options += "b5paper,"; - break; - case BufferParams::PAPER_EXECUTIVEPAPER: - options += "executivepaper,"; - break; - case BufferParams::PAPER_LEGALPAPER: - options += "legalpaper,"; - break; - } - } - - // if needed - if (params.sides != tclass.sides()) { - switch (params.sides) { - case LyXTextClass::OneSide: - options += "oneside,"; - break; - case LyXTextClass::TwoSides: - options += "twoside,"; - break; - } - - } - - // if needed - if (params.columns != tclass.columns()) { - if (params.columns == 2) - options += "twocolumn,"; - else - options += "onecolumn,"; - } - - if (!params.use_geometry - && params.orientation == BufferParams::ORIENTATION_LANDSCAPE) - options += "landscape,"; - - // language should be a parameter to \documentclass - if (params.language != "default") { - if (params.language == "hebrew") - options += "english,"; - else if (lyxrc->rtl_support) - options += "hebrew,"; - options += params.language + ','; - } else if (lyxrc->rtl_support) - options += "hebrew,english,"; - - // the user-defined options - if (!params.options.empty()) { - options += params.options + ','; - } - - if (!options.empty()){ - options = strip(options, ','); - LFile += '['; - LFile += options; - LFile += ']'; - } - - LFile += '{'; - LFile += textclasslist.LatexnameOfClass(params.textclass); - LFile += "}\n"; - texrow.newline(); - // end of \documentclass defs - - // font selection must be done before loading fontenc.sty - if (params.fonts != "default") { - LFile += "\\usepackage{" + params.fonts + "}\n"; - texrow.newline(); - } - // this one is not per buffer - if (lyxrc->fontenc != "default") { - LFile += "\\usepackage[" + lyxrc->fontenc - + "]{fontenc}\n"; - texrow.newline(); - } - if (params.inputenc != "default") { - LFile += "\\usepackage[" + params.inputenc - + "]{inputenc}\n"; - texrow.newline(); - } - - /* at the very beginning the text parameters */ - if (params.paperpackage != BufferParams::PACKAGE_NONE) { - switch (params.paperpackage) { - case BufferParams::PACKAGE_A4: - LFile += "\\usepackage{a4}\n"; - texrow.newline(); - break; - case BufferParams::PACKAGE_A4WIDE: - LFile += "\\usepackage{a4wide}\n"; - texrow.newline(); - break; - case BufferParams::PACKAGE_WIDEMARGINSA4: - LFile += "\\usepackage[widemargins]{a4}\n"; - texrow.newline(); - break; - } - } - if (params.use_geometry) { - LFile += "\\usepackage{geometry}\n"; - texrow.newline(); - LFile += "\\geometry{verbose"; - if (params.orientation == BufferParams::ORIENTATION_LANDSCAPE) - LFile += ",landscape"; - switch (params.papersize2) { - case BufferParams::VM_PAPER_CUSTOM: - if (!params.paperwidth.empty()) - LFile += ",paperwidth=" - + params.paperwidth; - if (!params.paperheight.empty()) - LFile += ",paperheight=" - + params.paperheight; - break; - case BufferParams::VM_PAPER_USLETTER: - LFile += ",letterpaper"; - break; - case BufferParams::VM_PAPER_USLEGAL: - LFile += ",legalpaper"; - break; - case BufferParams::VM_PAPER_USEXECUTIVE: - LFile += ",executivepaper"; - break; - case BufferParams::VM_PAPER_A3: - LFile += ",a3paper"; - break; - case BufferParams::VM_PAPER_A4: - LFile += ",a4paper"; - break; - case BufferParams::VM_PAPER_A5: - LFile += ",a5paper"; - break; - case BufferParams::VM_PAPER_B3: - LFile += ",b3paper"; - break; - case BufferParams::VM_PAPER_B4: - LFile += ",b4paper"; - break; - case BufferParams::VM_PAPER_B5: - LFile += ",b5paper"; - break; - default: - // default papersize ie BufferParams::VM_PAPER_DEFAULT - switch (lyxrc->default_papersize) { - case BufferParams::PAPER_DEFAULT: // keep compiler happy - case BufferParams::PAPER_USLETTER: - LFile += ",letterpaper"; - break; - case BufferParams::PAPER_LEGALPAPER: - LFile += ",legalpaper"; - break; - case BufferParams::PAPER_EXECUTIVEPAPER: - LFile += ",executivepaper"; - break; - case BufferParams::PAPER_A3PAPER: - LFile += ",a3paper"; - break; - case BufferParams::PAPER_A4PAPER: - LFile += ",a4paper"; - break; - case BufferParams::PAPER_A5PAPER: - LFile += ",a5paper"; - break; - case BufferParams::PAPER_B5PAPER: - LFile += ",b5paper"; - break; - } - } - if (!params.topmargin.empty()) - LFile += ",tmargin=" + params.topmargin; - if (!params.bottommargin.empty()) - LFile += ",bmargin=" + params.bottommargin; - if (!params.leftmargin.empty()) - LFile += ",lmargin=" + params.leftmargin; - if (!params.rightmargin.empty()) - LFile += ",rmargin=" + params.rightmargin; - if (!params.headheight.empty()) - LFile += ",headheight=" + params.headheight; - if (!params.headsep.empty()) - LFile += ",headsep=" + params.headsep; - if (!params.footskip.empty()) - LFile += ",footskip=" + params.footskip; - LFile += "}\n"; - texrow.newline(); - } - if (params.use_amsmath - && !prefixIs(textclasslist.LatexnameOfClass(params.textclass), "ams")) { - LFile += "\\usepackage{amsmath}\n"; - } - - if (tokenPos(tclass.opt_pagestyle(), '|', params.pagestyle) >= 0) { - if (params.pagestyle == "fancy") { - LFile += "\\usepackage{fancyhdr}\n"; - texrow.newline(); - } - LFile += "\\pagestyle{" + params.pagestyle + "}\n"; - texrow.newline(); - } - - // We try to load babel late, in case it interferes - // with other packages. - if (params.language != "default" || lyxrc->rtl_support ) { - LFile += "\\usepackage{babel}\n"; - texrow.newline(); - } - - if (params.secnumdepth != tclass.secnumdepth()) { - LFile += "\\setcounter{secnumdepth}{"; - LFile += tostr(params.secnumdepth); - LFile += "}\n"; - texrow.newline(); - } - if (params.tocdepth != tclass.tocdepth()) { - LFile += "\\setcounter{tocdepth}{"; - LFile += tostr(params.tocdepth); - LFile += "}\n"; - texrow.newline(); - } - - if (params.paragraph_separation) { - switch (params.defskip.kind()) { - case VSpace::SMALLSKIP: - LFile += "\\setlength\\parskip{\\smallskipamount}\n"; - break; - case VSpace::MEDSKIP: - LFile += "\\setlength\\parskip{\\medskipamount}\n"; - break; - case VSpace::BIGSKIP: - LFile += "\\setlength\\parskip{\\bigskipamount}\n"; - break; - case VSpace::LENGTH: - LFile += "\\setlength\\parskip{" - + params.defskip.length().asLatexString() - + "}\n"; - break; - default: // should never happen // Then delete it. - LFile += "\\setlength\\parskip{\\medskipamount}\n"; - break; - } - texrow.newline(); - - LFile += "\\setlength\\parindent{0pt}\n"; - texrow.newline(); - } - - // Write out what we've generated so far...and reset LFile - ofs << LFile; - LFile.clear(); - - // Now insert the LyX specific LaTeX commands... - string preamble, tmppreamble; - - // The optional packages; - preamble = features.getPackages(params); - - // this might be useful... - preamble += "\n\\makeatletter\n\n"; - - // Some macros LyX will need - tmppreamble = features.getMacros(params); - - if (!tmppreamble.empty()) { - preamble += "\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " - "LyX specific LaTeX commands.\n" - + tmppreamble + '\n'; - } - - // the text class specific preamble - tmppreamble = features.getTClassPreamble(params); - if (!tmppreamble.empty()) { - preamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " - "Textclass specific LaTeX commands.\n" - + tmppreamble + '\n'; - } - - /* the user-defined preamble */ - if (!params.preamble.empty()) { - preamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% " - "User specified LaTeX commands.\n" - + params.preamble + '\n'; - } - - preamble += "\\makeatother\n\n"; - - // Itemize bullet settings need to be last in case the user - // defines their own bullets that use a package included - // in the user-defined preamble -- ARRae - // Actually it has to be done much later than that - // since some packages like frenchb make modifications - // at \begin{document} time -- JMarc - string bullets_def; - for (int i = 0; i < 4; ++i) { - if (params.user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) { - if (bullets_def.empty()) - bullets_def="\\AtBeginDocument{\n"; - bullets_def += " \\renewcommand{\\labelitemi"; - switch (i) { - // `i' is one less than the item to modify - case 0: - break; - case 1: - bullets_def += 'i'; - break; - case 2: - bullets_def += "ii"; - break; - case 3: - bullets_def += 'v'; - break; - } - bullets_def += "}{" + - params.user_defined_bullets[i].getText() - + "}\n"; - } - } - - if (!bullets_def.empty()) - preamble += bullets_def + "}\n\n"; - - for (int j = countChar(preamble, '\n'); j-- ;) { - texrow.newline(); - } - - ofs << preamble; - - // make the body. - LFile += "\\begin{document}\n\n"; - texrow.newline(); - texrow.newline(); - } // only_body - lyxerr.debug() << "preamble finished, now the body." << endl; - - bool was_title = false; - bool already_title = false; - string ftnote; - TexRow ft_texrow; - int ftcount = 0; - int loop_count = 0; - - LyXParagraph * par = paragraph; - - // if only_body - while (par) { - ++loop_count; - if (par->IsDummy()) - lyxerr[Debug::LATEX] << "Error in MakeLateXFile." - << endl; - LyXLayout const & layout = - textclasslist.Style(params.textclass, - par->layout); - - if (layout.intitle) { - if (already_title) { - lyxerr <<"Error in MakeLatexFile: You" - " should not mix title layouts" - " with normal ones." << endl; - } else - was_title = true; - } else if (was_title && !already_title) { - LFile += "\\maketitle\n"; - texrow.newline(); - already_title = true; - was_title = false; - } - // We are at depth 0 so we can just use - // ordinary \footnote{} generation - // flag this with ftcount - ftcount = -1; - if (layout.isEnvironment() - || par->pextra_type != LyXParagraph::PEXTRA_NONE) { - par = par->TeXEnvironment(LFile, texrow, - ftnote, ft_texrow, ftcount); - } else { - par = par->TeXOnePar(LFile, texrow, - ftnote, ft_texrow, ftcount); - } - - // Write out what we've generated...and reset LFile - if (ftcount >= 1) { - if (ftcount > 1) { - LFile += "\\addtocounter{footnote}{-"; - LFile += tostr(ftcount - 1); - LFile += '}'; - } - LFile += ftnote; - texrow += ft_texrow; - ftnote.clear(); - ft_texrow.reset(); - ftcount = 0; - } - if (loop_count == 2) { - // fwrite()ing every second time through the loop - // gains a few extra % of speed; going higher than - // 2 will slow things down again. I'll look at - // LFile.length() in a future revision. ARRae - ofs << LFile; - LFile.clear(); - loop_count = 0; - } - } - - // It might be that we only have a title in this document - if (was_title && !already_title) { - LFile += "\\maketitle\n"; - texrow.newline(); - } - - if (!only_body) { - LFile += "\\end{document}\n"; - texrow.newline(); - - lyxerr[Debug::LATEX] << "makeLaTeXFile...done" << endl; - } else { - lyxerr[Debug::LATEX] << "LaTeXFile for inclusion made." - << endl; - } - - // Just to be sure. (Asger) - texrow.newline(); - - // Write out what we've generated...and reset LFile - ofs << LFile; - LFile.clear(); - - // tex_code_break_column's value is used to decide - // if we are in batchmode or not (within mathed_write() - // in math_write.C) so we must set it to a non-zero - // value when we leave otherwise we save incorrect .lyx files. - tex_code_break_column = lyxrc->ascii_linelen; - - // How to check if the close went ok when using fstreams - ofs.close(); - lyxerr.debug() << "Finished making latex file." << endl; -} -#endif - - -bool Buffer::isLatex() const -{ - return textclasslist.TextClass(params.textclass).outputType() == LATEX; -} - - -bool Buffer::isLinuxDoc() const -{ - return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC; -} - - -bool Buffer::isLiterate() const -{ - return textclasslist.TextClass(params.textclass).outputType() == LITERATE; -} - - -bool Buffer::isDocBook() const -{ - return textclasslist.TextClass(params.textclass).outputType() == DOCBOOK; -} - - -bool Buffer::isSGML() const -{ - return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC || - textclasslist.TextClass(params.textclass).outputType() == DOCBOOK; -} - -void Buffer::sgmlOpenTag(ostream & os, int depth, - string const & latexname) const -{ - os << string(depth, ' ') << "<" << latexname << ">\n"; -} - - -void Buffer::sgmlCloseTag(ostream & os, int depth, - string const & latexname) const -{ - os << string(depth, ' ') << "\n"; -} + LyXTextClass const & tclass = + textclasslist.TextClass(params.textclass); + LaTeXFeatures features(params, tclass.numLayouts()); + validate(features); -void Buffer::makeLinuxDocFile(string const & fname, int column) -{ - LyXParagraph * par = paragraph; + //if (nice) + tex_code_break_column = lyxrc.ascii_linelen; + //else + //tex_code_break_column = 0; - string top_element = textclasslist.LatexnameOfClass(params.textclass); - string environment_stack[10]; - string item_name; + texrow.reset(); - int depth = 0; /* paragraph depth */ + if (!body_only) { + string sgml_includedfiles=features.getIncludedFiles(); - ofstream ofs(fname.c_str()); + if (params.preamble.empty() && sgml_includedfiles.empty()) { + ofs << "\n\n"; + } else { + ofs << "\n\n"; + } - if (!ofs) { - WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname); - return; - } - - tex_code_break_column = column; - texrow.reset(); - - if (params.preamble.empty()) { - ofs << "\n\n"; - } - else { - ofs << "\n\n"; + if (params.options.empty()) + sgmlOpenTag(ofs, 0, top_element); + else { + string top = top_element; + top += " "; + top += params.options; + sgmlOpenTag(ofs, 0, top); + } } ofs << "\n"; - if(params.options.empty()) - sgmlOpenTag(ofs, 0, top_element); - else { - string top = top_element; - top += " "; - top += params.options; - sgmlOpenTag(ofs, 0, top); - } - while (par) { - int desc_on = 0; /* description mode*/ + int desc_on = 0; // description mode LyXLayout const & style = - textclasslist.Style(users->buffer()->params.textclass, + textclasslist.Style(params.textclass, par->layout); - par->AutoDeleteInsets(); - /* treat as a special case for compatibility with old code */ + // treat as a special case for compatibility with old code if (par->GetChar(0) == LyXParagraph::META_INSET) { Inset * inset = par->GetInset(0); - char lyx_code = inset->LyxCode(); + Inset::Code lyx_code = inset->LyxCode(); if (lyx_code == Inset::TOC_CODE){ - string temp = "toc"; + string const temp = "toc"; sgmlOpenTag(ofs, depth, temp); par = par->next; +#ifndef NEW_INSETS linuxDocHandleFootnote(ofs, par, depth); +#endif continue; } } // environment tag closing - for( ; depth > par->depth; --depth) { + for (; depth > par->depth; --depth) { sgmlCloseTag(ofs, depth, environment_stack[depth]); - environment_stack[depth].clear(); + environment_stack[depth].erase(); } // write opening SGML tags - switch(style.latextype) { + switch (style.latextype) { case LATEX_PARAGRAPH: - if(depth == par->depth + if (depth == par->depth && !environment_stack[depth].empty()) { sgmlCloseTag(ofs, depth, environment_stack[depth]); - environment_stack[depth].clear(); - if(depth) + environment_stack[depth].erase(); + if (depth) --depth; else ofs << "

"; @@ -2765,7 +2448,9 @@ void Buffer::makeLinuxDocFile(string const & fname, int column) case LATEX_COMMAND: if (depth!= 0) - LinuxDocError(par, 0, _("Error : Wrong depth for LatexType Command.\n")); + LinuxDocError(par, 0, + _("Error : Wrong depth for" + " LatexType Command.\n")); if (!environment_stack[depth].empty()){ sgmlCloseTag(ofs, depth, @@ -2773,37 +2458,38 @@ void Buffer::makeLinuxDocFile(string const & fname, int column) ofs << "

"; } - environment_stack[depth].clear(); + environment_stack[depth].erase(); sgmlOpenTag(ofs, depth, style.latexname()); break; case LATEX_ENVIRONMENT: case LATEX_ITEM_ENVIRONMENT: - if(depth == par->depth + if (depth == par->depth && environment_stack[depth] != style.latexname() && !environment_stack[depth].empty()) { sgmlCloseTag(ofs, depth, environment_stack[depth]); - environment_stack[depth].clear(); + environment_stack[depth].erase(); } if (depth < par->depth) { depth = par->depth; - environment_stack[depth].clear(); + environment_stack[depth].erase(); } if (environment_stack[depth] != style.latexname()) { - if(depth == 0) { - string temp = "p"; + if (depth == 0) { + string const temp = "p"; sgmlOpenTag(ofs, depth, temp); } environment_stack[depth] = style.latexname(); - sgmlOpenTag(ofs, depth, environment_stack[depth]); + sgmlOpenTag(ofs, depth, + environment_stack[depth]); } - if(style.latextype == LATEX_ENVIRONMENT) break; + if (style.latextype == LATEX_ENVIRONMENT) break; desc_on = (style.labeltype == LABEL_MANUAL); - if(desc_on) + if (desc_on) item_name = "tag"; else item_name = "item"; @@ -2815,17 +2501,21 @@ void Buffer::makeLinuxDocFile(string const & fname, int column) break; } +#ifndef NEW_INSETS do { +#endif SimpleLinuxDocOnePar(ofs, par, desc_on, depth); par = par->next; +#ifndef NEW_INSETS linuxDocHandleFootnote(ofs, par, depth); } while(par && par->IsDummy()); +#endif ofs << "\n"; - /* write closing SGML tags */ - switch(style.latextype) { + // write closing SGML tags + switch (style.latextype) { case LATEX_COMMAND: case LATEX_ENVIRONMENT: case LATEX_ITEM_ENVIRONMENT: @@ -2836,25 +2526,28 @@ void Buffer::makeLinuxDocFile(string const & fname, int column) } } - /* Close open tags */ - for(; depth > 0; --depth) + // Close open tags + for (; depth > 0; --depth) sgmlCloseTag(ofs, depth, environment_stack[depth]); - if(!environment_stack[depth].empty()) + if (!environment_stack[depth].empty()) sgmlCloseTag(ofs, depth, environment_stack[depth]); - ofs << "\n\n"; - sgmlCloseTag(ofs, 0, top_element); + if (!body_only) { + ofs << "\n\n"; + sgmlCloseTag(ofs, 0, top_element); + } ofs.close(); // How to check for successful close } +#ifndef NEW_INSETS void Buffer::linuxDocHandleFootnote(ostream & os, LyXParagraph * & par, - int const depth) + int depth) { - string tag = "footnote"; + string const tag = "footnote"; while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { sgmlOpenTag(os, depth + 1, tag); @@ -2863,45 +2556,38 @@ void Buffer::linuxDocHandleFootnote(ostream & os, LyXParagraph * & par, par = par->next; } } +#endif void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag, - int const depth, int desc_on, + int depth, int desc_on, LyXParagraph * & par) { LyXParagraph * tpar = par; - while (tpar && (tpar->footnoteflag != LyXParagraph::NO_FOOTNOTE) && - (tpar->layout != textclasslist.NumberOfLayout(params.textclass, + while (tpar +#ifndef NEW_INSETS + && (tpar->footnoteflag != LyXParagraph::NO_FOOTNOTE) +#endif + && (tpar->layout != textclasslist.NumberOfLayout(params.textclass, "Caption").second)) tpar = tpar->next; if (tpar && tpar->layout == textclasslist.NumberOfLayout(params.textclass, "Caption").second) { sgmlOpenTag(os, depth + 1, inner_tag); -#ifdef USE_OSTREAM_ONLY string extra_par; SimpleDocBookOnePar(os, extra_par, tpar, desc_on, depth + 2); sgmlCloseTag(os, depth+1, inner_tag); - if(!extra_par.empty()) - os << extra_par; -#else - string tmp_par, extra_par; - SimpleDocBookOnePar(tmp_par, extra_par, tpar, - desc_on, depth + 2); - tmp_par = strip(tmp_par); - tmp_par = frontStrip(tmp_par); - os << tmp_par; - sgmlCloseTag(os, depth+1, inner_tag); - if(!extra_par.empty()) + if (!extra_par.empty()) os << extra_par; -#endif } } +#ifndef NEW_INSETS void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par, - int const depth) + int depth) { string tag, inner_tag; string tmp_par, extra_par; @@ -2920,24 +2606,24 @@ void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par, SOME_ENUM present = FOOTNOTE_LIKE; while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - if(last == present) { - if(inner_span) { - if(!tmp_par.empty()) { + if (last == present) { + if (inner_span) { + if (!tmp_par.empty()) { os << tmp_par; - tmp_par.clear(); + tmp_par.erase(); sgmlCloseTag(os, depth + 1, inner_tag); sgmlOpenTag(os, depth + 1, inner_tag); } - } - else + } else { os << "\n"; + } } else { os << tmp_par; - if(!inner_tag.empty()) sgmlCloseTag(os, depth + 1, + if (!inner_tag.empty()) sgmlCloseTag(os, depth + 1, inner_tag); - if(!extra_par.empty()) os << extra_par; - if(!tag.empty()) sgmlCloseTag(os, depth, tag); - extra_par.clear(); + if (!extra_par.empty()) os << extra_par; + if (!tag.empty()) sgmlCloseTag(os, depth, tag); + extra_par.erase(); switch (par->footnotekind) { case LyXParagraph::FOOTNOTE: @@ -2972,7 +2658,7 @@ void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par, if ((present == TAB_LIKE) || (present == FIG_LIKE)) { DocBookHandleCaption(os, inner_tag, depth, desc_on, par); - inner_tag.clear(); + inner_tag.erase(); } else { sgmlOpenTag(os, depth + 1, inner_tag); } @@ -2981,24 +2667,10 @@ void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par, if (par->layout != textclasslist .NumberOfLayout(params.textclass, "Caption").second) { -#ifdef USE_OSTREAM_ONLY -#ifdef HAVE_SSTREAM - ostringstream ost; -#else - ostrstream ost; -#endif + std::ostringstream ost; SimpleDocBookOnePar(ost, extra_par, par, desc_on, depth + 2); -#ifdef HAVE_SSTREAM tmp_par += ost.str().c_str(); -#else - ost << '\0'; - char * ctmp = ost.str(); - tmp_par += ctmp; - delete [] ctmp; -#endif -#else -#endif } tmp_par = frontStrip(strip(tmp_par)); @@ -3006,40 +2678,50 @@ void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par, par = par->next; } os << tmp_par; - if(!inner_tag.empty()) sgmlCloseTag(os, depth + 1, inner_tag); - if(!extra_par.empty()) os << extra_par; - if(!tag.empty()) sgmlCloseTag(os, depth, tag); + if (!inner_tag.empty()) sgmlCloseTag(os, depth + 1, inner_tag); + if (!extra_par.empty()) os << extra_par; + if (!tag.empty()) sgmlCloseTag(os, depth, tag); } +#endif -/* push a tag in a style stack */ -void Buffer::push_tag(ostream & os, char const * tag, +// push a tag in a style stack +void Buffer::push_tag(ostream & os, string const & tag, int & pos, char stack[5][3]) { - /* pop all previous tags */ +#ifdef WITH_WARNINGS +#warning Use a real stack! (Lgb) +#endif + // pop all previous tags for (int j = pos; j >= 0; --j) os << ""; - /* add new tag */ - sprintf(stack[++pos], "%s", tag); + // add new tag + sprintf(stack[++pos], "%s", tag.c_str()); - /* push all tags */ + // push all tags for (int i = 0; i <= pos; ++i) os << "<" << stack[i] << ">"; } -void Buffer::pop_tag(ostream & os, char const * tag, + +void Buffer::pop_tag(ostream & os, string const & tag, int & pos, char stack[5][3]) { - int j; - +#ifdef WITH_WARNINGS +#warning Use a real stack! (Lgb) +#endif + // Please, Lars, do not remove the global variable. I already + // had to reintroduce it twice! (JMarc) + int j; + // pop all tags till specified one - for (j = pos; (j >= 0) && (strcmp(stack[j], tag)); --j) + for (j = pos; (j >= 0) && (strcmp(stack[j], tag.c_str())); --j) os << ""; // closes the tag os << ""; - + // push all tags, but the specified one for (j = j + 1; j <= pos; ++j) { os << "<" << stack[j] << ">"; @@ -3049,16 +2731,16 @@ void Buffer::pop_tag(ostream & os, char const * tag, } -/* handle internal paragraph parsing -- layout already processed */ +// Handle internal paragraph parsing -- layout already processed. // checks, if newcol chars should be put into this line // writes newline, if necessary. static -void linux_doc_line_break(ostream & os, unsigned int & colcount, - const unsigned int newcol) +void linux_doc_line_break(ostream & os, string::size_type & colcount, + string::size_type newcol) { colcount += newcol; - if (colcount > lyxrc->ascii_linelen) { + if (colcount > lyxrc.ascii_linelen) { os << "\n"; colcount = newcol; // assume write after this call } @@ -3066,9 +2748,9 @@ void linux_doc_line_break(ostream & os, unsigned int & colcount, void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, - int desc_on, int const /*depth*/) + int desc_on, int /*depth*/) { - LyXFont font1, font2; + LyXFont font1; char c; Inset * inset; LyXParagraph::size_type main_body; @@ -3081,115 +2763,114 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, char shape_type = 0; // shape font flag bool is_em = false; // emphasis (italic) font flag - int stack_num = -1; // style stack position + int stack_num = -1; // style stack position + // Can this be rewritten to use a std::stack, please. (Lgb) char stack[5][3]; // style stack - unsigned int char_line_count = 5; // Heuristic choice ;-) + string::size_type char_line_count = 5; // Heuristic choice ;-) if (style.labeltype != LABEL_MANUAL) main_body = 0; else main_body = par->BeginningOfMainBody(); - /* gets paragraph main font */ + // gets paragraph main font if (main_body > 0) font1 = style.labelfont; else font1 = style.font; - /* parsing main loop */ + // parsing main loop for (LyXParagraph::size_type i = 0; i < par->size(); ++i) { - /* handle quote tag */ - if (i == main_body && !par->IsDummy()) { + // handle quote tag + if (i == main_body +#ifndef NEW_INSETS + && !par->IsDummy() +#endif + ) { if (main_body > 0) font1 = style.font; } - font2 = par->getFont(i); + LyXFont const font2 = par->getFont(params, i); if (font1.family() != font2.family()) { - switch(family_type) { + switch (family_type) { case 0: if (font2.family() == LyXFont::TYPEWRITER_FAMILY) { push_tag(os, "tt", stack_num, stack); - family_type= 1; + family_type = 1; } else if (font2.family() == LyXFont::SANS_FAMILY) { push_tag(os, "sf", stack_num, stack); - family_type= 2; + family_type = 2; } break; case 1: pop_tag(os, "tt", stack_num, stack); if (font2.family() == LyXFont::SANS_FAMILY) { push_tag(os, "sf", stack_num, stack); - family_type= 2; - } - else { - family_type= 0; + family_type = 2; + } else { + family_type = 0; } break; case 2: pop_tag(os, "sf", stack_num, stack); if (font2.family() == LyXFont::TYPEWRITER_FAMILY) { push_tag(os, "tt", stack_num, stack); - family_type= 1; - } - else { - family_type= 0; + family_type = 1; + } else { + family_type = 0; } } } - /* handle bold face */ + // handle bold face if (font1.series() != font2.series()) { if (font2.series() == LyXFont::BOLD_SERIES) { push_tag(os, "bf", stack_num, stack); is_bold = true; - } - else if (is_bold) { + } else if (is_bold) { pop_tag(os, "bf", stack_num, stack); is_bold = false; } } - /* handle italic and slanted fonts */ + // handle italic and slanted fonts if (font1.shape() != font2.shape()) { - switch(shape_type) { + switch (shape_type) { case 0: if (font2.shape() == LyXFont::ITALIC_SHAPE) { push_tag(os, "it", stack_num, stack); - shape_type= 1; - } - else if (font2.shape() == LyXFont::SLANTED_SHAPE) { + shape_type = 1; + } else if (font2.shape() == LyXFont::SLANTED_SHAPE) { push_tag(os, "sl", stack_num, stack); - shape_type= 2; + shape_type = 2; } break; case 1: pop_tag(os, "it", stack_num, stack); if (font2.shape() == LyXFont::SLANTED_SHAPE) { push_tag(os, "sl", stack_num, stack); - shape_type= 2; - } - else { - shape_type= 0; + shape_type = 2; + } else { + shape_type = 0; } break; case 2: pop_tag(os, "sl", stack_num, stack); if (font2.shape() == LyXFont::ITALIC_SHAPE) { push_tag(os, "it", stack_num, stack); - shape_type= 1; - } - else { - shape_type= 0; + shape_type = 1; + } else { + shape_type = 0; } } } - /* handle tag */ + // handle tag if (font1.emph() != font2.emph()) { if (font2.emph() == LyXFont::ON) { push_tag(os, "em", stack_num, stack); @@ -3201,23 +2882,18 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, } c = par->GetChar(i); - + + if (c == LyXParagraph::META_INSET) { + inset = par->GetInset(i); + inset->Linuxdoc(this, os); + } + if (font2.latex() == LyXFont::ON) { // "TeX"-Mode on == > SGML-Mode on. if (c != '\0') os << c; // see LaTeX-Generation... ++char_line_count; - } else if (c == LyXParagraph::META_INSET) { - inset = par->GetInset(i); -#ifdef USE_OSTREAM_ONLY - inset->Linuxdoc(os); -#else - string tmp_out; - inset->Linuxdoc(tmp_out); - os << tmp_out; -#endif - } - else { + } else { string sgml_string; if (par->linuxDocConvertChar(c, sgml_string) && !style.free_spacing) { // in freespacing @@ -3229,13 +2905,11 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, linux_doc_line_break(os, char_line_count, 6); os << ""; desc_on = 2; - } - else { + } else { linux_doc_line_break(os, char_line_count, 1); os << c; } - } - else { + } else { os << sgml_string; char_line_count += sgml_string.length(); } @@ -3243,12 +2917,12 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, font1 = font2; } - /* needed if there is an optional argument but no contents */ + // needed if there is an optional argument but no contents if (main_body > 0 && main_body == par->size()) { font1 = style.font; } - /* pop all defined Styles */ + // pop all defined Styles for (j = stack_num; j >= 0; --j) { linux_doc_line_break(os, char_line_count, @@ -3256,29 +2930,26 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par, os << ""; } - /* resets description flag correctly */ - switch(desc_on){ + // resets description flag correctly + switch (desc_on){ case 1: - /* not closed... */ + // not closed... linux_doc_line_break(os, char_line_count, 6); os << ""; break; case 2: - /* fprintf(file, "

");*/ + // fprintf(file, "

"); break; } } -/* print an error message */ +// Print an error message. void Buffer::LinuxDocError(LyXParagraph * par, int pos, - char const * message) + string const & message) { - InsetError * new_inset; - - /* insert an error marker in text */ - new_inset = new InsetError(message); - par->InsertChar(pos, LyXParagraph::META_INSET); + // insert an error marker in text + InsetError * new_inset = new InsetError(message); par->InsertInset(pos, new_inset); } @@ -3290,13 +2961,17 @@ void Buffer::LinuxDocError(LyXParagraph * par, int pos, enum { MAX_NEST_LEVEL = 25}; -void Buffer::makeDocBookFile(string const & fname, int column) +void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) { LyXParagraph * par = paragraph; + niceFile = nice; // this will be used by Insetincludes. + string top_element= textclasslist.LatexnameOfClass(params.textclass); + // Please use a real stack. string environment_stack[MAX_NEST_LEVEL]; string environment_inner[MAX_NEST_LEVEL]; + // Please use a real stack. string command_stack[MAX_NEST_LEVEL]; bool command_flag= false; int command_depth= 0, command_base= 0, cmd_depth= 0; @@ -3304,9 +2979,17 @@ void Buffer::makeDocBookFile(string const & fname, int column) string item_name, command_name; string c_depth, c_params, tmps; - int depth= 0; /* paragraph depth */ + int depth = 0; // paragraph depth + LyXTextClass const & tclass = + textclasslist.TextClass(params.textclass); + + LaTeXFeatures features(params, tclass.numLayouts()); + validate(features); - tex_code_break_column = column; + //if (nice) + tex_code_break_column = lyxrc.ascii_linelen; + //else + //tex_code_break_column = 0; ofstream ofs(fname.c_str()); if (!ofs) { @@ -3316,57 +2999,61 @@ void Buffer::makeDocBookFile(string const & fname, int column) texrow.reset(); - ofs << "\n\n"; - else - ofs << "\n [ " << params.preamble << " \n]>\n\n"; + ofs << "\n"; + if (params.preamble.empty() && sgml_includedfiles.empty()) + ofs << ">\n\n"; + else + ofs << "\n [ " << params.preamble + << sgml_includedfiles << " \n]>\n\n"; - if(params.options.empty()) - sgmlOpenTag(ofs, 0, top_element); - else { - string top = top_element; - top += " "; - top += params.options; - sgmlOpenTag(ofs, 0, top); + if (params.options.empty()) + sgmlOpenTag(ofs, 0, top_element); + else { + string top = top_element; + top += " "; + top += params.options; + sgmlOpenTag(ofs, 0, top); + } } + ofs << "\n"; + while (par) { - int desc_on = 0; /* description mode*/ + int desc_on = 0; // description mode LyXLayout const & style = - textclasslist.Style(users->buffer()->params.textclass, + textclasslist.Style(params.textclass, par->layout); - par->AutoDeleteInsets(); - /* environment tag closing */ - for( ; depth > par->depth; --depth) { - if(environment_inner[depth] != "!-- --") { + // environment tag closing + for (; depth > par->depth; --depth) { + if (environment_inner[depth] != "!-- --") { item_name= "listitem"; sgmlCloseTag(ofs, command_depth + depth, item_name); - if( environment_inner[depth] == "varlistentry") + if (environment_inner[depth] == "varlistentry") sgmlCloseTag(ofs, depth+command_depth, environment_inner[depth]); } sgmlCloseTag(ofs, depth + command_depth, environment_stack[depth]); - environment_stack[depth].clear(); - environment_inner[depth].clear(); + environment_stack[depth].erase(); + environment_inner[depth].erase(); } - if(depth == par->depth + if (depth == par->depth && environment_stack[depth] != style.latexname() && !environment_stack[depth].empty()) { - if(environment_inner[depth] != "!-- --") { + if (environment_inner[depth] != "!-- --") { item_name= "listitem"; sgmlCloseTag(ofs, command_depth+depth, item_name); - if( environment_inner[depth] == "varlistentry") + if (environment_inner[depth] == "varlistentry") sgmlCloseTag(ofs, depth + command_depth, environment_inner[depth]); @@ -3375,14 +3062,14 @@ void Buffer::makeDocBookFile(string const & fname, int column) sgmlCloseTag(ofs, depth + command_depth, environment_stack[depth]); - environment_stack[depth].clear(); - environment_inner[depth].clear(); + environment_stack[depth].erase(); + environment_inner[depth].erase(); } // Write opening SGML tags. - switch(style.latextype) { + switch (style.latextype) { case LATEX_PARAGRAPH: - if(style.latexname() != "dummy") + if (style.latexname() != "dummy") sgmlOpenTag(ofs, depth+command_depth, style.latexname()); break; @@ -3398,28 +3085,25 @@ void Buffer::makeDocBookFile(string const & fname, int column) tmps = style.latexparam(); c_params = split(tmps, c_depth,'|'); - cmd_depth= atoi(c_depth.c_str()); + cmd_depth= lyx::atoi(c_depth); - if(command_flag) { - if(cmd_depth= command_base; --j) - if(!command_stack[j].empty()) + if (!command_stack[j].empty()) sgmlCloseTag(ofs, j, command_stack[j]); command_depth= command_base= cmd_depth; - } - else if(cmd_depth <= command_depth) { - for(int j = command_depth; + } else if (cmd_depth <= command_depth) { + for (int j = command_depth; j >= cmd_depth; --j) - if(!command_stack[j].empty()) + if (!command_stack[j].empty()) sgmlCloseTag(ofs, j, command_stack[j]); command_depth= cmd_depth; - } - else + } else command_depth= cmd_depth; - } - else { + } else { command_depth = command_base = cmd_depth; command_flag = true; } @@ -3429,7 +3113,7 @@ void Buffer::makeDocBookFile(string const & fname, int column) // more WYSIWYM handling. if (par->GetChar(0) == LyXParagraph::META_INSET) { Inset * inset = par->GetInset(0); - char lyx_code = inset->LyxCode(); + Inset::Code lyx_code = inset->LyxCode(); if (lyx_code == Inset::LABEL_CODE){ command_name += " id=\""; command_name += (static_cast(inset))->getContents(); @@ -3438,7 +3122,7 @@ void Buffer::makeDocBookFile(string const & fname, int column) } } - sgmlOpenTag(ofs, depth+command_depth, command_name); + sgmlOpenTag(ofs, depth + command_depth, command_name); item_name = "title"; sgmlOpenTag(ofs, depth + 1 + command_depth, item_name); break; @@ -3447,7 +3131,7 @@ void Buffer::makeDocBookFile(string const & fname, int column) case LATEX_ITEM_ENVIRONMENT: if (depth < par->depth) { depth = par->depth; - environment_stack[depth].clear(); + environment_stack[depth].erase(); } if (environment_stack[depth] != style.latexname()) { @@ -3456,7 +3140,7 @@ void Buffer::makeDocBookFile(string const & fname, int column) sgmlOpenTag(ofs, depth + command_depth, environment_stack[depth]); } else { - if(environment_inner[depth] != "!-- --") { + if (environment_inner[depth] != "!-- --") { item_name= "listitem"; sgmlCloseTag(ofs, command_depth + depth, @@ -3468,8 +3152,8 @@ void Buffer::makeDocBookFile(string const & fname, int column) } } - if(style.latextype == LATEX_ENVIRONMENT) { - if(!style.latexparam().empty()) + if (style.latextype == LATEX_ENVIRONMENT) { + if (!style.latexparam().empty()) sgmlOpenTag(ofs, depth + command_depth, style.latexparam()); break; @@ -3477,7 +3161,7 @@ void Buffer::makeDocBookFile(string const & fname, int column) desc_on = (style.labeltype == LABEL_MANUAL); - if(desc_on) + if (desc_on) environment_inner[depth]= "varlistentry"; else environment_inner[depth]= "listitem"; @@ -3485,12 +3169,11 @@ void Buffer::makeDocBookFile(string const & fname, int column) sgmlOpenTag(ofs, depth + 1 + command_depth, environment_inner[depth]); - if(desc_on) { + if (desc_on) { item_name= "term"; sgmlOpenTag(ofs, depth + 1 + command_depth, item_name); - } - else { + } else { item_name= "para"; sgmlOpenTag(ofs, depth + 1 + command_depth, item_name); @@ -3502,47 +3185,38 @@ void Buffer::makeDocBookFile(string const & fname, int column) break; } +#ifndef NEW_INSETS do { -#ifdef USE_OSTREAM_ONLY +#endif string extra_par; SimpleDocBookOnePar(ofs, extra_par, par, desc_on, depth + 1 + command_depth); par = par->next; +#ifndef NEW_INSETS DocBookHandleFootnote(ofs, par, depth + 1 + command_depth); -#else - string tmp_par, extra_par; - - SimpleDocBookOnePar(tmp_par, extra_par, par, desc_on, - depth + 1 + command_depth); - ofs << tmp_par; - - par = par->next; - DocBookHandleFootnote(ofs, par, - depth + 1 + command_depth); -#endif } while(par && par->IsDummy()); - +#endif string end_tag; - /* write closing SGML tags */ - switch(style.latextype) { + // write closing SGML tags + switch (style.latextype) { case LATEX_COMMAND: end_tag = "title"; sgmlCloseTag(ofs, depth + command_depth, end_tag); break; case LATEX_ENVIRONMENT: - if(!style.latexparam().empty()) + if (!style.latexparam().empty()) sgmlCloseTag(ofs, depth + command_depth, style.latexparam()); break; case LATEX_ITEM_ENVIRONMENT: - if(desc_on == 1) break; + if (desc_on == 1) break; end_tag= "para"; sgmlCloseTag(ofs, depth + 1 + command_depth, end_tag); break; case LATEX_PARAGRAPH: - if(style.latexname() != "dummy") + if (style.latexname() != "dummy") sgmlCloseTag(ofs, depth + command_depth, style.latexname()); break; @@ -3554,13 +3228,13 @@ void Buffer::makeDocBookFile(string const & fname, int column) } // Close open tags - for(; depth >= 0; --depth) { - if(!environment_stack[depth].empty()) { - if(environment_inner[depth] != "!-- --") { + for (; depth >= 0; --depth) { + if (!environment_stack[depth].empty()) { + if (environment_inner[depth] != "!-- --") { item_name= "listitem"; sgmlCloseTag(ofs, command_depth + depth, item_name); - if( environment_inner[depth] == "varlistentry") + if (environment_inner[depth] == "varlistentry") sgmlCloseTag(ofs, depth + command_depth, environment_inner[depth]); } @@ -3570,28 +3244,24 @@ void Buffer::makeDocBookFile(string const & fname, int column) } } - for(int j = command_depth; j >= command_base; --j) - if(!command_stack[j].empty()) + for (int j = command_depth; j >= command_base; --j) + if (!command_stack[j].empty()) sgmlCloseTag(ofs, j, command_stack[j]); - ofs << "\n\n"; - sgmlCloseTag(ofs, 0, top_element); + if (!only_body) { + ofs << "\n\n"; + sgmlCloseTag(ofs, 0, top_element); + } ofs.close(); // How to check for successful close } -#ifdef USE_OSTREAM_ONLY void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, LyXParagraph * par, int & desc_on, - int const depth) + int depth) const { - if (par->table) { - par->SimpleDocBookOneTablePar(os, extra, desc_on, depth); - return; - } - bool emph_flag = false; LyXLayout const & style = textclasslist.Style(params.textclass, @@ -3604,173 +3274,36 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, main_body = par->BeginningOfMainBody(); // gets paragraph main font - //if (main_body > 0) - // font1 = style.labelfont; - //else - // font1 = style.font; LyXFont font1 = main_body > 0 ? style.labelfont : style.font; int char_line_count = depth; - if(!style.free_spacing) + if (!style.free_spacing) for (int j = 0; j < depth; ++j) - os << ' '; - - // parsing main loop - for (LyXParagraph::size_type i = 0; - i < par->size(); ++i) { - LyXFont font2 = par->getFont(i); - - // handle tag - if (font1.emph() != font2.emph() && i) { - if (font2.emph() == LyXFont::ON) { - os << ""; - emph_flag = true; - }else { - os << ""; - emph_flag = false; - } - } - - char c = par->GetChar(i); - - if (c == LyXParagraph::META_INSET) { - Inset * inset = par->GetInset(i); -#ifdef HAVE_SSTREAM - ostringstream ost; - inset->DocBook(ost); - string tmp_out = ost.str().c_str(); -#else - ostrstream ost; - inset->DocBook(ost); - ost << '\0'; - char * ctmp = ost.str(); - string tmp_out(ctmp); - delete [] ctmp; -#endif - // - // This code needs some explanation: - // Two insets are treated specially - // label if it is the first element in a command paragraph - // desc_on == 3 - // graphics inside tables or figure floats can't go on - // title (the equivalente in latex for this case is caption - // and title should come first - // desc_on == 4 - // - if(desc_on!= 3 || i!= 0) { - if(!tmp_out.empty() && tmp_out[0] == '@') { - if(desc_on == 4) - extra += frontStrip(tmp_out, '@'); - else - os << frontStrip(tmp_out, '@'); - } - else - os << tmp_out; - } - } else if (font2.latex() == LyXFont::ON) { - // "TeX"-Mode on ==> SGML-Mode on. - if (c != '\0') - os << c; - ++char_line_count; - } - else { - string sgml_string; - if (par->linuxDocConvertChar(c, sgml_string) - && !style.free_spacing) { // in freespacing - // mode, spaces are - // non-breaking characters - // char is ' ' - if (desc_on == 1) { - ++char_line_count; - os << "\n"; - desc_on = 2; - } - else { - os << c; - } - } - else { - os << sgml_string; - } - } - font1 = font2; - } - - /* needed if there is an optional argument but no contents */ - if (main_body > 0 && main_body == par->size()) { - font1 = style.font; - } - if (emph_flag) { - os << ""; - } - - /* resets description flag correctly */ - switch(desc_on){ - case 1: - /* not closed... */ - os << ""; - break; - } - os << '\n'; -} -#else -void Buffer::SimpleDocBookOnePar(string & file, string & extra, - LyXParagraph * par, int & desc_on, - int const depth) -{ - if (par->table) { - par->SimpleDocBookOneTablePar(file, extra, desc_on, depth); - return; - } - LyXFont font1, font2; - char c; - Inset * inset; - LyXParagraph::size_type main_body; - int j; - string emph= "emphasis"; - bool emph_flag= false; - - LyXLayout const & style = textclasslist.Style(params.textclass, - par->GetLayout()); - - if (style.labeltype != LABEL_MANUAL) - main_body = 0; - else - main_body = par->BeginningOfMainBody(); - - /* gets paragraph main font */ - if (main_body > 0) - font1 = style.labelfont; - else - font1 = style.font; - - int char_line_count = depth; - if(!style.free_spacing) - for (j = 0; j < depth; ++j) - file += ' '; + os << ' '; - /* parsing main loop */ + // parsing main loop for (LyXParagraph::size_type i = 0; i < par->size(); ++i) { - font2 = par->getFont(i); + LyXFont font2 = par->getFont(params, i); - /* handle tag */ + // handle tag if (font1.emph() != font2.emph() && i) { if (font2.emph() == LyXFont::ON) { - file += ""; - emph_flag= true; + os << ""; + emph_flag = true; }else { - file += ""; - emph_flag= false; + os << ""; + emph_flag = false; } } - c = par->GetChar(i); + char c = par->GetChar(i); if (c == LyXParagraph::META_INSET) { - inset = par->GetInset(i); - string tmp_out; - inset->DocBook(tmp_out); + Inset * inset = par->GetInset(i); + std::ostringstream ost; + inset->DocBook(this, ost); + string tmp_out = ost.str().c_str(); // // This code needs some explanation: @@ -3782,23 +3315,22 @@ void Buffer::SimpleDocBookOnePar(string & file, string & extra, // and title should come first // desc_on == 4 // - if(desc_on!= 3 || i!= 0) { - if(!tmp_out.empty() && tmp_out[0] == '@') { - if(desc_on == 4) + if (desc_on!= 3 || i!= 0) { + if (!tmp_out.empty() && tmp_out[0] == '@') { + if (desc_on == 4) extra += frontStrip(tmp_out, '@'); else - file += frontStrip(tmp_out, '@'); + os << frontStrip(tmp_out, '@'); } else - file += tmp_out; + os << tmp_out; } } else if (font2.latex() == LyXFont::ON) { // "TeX"-Mode on ==> SGML-Mode on. - if (c!= '\0') - file += c; + if (c != '\0') + os << c; ++char_line_count; - } - else { + } else { string sgml_string; if (par->linuxDocConvertChar(c, sgml_string) && !style.free_spacing) { // in freespacing @@ -3807,244 +3339,34 @@ void Buffer::SimpleDocBookOnePar(string & file, string & extra, // char is ' ' if (desc_on == 1) { ++char_line_count; - file += '\n'; - file += ""; + os << "\n"; desc_on = 2; + } else { + os << c; } - else { - file += c; - } - } - else { - file += sgml_string; + } else { + os << sgml_string; } } font1 = font2; } - /* needed if there is an optional argument but no contents */ + // needed if there is an optional argument but no contents if (main_body > 0 && main_body == par->size()) { font1 = style.font; } if (emph_flag) { - file += ""; + os << ""; } - /* resets description flag correctly */ - switch(desc_on){ + // resets description flag correctly + switch (desc_on){ case 1: - /* not closed... */ - file += ""; + // not closed... + os << ""; break; } - file += '\n'; -} -#endif - - -int Buffer::runLaTeX() -{ - if (!users->text) return 0; - - ProhibitInput(); - - // get LaTeX-Filename - string name = getLatexName(); - - string path = OnlyPath(filename); - - string org_path = path; - if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) { - path = tmppath; - } - - Path p(path); // path to LaTeX file - users->owner()->getMiniBuffer()->Set(_("Running LaTeX...")); - - // Remove all error insets - bool a = users->removeAutoInsets(); - - // Always generate the LaTeX file - makeLaTeXFile(name, org_path, false); - markDviDirty(); - - // do the LaTex run(s) - TeXErrors terr; - string latex_command = lyxrc->pdf_mode ? - lyxrc->pdflatex_command : lyxrc->latex_command; - LaTeX latex(latex_command, name, filepath); - int res = latex.run(terr, - users->owner()->getMiniBuffer()); // running latex - - // check return value from latex.run(). - if ((res & LaTeX::NO_LOGFILE)) { - WriteAlert(_("LaTeX did not work!"), - _("Missing log file:"), name); - } else if ((res & LaTeX::ERRORS)) { - users->owner()->getMiniBuffer()->Set(_("Done")); - // Insert all errors as errors boxes - users->insertErrors(terr); - - // Dvi should also be kept dirty if the latex run - // ends up with errors. However it should be possible - // to view a dirty dvi too. - } else { - //no errors or any other things to think about so: - users->owner()->getMiniBuffer()->Set(_("Done")); - markDviClean(); - } - - // if we removed error insets before we ran LaTeX or if we inserted - // error insets after we ran LaTeX this must be run: - if (a || (res & LaTeX::ERRORS)){ - users->redraw(); - users->fitCursor(); - users->updateScrollbar(); - } - AllowInput(); - - return latex.getNumErrors(); -} - - -int Buffer::runLiterate() -{ - if (!users->text) return 0; - - ProhibitInput(); - - // get LaTeX-Filename - string name = getLatexName(); - // get Literate-Filename - string lit_name = ChangeExtension (getLatexName(), - lyxrc->literate_extension, true); - - string path = OnlyPath(filename); - - string org_path = path; - if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) { - path = tmppath; - } - - Path p(path); // path to Literate file - users->owner()->getMiniBuffer()->Set(_("Running Literate...")); - - // Remove all error insets - bool a = users->removeAutoInsets(); - - // generate the Literate file if necessary - if (!isDviClean() || a) { - makeLaTeXFile(lit_name, org_path, false); - markDviDirty(); - } - - string latex_command = lyxrc->pdf_mode ? - lyxrc->pdflatex_command : lyxrc->latex_command; - Literate literate(latex_command, name, filepath, - lit_name, - lyxrc->literate_command, lyxrc->literate_error_filter, - lyxrc->build_command, lyxrc->build_error_filter); - TeXErrors terr; - int res = literate.weave(terr, users->owner()->getMiniBuffer()); - - // check return value from literate.weave(). - if ((res & Literate::NO_LOGFILE)) { - WriteAlert(_("Literate command did not work!"), - _("Missing log file:"), name); - } else if ((res & Literate::ERRORS)) { - users->owner()->getMiniBuffer()->Set(_("Done")); - // Insert all errors as errors boxes - users->insertErrors(terr); - - // Dvi should also be kept dirty if the latex run - // ends up with errors. However it should be possible - // to view a dirty dvi too. - } else { - //no errors or any other things to think about so: - users->owner()->getMiniBuffer()->Set(_("Done")); - markDviClean(); - } - - // if we removed error insets before we ran LaTeX or if we inserted - // error insets after we ran LaTeX this must be run: - if (a || (res & Literate::ERRORS)){ - users->redraw(); - users->fitCursor(); - users->updateScrollbar(); - } - AllowInput(); - - return literate.getNumErrors(); -} - - -int Buffer::buildProgram() -{ - if (!users->text) return 0; - - ProhibitInput(); - - // get LaTeX-Filename - string name = getLatexName(); - // get Literate-Filename - string lit_name = ChangeExtension(getLatexName(), - lyxrc->literate_extension, true); - - string path = OnlyPath(filename); - - string org_path = path; - if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) { - path = tmppath; - } - - Path p(path); // path to Literate file - users->owner()->getMiniBuffer()->Set(_("Building Program...")); - - // Remove all error insets - bool a = users->removeAutoInsets(); - - // generate the LaTeX file if necessary - if (!isNwClean() || a) { - makeLaTeXFile(lit_name, org_path, false); - markNwDirty(); - } - - string latex_command = lyxrc->pdf_mode ? - lyxrc->pdflatex_command : lyxrc->latex_command; - Literate literate(latex_command, name, filepath, - lit_name, - lyxrc->literate_command, lyxrc->literate_error_filter, - lyxrc->build_command, lyxrc->build_error_filter); - TeXErrors terr; - int res = literate.build(terr, users->owner()->getMiniBuffer()); - - // check return value from literate.build(). - if ((res & Literate::NO_LOGFILE)) { - WriteAlert(_("Build did not work!"), - _("Missing log file:"), name); - } else if ((res & Literate::ERRORS)) { - users->owner()->getMiniBuffer()->Set(_("Done")); - // Insert all errors as errors boxes - users->insertErrors(terr); - - // Literate files should also be kept dirty if the literate - // command run ends up with errors. - } else { - //no errors or any other things to think about so: - users->owner()->getMiniBuffer()->Set(_("Done")); - markNwClean(); - } - - // if we removed error insets before we ran Literate/Build or if we inserted - // error insets after we ran Literate/Build this must be run: - if (a || (res & Literate::ERRORS)){ - users->redraw(); - users->fitCursor(); - users->updateScrollbar(); - } - AllowInput(); - - return literate.getNumErrors(); + os << '\n'; } @@ -4055,14 +3377,14 @@ int Buffer::runChktex() { if (!users->text) return 0; - ProhibitInput(); + ProhibitInput(users); // get LaTeX-Filename - string name = getLatexName(); + string const name = getLatexName(); string path = OnlyPath(filename); - string org_path = path; - if (lyxrc->use_tempdir || (IsDirWriteable(path) < 1)) { + string const org_path = path; + if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) { path = tmppath; } @@ -4070,16 +3392,13 @@ int Buffer::runChktex() users->owner()->getMiniBuffer()->Set(_("Running chktex...")); // Remove all error insets - bool a = users->removeAutoInsets(); + bool const removedErrorInsets = users->removeAutoInsets(); // Generate the LaTeX file if neccessary - if (!isDviClean() || a) { - makeLaTeXFile(name, org_path, false); - markDviDirty(); - } + makeLaTeXFile(name, org_path, false); TeXErrors terr; - Chktex chktex(lyxrc->chktex_command, name, filepath); + Chktex chktex(lyxrc.chktex_command, name, filepath); int res = chktex.run(terr); // run chktex if (res == -1) { @@ -4092,197 +3411,16 @@ int Buffer::runChktex() // if we removed error insets before we ran chktex or if we inserted // error insets after we ran chktex, this must be run: - if (a || res){ + if (removedErrorInsets || res){ users->redraw(); - users->fitCursor(); - users->updateScrollbar(); + users->fitCursor(users->text); } - AllowInput(); + AllowInput(users); return res; } -#if 0 -void Buffer::RoffAsciiTable(ostream & os, LyXParagraph * par) -{ - LyXFont font1(LyXFont::ALL_INHERIT); - LyXFont font2; - Inset * inset; - LyXParagraph::size_type i; - int j, cell = 0; - char c; - - string fname1 = TmpFileName(string(), "RAT1"); - string fname2 = TmpFileName(string(), "RAT2"); - - ofstream ofs(fname1.c_str()); - if (!ofs) { - WriteAlert(_("LYX_ERROR:"), - _("Cannot open temporary file:"), fname1); - return; - } - par->table->RoffEndOfCell(ofs, -1); - for (i = 0; i < par->size(); ++i) { - c = par->GetChar(i); - if (par->table->IsContRow(cell)) { - if (c == LyXParagraph::META_NEWLINE) - ++cell; - continue; - } - font2 = par->GetFontSettings(i); - if (font1.latex() != font2.latex()) { - if (font2.latex() != LyXFont::OFF) - continue; - } - switch (c) { - case LyXParagraph::META_INSET: - if ((inset = par->GetInset(i))) { -#if 1 -#ifdef HAVE_SSTREAM - stringstresm ss(ios::in | ios::out); - inset->Latex(ss, -1); - ss.seekp(0); - ss.get(c); - while (!ss) { - if (c == '\\') - ofs << "\\\\"; - else - ofs << c; - ss.get(c); - } -#else - strstream ss; - inset->Latex(ss, -1); - ss.seekp(0); - ss.get(c); - while (!ss) { - if (c == '\\') - ofs << "\\\\"; - else - ofs << c; - ss.get(c); - } - delete [] ss.str(); -#endif -#else - fstream fs(fname2.c_str(), ios::in|ios::out); - if (!fs) { - WriteAlert(_("LYX_ERROR:"), - _("Cannot open temporary file:"), fname2); - ofs.close(); - remove(fname1.c_str()); - return; - } - inset->Latex(fs, -1); - fs.seekp(0); - fs.get(c); - while(!fs) { - if (c == '\\') - ofs << "\\\\"; - else - ofs << c; - fs >> c; - } - fs.close(); -#endif - } - break; - case LyXParagraph::META_NEWLINE: - if (par->table->CellHasContRow(cell)>= 0) - par->RoffContTableRows(ofs, i+1, cell); - par->table->RoffEndOfCell(ofs, cell); - ++cell; - break; - case LyXParagraph::META_HFILL: - break; -#if 0 - case LyXParagraph::META_PROTECTED_SEPARATOR: - break; -#endif - case '\\': - ofs << "\\\\"; - break; - default: - if (c != '\0') - ofs << c; - else if (c == '\0') - lyxerr.debug() - << "RoffAsciiTable:" - " NULL char in structure." << endl; - break; - } - } - par->table->RoffEndOfCell(ofs, cell); - ofs.close(); - string cmd = lyxrc->ascii_roff_command + " >" + fname2; - cmd = subst(cmd, "$$FName", fname1); - Systemcalls one(Systemcalls::System, cmd); - if (!(lyxerr.debugging(Debug::ROFF))) { - remove(fname1.c_str()); - } - ifstream ifs(fname2.c_str()); - if (!ifs) { - WriteFSAlert(_("Error! Can't open temporary file:"), fname2); - return; - } - // now output the produced file - os << "\n\n"; - ifs.get(c); - if (!ifs) - WriteAlert(_("Error!"), - _("Error executing *roff command on table")); - // overread leading blank lines - while(!ifs && (c == '\n')) - ifs.get(c); - while(!ifs) { - for(j = 0; j < par->depth; ++j) - os << " "; - while(!ifs && (c != '\n')) { - os << c; - ifs.get(c); - } - os << '\n'; - // overread trailing blank lines - while(!ifs && (c == '\n')) - ifs.get(c); - } - ifs.close(); - remove(fname2.c_str()); -} -#endif - - -/// changed Heinrich Bauer, 23/03/98 -bool Buffer::isDviClean() const -{ - if (lyxrc->use_tempdir) - return dvi_clean_tmpd; - else - return dvi_clean_orgd; -} - - -/// changed Heinrich Bauer, 23/03/98 -void Buffer::markDviClean() -{ - if (lyxrc->use_tempdir) - dvi_clean_tmpd = true; - else - dvi_clean_orgd = true; -} - - -/// changed Heinrich Bauer, 23/03/98 -void Buffer::markDviDirty() -{ - if (lyxrc->use_tempdir) - dvi_clean_tmpd = false; - else - dvi_clean_orgd = false; -} - - void Buffer::validate(LaTeXFeatures & features) const { LyXParagraph * par = paragraph; @@ -4311,9 +3449,9 @@ void Buffer::validate(LaTeXFeatures & features) const // so they are tested here for (int i = 0; i < 4; ++i) { if (params.user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) { - int font = params.user_defined_bullets[i].getFont(); + int const font = params.user_defined_bullets[i].getFont(); if (font == 0) { - int c = params + int const c = params .user_defined_bullets[i] .getCharacter(); if (c == 16 @@ -4323,18 +3461,16 @@ void Buffer::validate(LaTeXFeatures & features) const || c == 31) { features.latexsym = true; } - } - if (font == 1) { + } else if (font == 1) { features.amssymb = true; - } - else if ((font >= 2 && font <= 5)) { + } else if ((font >= 2 && font <= 5)) { features.pifont = true; } } } if (lyxerr.debugging(Debug::LATEX)) { - features.showStruct(params); + features.showStruct(); } } @@ -4342,9 +3478,9 @@ void Buffer::validate(LaTeXFeatures & features) const void Buffer::setPaperStuff() { params.papersize = BufferParams::PAPER_DEFAULT; - char c1 = params.paperpackage; + char const c1 = params.paperpackage; if (c1 == BufferParams::PACKAGE_NONE) { - char c2 = params.papersize2; + char const c2 = params.papersize2; if (c2 == BufferParams::VM_PAPER_USLETTER) params.papersize = BufferParams::PAPER_USLETTER; else if (c2 == BufferParams::VM_PAPER_USLEGAL) @@ -4367,36 +3503,28 @@ void Buffer::setPaperStuff() // This function should be in Buffer because it's a buffer's property (ale) -string Buffer::getIncludeonlyList(char delim) +string const Buffer::getIncludeonlyList(char delim) { string lst; - LyXParagraph * par = paragraph; - LyXParagraph::size_type pos; - Inset * inset; - while (par){ - pos = -1; - while ((inset = par->ReturnNextInsetPointer(pos))){ - if (inset->LyxCode() == Inset::INCLUDE_CODE) { - InsetInclude * insetinc = - static_cast(inset); - if (insetinc->isInclude() - && insetinc->isNoLoad()) { - if (!lst.empty()) - lst += delim; - lst += ChangeExtension(insetinc->getContents(), string(), true); - } + for (inset_iterator it = inset_iterator_begin(); + it != inset_iterator_end(); ++it) { + if ((*it)->LyxCode() == Inset::INCLUDE_CODE) { + InsetInclude * insetinc = + static_cast(*it); + if (insetinc->isInclude() + && insetinc->isNoLoad()) { + if (!lst.empty()) + lst += delim; + lst += OnlyFilename(ChangeExtension(insetinc->getContents(), string())); } - ++pos; - } - par = par->next; + } } lyxerr.debug() << "Includeonly(" << lst << ')' << endl; return lst; } -// This is also a buffer property (ale) -string Buffer::getReferenceList(char delim) +vector const Buffer::getLabelList() { /// if this is a child document and the parent is already loaded /// Use the parent's list instead [ale990407] @@ -4404,81 +3532,114 @@ string Buffer::getReferenceList(char delim) && bufferlist.exists(params.parentname)) { Buffer * tmp = bufferlist.getBuffer(params.parentname); if (tmp) - return tmp->getReferenceList(delim); + return tmp->getLabelList(); + } + + vector label_list; + for (inset_iterator it = inset_iterator_begin(); + it != inset_iterator_end(); ++it) { + vector const l = (*it)->getLabelList(); + label_list.insert(label_list.end(), l.begin(), l.end()); } + return label_list; +} + +vector > const Buffer::getTocList() +{ + vector > l(4); LyXParagraph * par = paragraph; - LyXParagraph::size_type pos; - Inset * inset; - string lst; while (par) { - pos = -1; - while ((inset = par->ReturnNextInsetPointer(pos))){ - for (int i = 0; i < inset->GetNumberOfLabels(); ++i) { - if (!lst.empty()) - lst += delim; - lst += inset->getLabel(i); +#ifndef NEW_INSETS + if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE) { + if (textclasslist.Style(params.textclass, + par->GetLayout()).labeltype + == LABEL_SENSITIVE) { + TocItem tmp; + tmp.par = par; + tmp.depth = 0; + tmp.str = par->String(this, false); + switch (par->footnotekind) { + case LyXParagraph::FIG: + case LyXParagraph::WIDE_FIG: + l[TOC_LOF].push_back(tmp); + break; + case LyXParagraph::TAB: + case LyXParagraph::WIDE_TAB: + l[TOC_LOT].push_back(tmp); + break; + case LyXParagraph::ALGORITHM: + l[TOC_LOA].push_back(tmp); + break; + case LyXParagraph::FOOTNOTE: + case LyXParagraph::MARGIN: + break; + } } - ++pos; + } else if (!par->IsDummy()) { +#endif + char const labeltype = + textclasslist.Style(params.textclass, + par->GetLayout()).labeltype; + + if (labeltype >= LABEL_COUNTER_CHAPTER + && labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) { + // insert this into the table of contents + TocItem tmp; + tmp.par = par; + tmp.depth = max(0, + labeltype - + textclasslist.TextClass(params.textclass).maxcounter()); + tmp.str = par->String(this, true); + l[TOC_TOC].push_back(tmp); + } +#ifndef NEW_INSETS } +#endif par = par->next; } - lyxerr.debug() << "References(" << lst << ")" << endl; - return lst; + return l; } // This is also a buffer property (ale) -string Buffer::getBibkeyList(char delim) +vector > const Buffer::getBibkeyList() { /// if this is a child document and the parent is already loaded /// Use the parent's list instead [ale990412] if (!params.parentname.empty() && bufferlist.exists(params.parentname)) { Buffer * tmp = bufferlist.getBuffer(params.parentname); if (tmp) - return tmp->getBibkeyList(delim); + return tmp->getBibkeyList(); } - string bibkeys; + vector > keys; LyXParagraph * par = paragraph; while (par) { - if (par->bibkey) { - if (!bibkeys.empty()) - bibkeys += delim; - bibkeys += par->bibkey->getContents(); - } + if (par->bibkey) + keys.push_back(pair(par->bibkey->getContents(), + par->String(this, false))); par = par->next; } // Might be either using bibtex or a child has bibliography - if (bibkeys.empty()) { - par = paragraph; - while (par) { - Inset * inset; - LyXParagraph::size_type pos = -1; - + if (keys.empty()) { + for (inset_iterator it = inset_iterator_begin(); + it != inset_iterator_end(); ++it) { // Search for Bibtex or Include inset - while ((inset = par->ReturnNextInsetPointer(pos))) { - if (inset-> LyxCode() == Inset::BIBTEX_CODE) { - if (!bibkeys.empty()) - bibkeys += delim; - bibkeys += static_cast(inset)->getKeys(delim); - } else if (inset-> LyxCode() == Inset::INCLUDE_CODE) { - string bk = static_cast(inset)->getKeys(delim); - if (!bk.empty()) { - if (!bibkeys.empty()) - bibkeys += delim; - bibkeys += bk; - } - } - ++pos; + if ((*it)->LyxCode() == Inset::BIBTEX_CODE) { + vector > tmp = + static_cast(*it)->getKeys(this); + keys.insert(keys.end(), tmp.begin(), tmp.end()); + } else if ((*it)->LyxCode() == Inset::INCLUDE_CODE) { + vector > const tmp = + static_cast(*it)->getKeys(); + keys.insert(keys.end(), tmp.begin(), tmp.end()); } - par = par->next; } } - lyxerr.debug() << "Bibkeys(" << bibkeys << ")" << endl; - return bibkeys; + return keys; } @@ -4500,7 +3661,7 @@ void Buffer::markDepClean(string const & name) dep_clean->master = name; dep_clean->next = 0; } else { - DEPCLEAN* item = dep_clean; + DEPCLEAN * item = dep_clean; while (item && item->master != name) item = item->next; if (item) { @@ -4509,32 +3670,98 @@ void Buffer::markDepClean(string const & name) item = new DEPCLEAN; item->clean = true; item->master = name; - item->next = 0;; + item->next = 0; } } } -void Buffer::Dispatch(string const & command) +bool Buffer::Dispatch(string const & command) { // Split command string into command and argument - string cmd, line = frontStrip(command); - string arg = strip(frontStrip(split(line, cmd, ' '))); + string cmd; + string line = frontStrip(command); + string const arg = strip(frontStrip(split(line, cmd, ' '))); - Dispatch(lyxaction.LookupFunc(cmd.c_str()), arg.c_str()); + return Dispatch(lyxaction.LookupFunc(cmd), arg); } -void Buffer::Dispatch(int action, string const & argument) +bool Buffer::Dispatch(int action, string const & argument) { + bool dispatched = true; switch (action) { case LFUN_EXPORT: - MenuExport(this, argument); + Exporter::Export(this, argument, false); break; default: - lyxerr << "A truly unknown func!" << endl; - break; + dispatched = false; + } + return dispatched; +} + + +void Buffer::resize() +{ + /// resize the BufferViews! + if (users) + users->resize(); +} + + +void Buffer::resizeInsets(BufferView * bv) +{ + /// then remove all LyXText in text-insets + LyXParagraph * par = paragraph; + for (; par; par = par->next) { + par->resizeInsetsLyXText(bv); + } +} + +void Buffer::ChangeLanguage(Language const * from, Language const * to) +{ + + LyXParagraph * par = paragraph; + while (par) { + par->ChangeLanguage(params, from, to); + par = par->next; + } +} + + +bool Buffer::isMultiLingual() +{ + LyXParagraph * par = paragraph; + while (par) { + if (par->isMultiLingual(params)) + return true; + par = par->next; + } + return false; +} + + +Buffer::inset_iterator::inset_iterator(LyXParagraph * paragraph, + LyXParagraph::size_type pos) + : par(paragraph) +{ + it = par->InsetIterator(pos); + if (it == par->inset_iterator_end()) { + par = par->next; + SetParagraph(); + } +} + - } // end of switch +void Buffer::inset_iterator::SetParagraph() +{ + while (par) { + it = par->inset_iterator_begin(); + if (it != par->inset_iterator_end()) + return; + par = par->next; + } + //it = 0; + // We maintain an invariant that whenever par = 0 then it = 0 }