X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.C;h=331c336463b27a1f5c9c5f04851d2deaad42d4b3;hb=dbd7a961fc46bb10c85bdd8c7fb6626477ae63d8;hp=3701b7768301e033e35fd04db72f5353d9aee5df;hpb=bf6257967e48709d375d5b8aa1cdd66c7f7bc25a;p=lyx.git diff --git a/src/buffer.C b/src/buffer.C index 3701b77683..331c336463 100644 --- a/src/buffer.C +++ b/src/buffer.C @@ -14,24 +14,6 @@ #include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -#include - -#ifdef HAVE_LOCALE -#include -#endif - #ifdef __GNUG__ #pragma implementation #endif @@ -39,7 +21,6 @@ #include "buffer.h" #include "bufferlist.h" #include "lyx_main.h" -#include "lyx_gui_misc.h" #include "LyXAction.h" #include "lyxrc.h" #include "lyxlex.h" @@ -48,8 +29,26 @@ #include "bufferview_funcs.h" #include "lyxfont.h" #include "version.h" +#include "LaTeX.h" +#include "Chktex.h" +#include "LyXView.h" +#include "debug.h" +#include "LaTeXFeatures.h" +#include "lyxtext.h" +#include "gettext.h" +#include "language.h" +#include "encoding.h" +#include "exporter.h" +#include "Lsstream.h" +#include "converter.h" +#include "BufferView.h" +#include "ParagraphParameters.h" +#include "iterators.h" +#include "lyxtextclasslist.h" + #include "mathed/formulamacro.h" #include "mathed/formula.h" + #include "insets/inset.h" #include "insets/inseterror.h" #include "insets/insetlabel.h" @@ -66,7 +65,6 @@ #include "insets/insettoc.h" #include "insets/insetparent.h" #include "insets/insetspecialchar.h" -#include "insets/figinset.h" #include "insets/insettext.h" #include "insets/insetert.h" #include "insets/insetgraphics.h" @@ -81,30 +79,37 @@ #endif #include "insets/insetcaption.h" #include "insets/insetfloatlist.h" + +#include "frontends/Dialogs.h" +#include "frontends/Alert.h" + #include "support/textutils.h" #include "support/filetools.h" #include "support/path.h" #include "support/os.h" -#include "LaTeX.h" -#include "Chktex.h" -#include "LyXView.h" -#include "debug.h" -#include "LaTeXFeatures.h" -#include "support/syscall.h" #include "support/lyxlib.h" #include "support/FileInfo.h" #include "support/lyxmanip.h" -#include "lyxtext.h" -#include "gettext.h" -#include "language.h" -#include "lyx_gui_misc.h" // WarnReadonly() -#include "frontends/Dialogs.h" -#include "encoding.h" -#include "exporter.h" -#include "Lsstream.h" -#include "converter.h" -#include "BufferView.h" -#include "ParagraphParameters.h" +#include "support/lyxalgo.h" // for lyx::count + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + + +#ifdef HAVE_LOCALE +#include +#endif + using std::ostream; using std::ofstream; @@ -122,6 +127,9 @@ using std::set; using std::stack; using std::list; +using lyx::pos_type; +using lyx::textclass_type; + // all these externs should eventually be removed. extern BufferList bufferlist; @@ -137,21 +145,26 @@ extern int tex_code_break_column; Buffer::Buffer(string const & file, bool ronly) + : paragraph(0), lyx_clean(true), bak_clean(true), + unnamed(false), dep_clean(0), read_only(ronly), + filename_(file), users(0) { lyxerr[Debug::INFO] << "Buffer::Buffer()" << endl; - filename = file; - filepath = OnlyPath(file); - paragraph = 0; - lyx_clean = true; - bak_clean = true; - dep_clean = 0; - read_only = ronly; - unnamed = false; - users = 0; +// filename = file; + filepath_ = OnlyPath(file); +// paragraph = 0; +// lyx_clean = true; +// bak_clean = true; +// dep_clean = 0; +// read_only = ronly; +// unnamed = false; +// users = 0; lyxvc.buffer(this); - if (read_only || (lyxrc.use_tempdir)) { + if (read_only || lyxrc.use_tempdir) { tmppath = CreateBufferTmpDir(); - } else tmppath.erase(); + } else { + tmppath.erase(); + } } @@ -183,7 +196,7 @@ Buffer::~Buffer() string const Buffer::getLatexName(bool no_path) const { - string name = ChangeExtension(MakeLatexName(filename), ".tex"); + string const name = ChangeExtension(MakeLatexName(fileName()), ".tex"); if (no_path) return OnlyFilename(name); else @@ -200,7 +213,7 @@ pair const Buffer::getLogName(void) const string path = OnlyPath(filename); - if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) + if (lyxrc.use_tempdir || !IsDirWriteable(path)) path = tmppath; string const fname = AddName(path, @@ -209,7 +222,7 @@ pair const Buffer::getLogName(void) const string const bname = AddName(path, OnlyFilename( ChangeExtension(filename, - formats.Extension("literate") + ".out"))); + formats.extension("literate") + ".out"))); // If no Latex log or Build log is newer, show Build log @@ -233,25 +246,6 @@ void Buffer::setReadonly(bool flag) updateTitles(); users->owner()->getDialogs()->updateBufferDependent(false); } - if (read_only) { - WarnReadonly(filename); - } -} - - -bool Buffer::saveParamsAsDefaults() // const -{ - string const fname = AddName(AddPath(user_lyxdir, "templates/"), - "defaults.lyx"); - Buffer defaults = Buffer(fname); - - // Use the current buffer's parameters as default - defaults.params = params; - - // add an empty paragraph. Is this enough? - defaults.paragraph = new Paragraph; - - return defaults.writeFile(defaults.filename, false); } @@ -259,7 +253,8 @@ bool Buffer::saveParamsAsDefaults() // const // Should work on a list void Buffer::updateTitles() const { - if (users) users->owner()->updateWindowTitle(); + if (users) + users->owner()->updateWindowTitle(); } @@ -267,15 +262,16 @@ void Buffer::updateTitles() const // Should work on a list void Buffer::resetAutosaveTimers() const { - if (users) users->owner()->resetAutosaveTimer(); + if (users) + users->owner()->resetAutosaveTimer(); } void Buffer::setFileName(string const & newfile) { - filename = MakeAbsPath(newfile); - filepath = OnlyPath(filename); - setReadonly(IsFileWriteable(filename) == 0); + filename_ = MakeAbsPath(newfile); + filepath_ = OnlyPath(filename_); + setReadonly(IsFileWriteable(filename_) == 0); updateTitles(); } @@ -285,6 +281,7 @@ namespace { string last_inset_read; +#ifndef NO_COMPABILITY struct ErtComp { ErtComp() : active(false), in_tabular(false) { @@ -292,17 +289,22 @@ struct ErtComp string contents; bool active; bool in_tabular; + LyXFont font; }; std::stack ert_stack; ErtComp ert_comp; +#endif +#ifdef WITH_WARNINGS +#warning And _why_ is this here? (Lgb) +#endif +int unknown_layouts; +int unknown_tokens; } // anon -int unknown_layouts; - // candidate for move to BufferView // (at least some parts in the beginning of the func) // @@ -314,12 +316,12 @@ int unknown_layouts; bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par) { unknown_layouts = 0; -#ifdef NO_LATEX + unknown_tokens = 0; +#ifndef NO_COMPABILITY ert_comp.contents.erase(); ert_comp.active = false; ert_comp.in_tabular = false; #endif - int pos = 0; Paragraph::depth_type depth = 0; bool the_end_read = false; @@ -334,14 +336,14 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par) } else { // We are inserting into an existing document users->text->breakParagraph(users); - first_par = users->text->firstParagraph(); + first_par = users->text->ownerParagraph(); pos = 0; markDirty(); // We don't want to adopt the parameters from the // document we insert, so we skip until the text begins: - while (lex.IsOK()) { + while (lex.isOK()) { lex.nextToken(); - string const pretoken = lex.GetString(); + string const pretoken = lex.getString(); if (pretoken == "\\layout") { lex.pushToken(pretoken); break; @@ -349,9 +351,9 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par) } } - while (lex.IsOK()) { + while (lex.isOK()) { lex.nextToken(); - string const token = lex.GetString(); + string const token = lex.getString(); if (token.empty()) continue; @@ -377,28 +379,41 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par) s += tostr(unknown_layouts); s += _(" paragraphs"); } - WriteAlert(_("Textclass Loading Error!"), s, + Alert::alert(_("Textclass Loading Error!"), s, _("When reading " + fileName())); - } + } + + if (unknown_tokens > 0) { + string s = _("Encountered "); + if (unknown_tokens == 1) { + s += _("one unknown token"); + } else { + s += tostr(unknown_tokens); + s += _(" unknown tokens"); + } + Alert::alert(_("Textclass Loading Error!"), s, + _("When reading " + fileName())); + } return the_end_read; } -void Buffer::insertErtContents(Paragraph * par, int & pos, - LyXFont const & font, bool set_inactive) +#ifndef NO_COMPABILITY +void Buffer::insertErtContents(Paragraph * par, int & pos, bool set_inactive) { if (!ert_comp.contents.empty()) { - lyxerr[Debug::INSETS] << "ERT contents:\n" - << ert_comp.contents << endl; - Inset * inset = new InsetERT(ert_comp.contents, true); - par->insertInset(pos++, inset, font); + lyxerr[Debug::INSETS] << "ERT contents:\n'" + << ert_comp.contents << "'" << endl; + Inset * inset = new InsetERT(params.language, ert_comp.contents, true); + par->insertInset(pos++, inset, ert_comp.font); ert_comp.contents.erase(); } if (set_inactive) { ert_comp.active = false; } } +#endif bool @@ -410,6 +425,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, ) { bool the_end_read = false; +#ifndef NO_COMPABILITY #ifndef NO_PEXTRA_REALLY // This is super temporary but is needed to get the compability // mode for minipages work correctly together with new tabulars. @@ -419,9 +435,9 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, static Paragraph * minipar; static Paragraph * parBeforeMinipage; #endif - +#endif if (token[0] != '\\') { -#ifdef NO_LATEX +#ifndef NO_COMPABILITY if (ert_comp.active) { ert_comp.contents += token; } else { @@ -431,7 +447,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, par->insertChar(pos, (*cit), font); ++pos; } -#ifdef NO_LATEX +#ifndef NO_COMPABILITY } #endif } else if (token == "\\i") { @@ -440,20 +456,22 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, par->insertInset(pos, inset, font); ++pos; } else if (token == "\\layout") { -#ifdef NO_LATEX +#ifndef NO_COMPABILITY ert_comp.in_tabular = false; // Do the insetert. - insertErtContents(par, pos, font); + insertErtContents(par, pos); #endif - lex.EatLine(); - string const layoutname = lex.GetString(); - pair pp - = textclasslist.NumberOfLayout(params.textclass, - layoutname); + lex.eatLine(); + string const layoutname = lex.getString(); + //lyxerr << "Looking for layout '" + // << layoutname << "'!" << endl; -#ifdef NO_LATEX + //lyxerr << "Result: " << pp.first << "/" << pp.second << endl; + +#ifndef NO_COMPABILITY if (compare_no_case(layoutname, "latex") == 0) { ert_comp.active = true; + ert_comp.font = font; } #endif #ifdef USE_CAPTION @@ -515,28 +533,12 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, par = new Paragraph(par); } pos = 0; - if (pp.first) { - par->layout = pp.second; - } else { - // layout not found - // use default layout "Standard" (0) - par->layout = 0; - ++unknown_layouts; - string const s = _("Layout had to be changed from\n") - + layoutname + _(" to ") - + textclasslist.NameOfLayout(params.textclass, par->layout); - InsetError * new_inset = new InsetError(s); - par->insertInset(0, new_inset); - } + par->layout(layoutname); // Test whether the layout is obsolete. LyXLayout const & layout = - textclasslist.Style(params.textclass, - par->layout); + textclasslist[params.textclass][par->layout()]; if (!layout.obsoleted_by().empty()) - par->layout = textclasslist - .NumberOfLayout(params.textclass, - layout.obsoleted_by()) - .second; + par->layout(layout.obsoleted_by()); par->params().depth(depth); font = LyXFont(LyXFont::ALL_INHERIT, params.language); if (file_format < 216 @@ -546,11 +548,17 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } #endif +#ifndef NO_COMPABILITY } else if (token == "\\begin_float") { + insertErtContents(par, pos); + //insertErtContents(par, pos, false); + //ert_stack.push(ert_comp); + //ert_comp = ErtComp(); + // This is the compability reader. It can be removed in // LyX version 1.3.0. (Lgb) lex.next(); - string const tmptok = lex.GetString(); + string const tmptok = lex.getString(); //lyxerr << "old float: " << tmptok << endl; Inset * inset = 0; @@ -558,34 +566,41 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, if (tmptok == "footnote") { inset = new InsetFoot; + old_float << "collapsed true\n"; } else if (tmptok == "margin") { inset = new InsetMarginal; + old_float << "collapsed true\n"; } else if (tmptok == "fig") { inset = new InsetFloat("figure"); old_float << "placement htbp\n" - << "wide false\n"; + << "wide false\n" + << "collapsed false\n"; } else if (tmptok == "tab") { inset = new InsetFloat("table"); old_float << "placement htbp\n" - << "wide false\n"; + << "wide false\n" + << "collapsed false\n"; } else if (tmptok == "alg") { inset = new InsetFloat("algorithm"); old_float << "placement htbp\n" - << "wide false\n"; + << "wide false\n" + << "collapsed false\n"; } else if (tmptok == "wide-fig") { inset = new InsetFloat("figure"); //InsetFloat * tmp = new InsetFloat("figure"); //tmp->wide(true); //inset = tmp; old_float << "placement htbp\n" - << "wide true\n"; + << "wide true\n" + << "collapsed false\n"; } else if (tmptok == "wide-tab") { inset = new InsetFloat("table"); //InsetFloat * tmp = new InsetFloat("table"); //tmp->wide(true); //inset = tmp; old_float << "placement htbp\n" - << "wide true\n"; + << "wide true\n" + << "collapsed false\n"; } if (!inset) { @@ -594,15 +609,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, #endif 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(); + string const tmp = lex.getString(); if (tmp == "\\end_deeper") { //lyxerr << "\\end_deeper caught!" << endl; if (!depth) { @@ -628,6 +641,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, inset->read(this, nylex); par->insertInset(pos, inset, font); ++pos; + insertErtContents(par, pos); +#endif } else if (token == "\\begin_deeper") { ++depth; } else if (token == "\\end_deeper") { @@ -640,45 +655,45 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } else if (token == "\\begin_preamble") { params.readPreamble(lex); } else if (token == "\\textclass") { - lex.EatLine(); - pair pp = - textclasslist.NumberOfClass(lex.GetString()); + lex.eatLine(); + pair pp = + textclasslist.NumberOfClass(lex.getString()); if (pp.first) { params.textclass = pp.second; } else { - WriteAlert(string(_("Textclass error")), + Alert::alert(string(_("Textclass error")), string(_("The document uses an unknown textclass \"")) + - lex.GetString() + string("\"."), + lex.getString() + string("\"."), string(_("LyX will not be able to produce output correctly."))); params.textclass = 0; } - if (!textclasslist.Load(params.textclass)) { - // if the textclass wasn't loaded properly - // we need to either substitute another - // or stop loading the file. - // I can substitute but I don't see how I can - // stop loading... ideas?? ARRae980418 - WriteAlert(_("Textclass Loading Error!"), + if (!textclasslist[params.textclass].load()) { + // if the textclass wasn't loaded properly + // we need to either substitute another + // or stop loading the file. + // I can substitute but I don't see how I can + // stop loading... ideas?? ARRae980418 + Alert::alert(_("Textclass Loading Error!"), string(_("Can't load textclass ")) + - textclasslist.NameOfClass(params.textclass), + textclasslist[params.textclass].name(), _("-- substituting default")); params.textclass = 0; } } else if (token == "\\options") { - lex.EatLine(); - params.options = lex.GetString(); + lex.eatLine(); + params.options = lex.getString(); } else if (token == "\\language") { params.readLanguage(lex); } else if (token == "\\fontencoding") { - lex.EatLine(); + lex.eatLine(); } else if (token == "\\inputencoding") { - lex.EatLine(); - params.inputenc = lex.GetString(); + lex.eatLine(); + params.inputenc = lex.getString(); } else if (token == "\\graphics") { params.readGraphicsDriver(lex); } else if (token == "\\fontscheme") { - lex.EatLine(); - params.fonts = lex.GetString(); + lex.eatLine(); + params.fonts = lex.getString(); } else if (token == "\\noindent") { par->params().noindent(true); } else if (token == "\\fill_top") { @@ -696,22 +711,26 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } else if (token == "\\start_of_appendix") { par->params().startOfAppendix(true); } else if (token == "\\paragraph_separation") { - int tmpret = lex.FindToken(string_paragraph_separation); - if (tmpret == -1) ++tmpret; + int tmpret = lex.findToken(string_paragraph_separation); + if (tmpret == -1) + ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) params.paragraph_separation = static_cast(tmpret); } else if (token == "\\defskip") { lex.nextToken(); - params.defskip = VSpace(lex.GetString()); + params.defskip = VSpace(lex.getString()); +#ifndef NO_COMPABILITY } 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); +#endif } else if (token == "\\quotes_language") { - int tmpret = lex.FindToken(string_quotes_language); - if (tmpret == -1) ++tmpret; + int tmpret = lex.findToken(string_quotes_language); + if (tmpret == -1) + ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) { InsetQuotes::quote_language tmpl = InsetQuotes::EnglishQ; @@ -739,7 +758,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } } else if (token == "\\quotes_times") { lex.nextToken(); - switch (lex.GetInteger()) { + switch (lex.getInteger()) { case 1: params.quotes_times = InsetQuotes::SingleQ; break; @@ -748,13 +767,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, break; } } else if (token == "\\papersize") { - int tmpret = lex.FindToken(string_papersize); + int tmpret = lex.findToken(string_papersize); if (tmpret == -1) ++tmpret; else params.papersize2 = tmpret; } else if (token == "\\paperpackage") { - int tmpret = lex.FindToken(string_paperpackages); + int tmpret = lex.findToken(string_paperpackages); if (tmpret == -1) { ++tmpret; params.paperpackage = BufferParams::PACKAGE_NONE; @@ -762,81 +781,82 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, params.paperpackage = tmpret; } else if (token == "\\use_geometry") { lex.nextToken(); - params.use_geometry = lex.GetInteger(); + params.use_geometry = lex.getInteger(); } else if (token == "\\use_amsmath") { lex.nextToken(); - params.use_amsmath = lex.GetInteger(); + params.use_amsmath = lex.getInteger(); } else if (token == "\\use_natbib") { lex.nextToken(); - params.use_natbib = lex.GetInteger(); + params.use_natbib = lex.getInteger(); } else if (token == "\\use_numerical_citations") { lex.nextToken(); - params.use_numerical_citations = lex.GetInteger(); + params.use_numerical_citations = lex.getInteger(); } else if (token == "\\paperorientation") { - int tmpret = lex.FindToken(string_orientation); - if (tmpret == -1) ++tmpret; + int tmpret = lex.findToken(string_orientation); + if (tmpret == -1) + ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) params.orientation = static_cast(tmpret); } else if (token == "\\paperwidth") { lex.next(); - params.paperwidth = lex.GetString(); + params.paperwidth = lex.getString(); } else if (token == "\\paperheight") { lex.next(); - params.paperheight = lex.GetString(); + params.paperheight = lex.getString(); } else if (token == "\\leftmargin") { lex.next(); - params.leftmargin = lex.GetString(); + params.leftmargin = lex.getString(); } else if (token == "\\topmargin") { lex.next(); - params.topmargin = lex.GetString(); + params.topmargin = lex.getString(); } else if (token == "\\rightmargin") { lex.next(); - params.rightmargin = lex.GetString(); + params.rightmargin = lex.getString(); } else if (token == "\\bottommargin") { lex.next(); - params.bottommargin = lex.GetString(); + params.bottommargin = lex.getString(); } else if (token == "\\headheight") { lex.next(); - params.headheight = lex.GetString(); + params.headheight = lex.getString(); } else if (token == "\\headsep") { lex.next(); - params.headsep = lex.GetString(); + params.headsep = lex.getString(); } else if (token == "\\footskip") { lex.next(); - params.footskip = lex.GetString(); + params.footskip = lex.getString(); } else if (token == "\\paperfontsize") { lex.nextToken(); - params.fontsize = strip(lex.GetString()); + params.fontsize = strip(lex.getString()); } else if (token == "\\papercolumns") { lex.nextToken(); - params.columns = lex.GetInteger(); + 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; } } else if (token == "\\paperpagestyle") { lex.nextToken(); - params.pagestyle = strip(lex.GetString()); + params.pagestyle = strip(lex.getString()); } else if (token == "\\bullet") { lex.nextToken(); - int const index = lex.GetInteger(); + int const index = lex.getInteger(); lex.nextToken(); - int temp_int = lex.GetInteger(); + int temp_int = lex.getInteger(); params.user_defined_bullets[index].setFont(temp_int); params.temp_bullets[index].setFont(temp_int); lex.nextToken(); - temp_int = lex.GetInteger(); + temp_int = lex.getInteger(); params.user_defined_bullets[index].setCharacter(temp_int); params.temp_bullets[index].setCharacter(temp_int); lex.nextToken(); - temp_int = lex.GetInteger(); + temp_int = lex.getInteger(); params.user_defined_bullets[index].setSize(temp_int); params.temp_bullets[index].setSize(temp_int); lex.nextToken(); - string const 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 @@ -846,10 +866,11 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, //how can I put it back? } } else if (token == "\\bulletLaTeX") { + // The bullet class should be able to read this. lex.nextToken(); - int const index = lex.GetInteger(); + int const index = lex.getInteger(); lex.next(); - string temp_str = lex.GetString(); + string temp_str = lex.getString(); string sum_str; while (temp_str != "\\end_bullet") { // this loop structure is needed when user @@ -860,19 +881,20 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, // therefore needs to be read in turn sum_str += temp_str; lex.next(); - temp_str = lex.GetString(); + temp_str = lex.getString(); } + params.user_defined_bullets[index].setText(sum_str); params.temp_bullets[index].setText(sum_str); } else if (token == "\\secnumdepth") { lex.nextToken(); - params.secnumdepth = lex.GetInteger(); + params.secnumdepth = lex.getInteger(); } else if (token == "\\tocdepth") { lex.nextToken(); - params.tocdepth = lex.GetInteger(); + params.tocdepth = lex.getInteger(); } else if (token == "\\spacing") { lex.next(); - string const tmp = strip(lex.GetString()); + string const tmp = strip(lex.getString()); Spacing::Space tmp_space = Spacing::Default; float tmp_val = 0.0; if (tmp == "single") { @@ -884,7 +906,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } else if (tmp == "other") { lex.next(); tmp_space = Spacing::Other; - tmp_val = lex.GetFloat(); + tmp_val = lex.getFloat(); } else { lex.printError("Unknown spacing token: '$$Token'"); } @@ -897,7 +919,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } } else if (token == "\\paragraph_spacing") { lex.next(); - string const tmp = strip(lex.GetString()); + string const tmp = strip(lex.getString()); if (tmp == "single") { par->params().spacing(Spacing(Spacing::Single)); } else if (tmp == "onehalf") { @@ -907,54 +929,38 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } else if (tmp == "other") { lex.next(); par->params().spacing(Spacing(Spacing::Other, - lex.GetFloat())); + lex.getFloat())); } else { lex.printError("Unknown spacing token: '$$Token'"); } } else if (token == "\\float_placement") { lex.nextToken(); - params.float_placement = lex.GetString(); + params.float_placement = lex.getString(); } else if (token == "\\family") { lex.next(); - font.setLyXFamily(lex.GetString()); + font.setLyXFamily(lex.getString()); } else if (token == "\\series") { lex.next(); - font.setLyXSeries(lex.GetString()); + font.setLyXSeries(lex.getString()); } else if (token == "\\shape") { lex.next(); - font.setLyXShape(lex.GetString()); + font.setLyXShape(lex.getString()); } else if (token == "\\size") { lex.next(); - font.setLyXSize(lex.GetString()); -#ifndef NO_LATEX -#ifdef WITH_WARNINGS -#warning compatability hack needed -#endif + font.setLyXSize(lex.getString()); +#ifndef NO_COMPABILITY } else if (token == "\\latex") { lex.next(); - string const tok = lex.GetString(); - // This is dirty, but gone with LyX3. (Asger) - if (tok == "no_latex") - font.setLatex(LyXFont::OFF); - else if (tok == "latex") - font.setLatex(LyXFont::ON); - else if (tok == "default") - font.setLatex(LyXFont::INHERIT); - else - lex.printError("Unknown LaTeX font flag " - "`$$Token'"); -#else - } else if (token == "\\latex") { - lex.next(); - string const tok = lex.GetString(); + string const tok = lex.getString(); if (tok == "no_latex") { // Do the insetert. - insertErtContents(par, pos, font); + insertErtContents(par, pos); } else if (tok == "latex") { ert_comp.active = true; + ert_comp.font = font; } else if (tok == "default") { // Do the insetert. - insertErtContents(par, pos, font); + insertErtContents(par, pos); } else { lex.printError("Unknown LaTeX font flag " "`$$Token'"); @@ -962,7 +968,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, #endif } else if (token == "\\lang") { lex.next(); - string const tok = lex.GetString(); + string const tok = lex.getString(); Language const * lang = languages.getLanguage(tok); if (lang) { font.setLanguage(lang); @@ -972,13 +978,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } } else if (token == "\\numeric") { lex.next(); - font.setNumber(font.setLyXMisc(lex.GetString())); + font.setNumber(font.setLyXMisc(lex.getString())); } else if (token == "\\emph") { lex.next(); - font.setEmph(font.setLyXMisc(lex.GetString())); + font.setEmph(font.setLyXMisc(lex.getString())); } else if (token == "\\bar") { lex.next(); - string const tok = lex.GetString(); + string const tok = lex.getString(); // This is dirty, but gone with LyX3. (Asger) if (tok == "under") font.setUnderbar(LyXFont::ON); @@ -991,12 +997,12 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, "`$$Token'"); } else if (token == "\\noun") { lex.next(); - font.setNoun(font.setLyXMisc(lex.GetString())); + font.setNoun(font.setLyXMisc(lex.getString())); } else if (token == "\\color") { lex.next(); - font.setLyXColor(lex.GetString()); + font.setLyXColor(lex.getString()); } else if (token == "\\align") { - int tmpret = lex.FindToken(string_align); + int tmpret = lex.findToken(string_align); if (tmpret == -1) ++tmpret; if (tmpret != LYX_LAYOUT_DEFAULT) { // tmpret != 99 ??? int const tmpret2 = int(pow(2.0, tmpret)); @@ -1005,33 +1011,41 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } } else if (token == "\\added_space_top") { lex.nextToken(); - par->params().spaceTop(VSpace(lex.GetString())); + VSpace value = VSpace(lex.getString()); + if ((value.length().len().value() != 0) || + (value.kind() != VSpace::LENGTH)) + par->params().spaceTop(value); } else if (token == "\\added_space_bottom") { lex.nextToken(); - par->params().spaceBottom(VSpace(lex.GetString())); + VSpace value = VSpace(lex.getString()); + if ((value.length().len().value() != 0) || + (value.kind() != VSpace::LENGTH)) + par->params().spaceBottom(value); +#ifndef NO_COMPABILITY #ifndef NO_PEXTRA_REALLY } else if (token == "\\pextra_type") { lex.nextToken(); - par->params().pextraType(lex.GetInteger()); + par->params().pextraType(lex.getInteger()); } else if (token == "\\pextra_width") { lex.nextToken(); - par->params().pextraWidth(lex.GetString()); + par->params().pextraWidth(lex.getString()); } else if (token == "\\pextra_widthp") { lex.nextToken(); - par->params().pextraWidthp(lex.GetString()); + par->params().pextraWidthp(lex.getString()); } else if (token == "\\pextra_alignment") { lex.nextToken(); - par->params().pextraAlignment(lex.GetInteger()); + par->params().pextraAlignment(lex.getInteger()); } else if (token == "\\pextra_hfill") { lex.nextToken(); - par->params().pextraHfill(lex.GetInteger()); + par->params().pextraHfill(lex.getInteger()); } else if (token == "\\pextra_start_minipage") { lex.nextToken(); - par->params().pextraStartMinipage(lex.GetInteger()); + par->params().pextraStartMinipage(lex.getInteger()); +#endif #endif } else if (token == "\\labelwidthstring") { - lex.EatLine(); - par->params().labelWidthString(lex.GetString()); + lex.eatLine(); + par->params().labelWidthString(lex.getString()); // do not delete this token, it is still needed! } else if (token == "\\end_inset") { lyxerr << "Solitary \\end_inset. Missing \\begin_inset?.\n" @@ -1042,26 +1056,26 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, // But insets should read it, it is a part of // the inset isn't it? Lgb. } else if (token == "\\begin_inset") { -#ifdef NO_LATEX - insertErtContents(par, pos, font, false); +#ifndef NO_COMPABILITY + insertErtContents(par, pos, false); ert_stack.push(ert_comp); ert_comp = ErtComp(); #endif readInset(lex, par, pos, font); -#ifdef NO_LATEX +#ifndef NO_COMPABILITY ert_comp = ert_stack.top(); ert_stack.pop(); + insertErtContents(par, pos); #endif } else if (token == "\\SpecialChar") { LyXLayout const & layout = - textclasslist.Style(params.textclass, - par->getLayout()); + textclasslist[params.textclass][par->layout()]; // Insets don't make sense in a free-spacing context! ---Kayvan - if (layout.free_spacing) { - if (lex.IsOK()) { + if (layout.free_spacing || par->isFreeSpacing()) { + if (lex.isOK()) { lex.next(); - string next_token = lex.GetString(); + string next_token = lex.getString(); if (next_token == "\\-") { par->insertChar(pos, '-', font); } else if (next_token == "\\protected_separator" @@ -1081,15 +1095,14 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } ++pos; } else if (token == "\\newline") { -#ifdef NO_LATEX - +#ifndef NO_COMPABILITY if (!ert_comp.in_tabular && ert_comp.active) { ert_comp.contents += char(Paragraph::META_NEWLINE); } else { // Since we cannot know it this is only a regular // newline or a tabular cell delimter we have to // handle the ERT here. - insertErtContents(par, pos, font, false); + insertErtContents(par, pos, false); par->insertChar(pos, Paragraph::META_NEWLINE, font); ++pos; @@ -1099,7 +1112,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, ++pos; #endif } else if (token == "\\LyXTable") { -#ifdef NO_LATEX +#ifndef NO_COMPABILITY ert_comp.in_tabular = true; #endif Inset * inset = new InsetTabular(*this); @@ -1114,10 +1127,9 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, // Remove it later some time...introduced with fileformat // 2.16. (Lgb) LyXLayout const & layout = - textclasslist.Style(params.textclass, - par->getLayout()); + textclasslist[params.textclass][par->layout()]; - if (layout.free_spacing) { + if (layout.free_spacing || par->isFreeSpacing()) { par->insertChar(pos, ' ', font); } else { Inset * inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); @@ -1131,50 +1143,55 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } par->bibkey->read(this, lex); } else if (token == "\\backslash") { -#ifdef NO_LATEX +#ifndef NO_COMPABILITY if (ert_comp.active) { ert_comp.contents += "\\"; } else { #endif par->insertChar(pos, '\\', font); ++pos; -#ifdef NO_LATEX +#ifndef NO_COMPABILITY } #endif } else if (token == "\\the_end") { -#ifdef NO_LATEX +#ifndef NO_COMPABILITY // If we still have some ert active here we have to insert // it so we don't loose it. (Lgb) - insertErtContents(par, pos, font); + insertErtContents(par, pos); #endif the_end_read = true; +#ifndef NO_COMPABILITY #ifndef NO_PEXTRA_REALLY minipar = parBeforeMinipage = 0; +#endif #endif } else { -#ifdef NO_LATEX +#ifndef NO_COMPABILITY if (ert_comp.active) { ert_comp.contents += token; } else { #endif // This should be insurance for the future: (Asger) - lex.printError("Unknown token `$$Token'. " - "Inserting as text."); - string::const_iterator cit = token.begin(); - string::const_iterator end = token.end(); - for (; cit != end; ++cit) { - par->insertChar(pos, (*cit), font); - ++pos; - } -#ifdef NO_LATEX + ++unknown_tokens; + lex.eatLine(); + string const s = _("Unknown token: ") + token + + " " + lex.text() + "\n"; + + InsetError * new_inset = new InsetError(s); + par->insertInset(pos, new_inset, LyXFont(LyXFont::ALL_INHERIT, + params.language)); + +#ifndef NO_COMPABILITY } #endif } +#ifndef NO_COMPABILITY #ifndef NO_PEXTRA_REALLY // I wonder if we could use this blanket fix for all the // checkminipage cases... - if (par && par->size()) { + // don't forget about ert paragraphs and compatibility read for'em + if (par && (par->size() || !ert_comp.contents.empty())) { // It is possible that this will check to often, // but that should not be an correctness issue. // Only a speed issue. @@ -1188,6 +1205,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, // // BEGIN pextra_minipage compability // This should be removed in 1.3.x (Lgb) + // I don't think we should remove this so fast (Jug) // This compability code is not perfect. In a couple // of rand cases it fails. When the minipage par is @@ -1200,8 +1218,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, if (checkminipage && (call_depth == 1)) { checkminipage = false; if (minipar && (minipar != par) && - (par->params().pextraType()==Paragraph::PEXTRA_MINIPAGE)) - { + (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE)) { lyxerr << "minipages in a row" << endl; if (par->params().pextraStartMinipage()) { lyxerr << "start new minipage" << endl; @@ -1222,10 +1239,10 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, // create a new paragraph to insert the // minipages in the following case if (par->params().pextraStartMinipage() && - !par->params().pextraHfill()) - { + !par->params().pextraHfill()) { Paragraph * p = new Paragraph; - p->layout = 0; + p->layout(textclasslist[params.textclass].defaultLayoutName()); + p->previous(parBeforeMinipage); parBeforeMinipage->next(p); p->next(0); @@ -1234,12 +1251,21 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } InsetMinipage * mini = new InsetMinipage; mini->pos(static_cast(par->params().pextraAlignment())); - mini->width(par->params().pextraWidth()); + mini->pageWidth(LyXLength(par->params().pextraWidth())); if (!par->params().pextraWidthp().empty()) { - lyxerr << "WP:" << mini->width() << endl; - mini->width(tostr(par->params().pextraWidthp())+"%"); + lyxerr << "WP:" << mini->pageWidth().asString() << endl; + mini->pageWidth(LyXLength((par->params().pextraWidthp())+"%")); } + Paragraph * op = mini->firstParagraph(); mini->inset.paragraph(par); + // + // and free the old ones! + // + while(op) { + Paragraph * pp = op->next(); + delete op; + op = pp; + } // Insert the minipage last in the // previous paragraph. if (par->params().pextraHfill()) { @@ -1276,6 +1302,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, tmp = tmp->next(); } depth = parBeforeMinipage->params().depth(); + // and set this depth on the par as it has not been set already + par->params().depth(depth); minipar = parBeforeMinipage = 0; } else if (!minipar && (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE)) @@ -1288,7 +1316,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, // a sequence of minipages // in its own paragraph. Paragraph * p = new Paragraph; - p->layout = 0; + p->layout(textclasslist[params.textclass].defaultLayoutName()); p->previous(par->previous()); p->next(0); p->params().depth(depth); @@ -1304,10 +1332,10 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, InsetMinipage * mini = new InsetMinipage; mini->pos(static_cast(minipar->params().pextraAlignment())); - mini->width(minipar->params().pextraWidth()); + mini->pageWidth(LyXLength(minipar->params().pextraWidth())); if (!par->params().pextraWidthp().empty()) { - lyxerr << "WP:" << mini->width() << endl; - mini->width(tostr(par->params().pextraWidthp())+"%"); + lyxerr << "WP:" << mini->pageWidth().asString() << endl; + mini->pageWidth(LyXLength((par->params().pextraWidthp())+"%")); } mini->inset.paragraph(minipar); @@ -1323,17 +1351,20 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, } // End of pextra_minipage compability --call_depth; +#endif #endif return the_end_read; } // needed to insert the selection -void Buffer::insertStringAsLines(Paragraph *& par, Paragraph::size_type & pos, - LyXFont const & font, - string const & str) const +void Buffer::insertStringAsLines(Paragraph *& par, pos_type & pos, + LyXFont const & fn,string const & str) const { - LyXLayout const & layout = textclasslist.Style(params.textclass, - par->getLayout()); + LyXLayout const & layout = + textclasslist[params.textclass][par->layout()]; + LyXFont font = fn; + + par->checkInsertChar(font); // insert the string, don't insert doublespace bool space_inserted = true; for(string::const_iterator cit = str.begin(); @@ -1341,7 +1372,7 @@ void Buffer::insertStringAsLines(Paragraph *& par, Paragraph::size_type & pos, if (*cit == '\n') { if (par->size() || layout.keepempty) { par->breakParagraph(params, pos, - layout.isEnvironment()); + layout.isEnvironment()); par = par->next(); pos = 0; space_inserted = true; @@ -1349,19 +1380,20 @@ void Buffer::insertStringAsLines(Paragraph *& par, Paragraph::size_type & pos, continue; } // do not insert consecutive spaces if !free_spacing - } else if ((*cit == ' ' || *cit == '\t') - && space_inserted && !layout.free_spacing) { + } else if ((*cit == ' ' || *cit == '\t') && + space_inserted && !layout.free_spacing && + !par->isFreeSpacing()) + { continue; } else if (*cit == '\t') { - if (!layout.free_spacing) { + if (!layout.free_spacing && !par->isFreeSpacing()) { // tabs are like spaces here par->insertChar(pos, ' ', font); ++pos; space_inserted = true; } else { - const Paragraph::value_type nb = 8 - pos % 8; - for (Paragraph::size_type a = 0; - a < nb ; ++a) { + const pos_type nb = 8 - pos % 8; + for (pos_type a = 0; a < nb ; ++a) { par->insertChar(pos, ' ', font); ++pos; } @@ -1385,7 +1417,7 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par, int & pos, LyXFont & font) { // consistency check - if (lex.GetString() != "\\begin_inset") { + if (lex.getString() != "\\begin_inset") { lyxerr << "Buffer::readInset: Consistency check failed." << endl; } @@ -1393,7 +1425,7 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par, Inset * inset = 0; lex.next(); - string const tmptok = lex.GetString(); + string const tmptok = lex.getString(); last_inset_read = tmptok; // test the different insets @@ -1453,8 +1485,11 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par, inset = new InsetFormulaMacro; } else if (tmptok == "Formula") { inset = new InsetFormula; - } else if (tmptok == "Figure") { - inset = new InsetFig(100, 100, *this); + } else if (tmptok == "Figure") { // Backward compatibility +// inset = new InsetFig(100, 100, *this); + inset = new InsetGraphics; + } else if (tmptok == "Graphics") { + inset = new InsetGraphics; } else if (tmptok == "Info") {// backwards compatibility inset = new InsetNote(this, lex.getLongString("\\end_inset"), @@ -1463,7 +1498,7 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par, } else if (tmptok == "Note") { inset = new InsetNote; } else if (tmptok == "Include") { - InsetCommandParams p( "Include" ); + InsetCommandParams p("Include"); inset = new InsetInclude(p, *this); } else if (tmptok == "ERT") { inset = new InsetERT; @@ -1479,7 +1514,7 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par, inset = new InsetMinipage; } else if (tmptok == "Float") { lex.next(); - string tmptok = lex.GetString(); + string tmptok = lex.getString(); inset = new InsetFloat(tmptok); #if 0 } else if (tmptok == "List") { @@ -1489,8 +1524,6 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par, #endif } else if (tmptok == "Caption") { inset = new InsetCaption; - } else if (tmptok == "GRAPHICS") { - inset = new InsetGraphics; } else if (tmptok == "FloatList") { inset = new InsetFloatList; } @@ -1507,12 +1540,12 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par, bool Buffer::readFile(LyXLex & lex, Paragraph * par) { - if (lex.IsOK()) { + if (lex.isOK()) { lex.next(); - string const token(lex.GetString()); + string const token(lex.getString()); if (token == "\\lyxformat") { // the first token _must_ be... - lex.EatLine(); - string tmp_format = lex.GetString(); + lex.eatLine(); + string tmp_format = lex.getString(); //lyxerr << "LyX Format: `" << tmp_format << "'" << endl; // if present remove ".," from string. string::size_type dot = tmp_format.find_first_of(".,"); @@ -1524,35 +1557,36 @@ bool Buffer::readFile(LyXLex & lex, Paragraph * par) // current format } else if (file_format > LYX_FORMAT) { // future format - WriteAlert(_("Warning!"), + Alert::alert(_("Warning!"), _("LyX file format is newer that what"), _("is supported in this LyX version. Expect some problems.")); } else if (file_format < LYX_FORMAT) { // old formats if (file_format < 200) { - WriteAlert(_("ERROR!"), + Alert::alert(_("ERROR!"), _("Old LyX file format found. " "Use LyX 0.10.x to read this!")); return false; } } bool the_end = readLyXformat2(lex, par); - setPaperStuff(); + params.setPaperStuff(); // the_end was added in 213 if (file_format < 213) the_end = true; - if (!the_end) - WriteAlert(_("Warning!"), + if (!the_end) { + Alert::alert(_("Warning!"), _("Reading of document is not complete"), _("Maybe the document is truncated")); + } return true; } else { // "\\lyxformat" not found - WriteAlert(_("ERROR!"), _("Not a LyX file!")); + Alert::alert(_("ERROR!"), _("Not a LyX file!")); } } else - WriteAlert(_("ERROR!"), _("Unable to read file!")); + Alert::alert(_("ERROR!"), _("Unable to read file!")); return false; } @@ -1641,14 +1675,14 @@ bool Buffer::writeFile(string const & fname, bool flag) const // warnings, only cerr. // Needed for autosave in background or panic save (Matthias 120496) - if (read_only && (fname == filename)) { + if (read_only && (fname == fileName())) { // Here we should come with a question if we should // perform the write anyway. if (flag) lyxerr << _("Error! Document is read-only: ") << fname << endl; else - WriteAlert(_("Error! Document is read-only: "), + Alert::alert(_("Error! Document is read-only: "), fname); return false; } @@ -1661,7 +1695,7 @@ bool Buffer::writeFile(string const & fname, bool flag) const lyxerr << _("Error! Cannot write file: ") << fname << endl; else - WriteFSAlert(_("Error! Cannot write file: "), + Alert::err_alert(_("Error! Cannot write file: "), fname); return false; } @@ -1672,7 +1706,7 @@ bool Buffer::writeFile(string const & fname, bool flag) const lyxerr << _("Error! Cannot open file: ") << fname << endl; else - WriteFSAlert(_("Error! Cannot open file: "), + Alert::err_alert(_("Error! Cannot open file: "), fname); return false; } @@ -1685,7 +1719,7 @@ bool Buffer::writeFile(string const & fname, bool flag) const // The top of the file should not be written by params. // write out a comment in the top of the file - ofs << '#' << LYX_DOCVERSION + ofs << '#' << lyx_docversion << " created this file. For more info see http://www.lyx.org/\n" << "\\lyxformat " << LYX_FORMAT << "\n"; @@ -1729,196 +1763,219 @@ bool Buffer::writeFile(string const & fname, bool flag) const string const Buffer::asciiParagraph(Paragraph const * par, - unsigned int linelen) const + unsigned int linelen, + bool noparbreak) const { ostringstream buffer; + ostringstream word; Paragraph::depth_type depth = 0; int ltype = 0; Paragraph::depth_type ltype_depth = 0; - unsigned int currlinelen = 0; + string::size_type currlinelen = 0; bool ref_printed = false; - - int noparbreak = 0; - int islatex = 0; - if (!par->previous()) { - // begins or ends a deeper area ? - if (depth != par->params().depth()) { - if (par->params().depth() > depth) { - while (par->params().depth() > depth) { - ++depth; - } - } else { - while (par->params().depth() < depth) { - --depth; - } +// if (!par->previous()) { +#if 0 + // begins or ends a deeper area ? + if (depth != par->params().depth()) { + if (par->params().depth() > depth) { + while (par->params().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 (contains(tmp, "ection")) { - ltype = 3; - ltype_depth = depth + 1; - } else if (contains(tmp, "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; + while (par->params().depth() < depth) { + --depth; + } } + } +#else + depth = par->params().depth(); +#endif - /* maybe some vertical spaces */ + // First write the layout + string const & tmp = lowercase(par->layout()); + if (tmp == "itemize") { + ltype = 1; + ltype_depth = depth + 1; + } else if (tmp == "enumerate") { + ltype = 2; + ltype_depth = depth + 1; + } else if (contains(tmp, "ection")) { + ltype = 3; + ltype_depth = depth + 1; + } else if (contains(tmp, "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; + } - /* the labelwidthstring used in lists */ + /* maybe some vertical spaces */ - /* some lines? */ + /* the labelwidthstring used in lists */ - /* some pagebreaks? */ + /* some lines? */ - /* noindent ? */ + /* some pagebreaks? */ - /* what about the alignment */ - } else { - lyxerr << "Should this ever happen?" << endl; - } - -#ifndef NO_LATEX - LyXFont const font1 = LyXFont(LyXFont::ALL_INHERIT, params.language); -#endif - for (Paragraph::size_type i = 0; i < par->size(); ++i) { - if (!i && !noparbreak) { + /* noindent ? */ + + /* what about the alignment */ +// } else { +// lyxerr << "Should this ever happen?" << endl; +// } + + // linelen <= 0 is special and means we don't have pargraph breaks + if (!noparbreak) { + if (linelen > 0) + buffer << "\n\n"; + for (Paragraph::depth_type j = 0; j < depth; ++j) + buffer << " "; + currlinelen = depth * 2; + //-- + // we should probably change to the paragraph language in the + // gettext here (if possible) so that strings are outputted in + // the correct language! (20012712 Jug) + //-- + switch (ltype) { + case 0: // Standard + case 4: // (Sub)Paragraph + case 5: // Description + break; + case 6: // Abstract if (linelen > 0) - buffer << "\n\n"; - for (Paragraph::depth_type 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 + buffer << _("Abstract") << "\n\n"; + else + buffer << _("Abstract: "); + break; + case 7: // Bibliography + if (!ref_printed) { if (linelen > 0) - buffer << "Abstract\n\n"; + buffer << _("References") << "\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->params().labelString() << " "; - break; - } - if (ltype_depth > depth) { - for (Paragraph::depth_type j = ltype_depth - 1; - j > depth; --j) - buffer << " "; - currlinelen += (ltype_depth-depth)*2; + buffer << _("References: "); + ref_printed = true; } + break; + default: + buffer << par->params().labelString() << " "; + break; } -#ifndef NO_LATEX - LyXFont const font2 = par->getFontSettings(params, i); - if (font1.latex() != font2.latex()) { - if (font2.latex() == LyXFont::OFF) - islatex = 0; - else - islatex = 1; - } else { - islatex = 0; + } + string s = buffer.str(); + if (s.rfind('\n') != string::npos) { + string dummy; + s = rsplit(buffer.str().c_str(), dummy, '\n'); + } + currlinelen = s.length(); + if (!currlinelen) { + for (Paragraph::depth_type j = 0; j < depth; ++j) + buffer << " "; + currlinelen = depth * 2; + if (ltype_depth > depth) { + for (Paragraph::depth_type j = ltype_depth; + j > depth; --j) + { + buffer << " "; + } + currlinelen += (ltype_depth-depth)*2; } -#endif - + } + // this is to change the linebreak to do it by word a bit more intelligent + // hopefully! (only in the case where we have a max linelenght!) (Jug) + for (pos_type i = 0; i < par->size(); ++i) { char c = par->getUChar(params, i); - if (islatex) - continue; switch (c) { case Paragraph::META_INSET: { Inset const * inset = par->getInset(i); if (inset) { - if (!inset->ascii(this, buffer)) { + if (linelen > 0) { + buffer << word.str(); + word.str(""); + } + if (inset->ascii(this, buffer, linelen)) { + // to be sure it breaks paragraph + currlinelen += linelen; + } +#if 0 + else { string dummy; string const s = rsplit(buffer.str().c_str(), dummy, '\n'); - currlinelen += s.length(); - } else { - // to be sure it breaks paragraph - currlinelen += linelen; + currlinelen = s.length(); } +#endif } } break; case Paragraph::META_NEWLINE: if (linelen > 0) { - buffer << "\n"; + buffer << word.str() << "\n"; + word.str(""); for (Paragraph::depth_type j = 0; j < depth; ++j) buffer << " "; + currlinelen = depth * 2; + if (ltype_depth > depth) { + for (Paragraph::depth_type j = ltype_depth; + j > depth; --j) + buffer << " "; + currlinelen += (ltype_depth - depth) * 2; + } } - currlinelen = depth * 2; - if (ltype_depth > depth) { - for (Paragraph::depth_type j = ltype_depth; - j > depth; --j) - buffer << " "; - currlinelen += (ltype_depth - depth) * 2; - } - break; - - case Paragraph::META_HFILL: - buffer << "\t"; break; - case '\\': - buffer << "\\"; + case Paragraph::META_HFILL: + buffer << word.str() << "\t"; + currlinelen += word.str().length() + 1; + word.str(""); break; - + default: - if ((linelen > 0) && (currlinelen > (linelen - 10)) && - (c == ' ') && ((i + 2) < par->size())) - { - buffer << "\n"; - for (Paragraph::depth_type j = 0; - j < depth; ++j) - buffer << " "; - currlinelen = depth * 2; - if (ltype_depth > depth) { - for (Paragraph::depth_type j = ltype_depth; - j > depth; --j) + if (c == ' ') { + buffer << word.str() << ' '; + currlinelen += word.str().length() + 1; + word.str(""); + } else { + if (c != '\0') { + word << c; + } else { + lyxerr[Debug::INFO] << + "writeAsciiFile: NULL char in structure." << endl; + } + if ((linelen > 0) && + (currlinelen+word.str().length()) > linelen) + { + buffer << "\n"; + for (Paragraph::depth_type j = 0; j < depth; ++j) buffer << " "; - currlinelen += (ltype_depth-depth)*2; + currlinelen = depth * 2; + if (ltype_depth > depth) { + for (Paragraph::depth_type j = ltype_depth; + j > depth; --j) + { + buffer << " "; + } + currlinelen += (ltype_depth-depth)*2; + } } - } else if (c != '\0') - buffer << c; - else if (c == '\0') - lyxerr[Debug::INFO] << "writeAsciiFile: NULL char in structure." << endl; - ++currlinelen; + } break; } } + buffer << word.str(); return buffer.str().c_str(); } @@ -1927,7 +1984,7 @@ void Buffer::writeFileAscii(string const & fname, int linelen) { ofstream ofs(fname.c_str()); if (!ofs) { - WriteFSAlert(_("Error: Cannot write file:"), fname); + Alert::err_alert(_("Error: Cannot write file:"), fname); return; } writeFileAscii(ofs, linelen); @@ -1938,14 +1995,16 @@ void Buffer::writeFileAscii(ostream & ofs, int linelen) { Paragraph * par = paragraph; while (par) { - ofs << asciiParagraph(par, linelen); + ofs << asciiParagraph(par, linelen, par->previous() == 0); par = par->next(); } ofs << "\n"; } + bool use_babel; + void Buffer::makeLaTeXFile(string const & fname, string const & original_path, bool nice, bool only_body) @@ -1957,17 +2016,17 @@ void Buffer::makeLaTeXFile(string const & fname, tex_code_break_column = lyxrc.ascii_linelen; LyXTextClass const & tclass = - textclasslist.TextClass(params.textclass); + textclasslist[params.textclass]; ofstream ofs(fname.c_str()); if (!ofs) { - WriteFSAlert(_("Error: Cannot open file: "), fname); + Alert::err_alert(_("Error: Cannot open file: "), fname); return; } // validate the buffer. lyxerr[Debug::LATEX] << " Validating buffer..." << endl; - LaTeXFeatures features(params, tclass.numLayouts()); + LaTeXFeatures features(params, tclass.size()); validate(features); lyxerr[Debug::LATEX] << " Buffer validation done." << endl; @@ -1977,7 +2036,7 @@ void Buffer::makeLaTeXFile(string const & fname, texrow.start(paragraph, 0); if (!only_body && nice) { - ofs << "%% " LYX_DOCVERSION " created this file. " + ofs << "%% " << lyx_docversion << " created this file. " "For more info, see http://www.lyx.org/.\n" "%% Do not edit unless you really know what " "you are doing.\n"; @@ -1995,7 +2054,7 @@ void Buffer::makeLaTeXFile(string const & fname, // original_path is set. This is done for usual tex-file, but not // for nice-latex-file. (Matthias 250696) if (!only_body) { - if (!nice){ + if (!nice) { // code for usual, NOT nice-latex-file ofs << "\\batchmode\n"; // changed // from \nonstopmode @@ -2076,16 +2135,13 @@ void Buffer::makeLaTeXFile(string const & fname, if (params.language->babel() == "hebrew" && default_language->babel() != "hebrew") // This seems necessary - features.UsedLanguages.insert(default_language); + features.useLanguage(default_language); if (lyxrc.language_use_babel || params.language->lang() != lyxrc.default_language || - !features.UsedLanguages.empty()) { + !features.hasLanguages()) { use_babel = true; - for (LaTeXFeatures::LanguageList::const_iterator cit = - features.UsedLanguages.begin(); - cit != features.UsedLanguages.end(); ++cit) - language_options << (*cit)->babel() << ','; + language_options << features.getLanguages(); language_options << params.language->babel(); if (lyxrc.language_global_options) options << language_options.str() << ','; @@ -2097,13 +2153,13 @@ void Buffer::makeLaTeXFile(string const & fname, } string strOptions(options.str().c_str()); - if (!strOptions.empty()){ + if (!strOptions.empty()) { strOptions = strip(strOptions, ','); ofs << '[' << strOptions << ']'; } ofs << '{' - << textclasslist.LatexnameOfClass(params.textclass) + << textclasslist[params.textclass].latexname() << "}\n"; texrow.newline(); // end of \documentclass defs @@ -2132,12 +2188,7 @@ void Buffer::makeLaTeXFile(string const & fname, // 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()); + set encodings = features.getEncodingSet(doc_encoding); ofs << "\\usepackage["; std::copy(encodings.begin(), encodings.end(), @@ -2253,11 +2304,6 @@ void Buffer::makeLaTeXFile(string const & fname, ofs << "}\n"; texrow.newline(); } - if (features.amsstyle - && !tclass.provides(LyXTextClass::amsmath)) { - ofs << "\\usepackage{amsmath}\n"; - texrow.newline(); - } if (tokenPos(tclass.opt_pagestyle(), '|', params.pagestyle) >= 0) { @@ -2269,19 +2315,6 @@ void Buffer::makeLaTeXFile(string const & fname, texrow.newline(); } - // We try to load babel late, in case it interferes - // with other packages. - if (use_babel) { - string tmp = lyxrc.language_package; - if (!lyxrc.language_global_options - && tmp == "\\usepackage{babel}") - tmp = string("\\usepackage[") + - language_options.str().c_str() + - "]{babel}"; - ofs << tmp << "\n"; - texrow.newline(); - } - if (params.secnumdepth != tclass.secnumdepth()) { ofs << "\\setcounter{secnumdepth}{" << params.secnumdepth @@ -2390,12 +2423,27 @@ void Buffer::makeLaTeXFile(string const & fname, if (!bullets_def.empty()) preamble += bullets_def + "}\n\n"; - for (int j = countChar(preamble, '\n'); j-- ;) { + int const nlines = + int(lyx::count(preamble.begin(), preamble.end(), '\n')); + for (int j = 0; j != nlines; ++j) { texrow.newline(); } ofs << preamble; + // We try to load babel late, in case it interferes + // with other packages. + if (use_babel) { + string tmp = lyxrc.language_package; + if (!lyxrc.language_global_options + && tmp == "\\usepackage{babel}") + tmp = string("\\usepackage[") + + language_options.str().c_str() + + "]{babel}"; + ofs << tmp << "\n"; + texrow.newline(); + } + // make the body. ofs << "\\begin{document}\n"; texrow.newline(); @@ -2447,6 +2495,7 @@ void Buffer::makeLaTeXFile(string const & fname, } lyxerr[Debug::INFO] << "Finished making latex file." << endl; + lyxerr[Debug::INFO] << "Row count was " << texrow.rows()-1 << "." << endl; } @@ -2454,33 +2503,41 @@ void Buffer::makeLaTeXFile(string const & fname, // LaTeX all paragraphs from par to endpar, if endpar == 0 then to the end // void Buffer::latexParagraphs(ostream & ofs, Paragraph * par, - Paragraph * endpar, TexRow & texrow) const + Paragraph * endpar, TexRow & texrow) const { bool was_title = false; bool already_title = false; // if only_body while (par != endpar) { - LyXLayout const & layout = - textclasslist.Style(params.textclass, - par->layout); - - if (layout.intitle) { - if (already_title) { - lyxerr <<"Error in latexParagraphs: You" - " should not mix title layouts" - " with normal ones." << endl; - } else - was_title = true; - } else if (was_title && !already_title) { - ofs << "\\maketitle\n"; - texrow.newline(); - already_title = true; - was_title = false; - } - - if (layout.isEnvironment()) { - par = par->TeXEnvironment(this, params, ofs, texrow); + Inset * in = par->inInset(); + // well we have to check if we are in an inset with unlimited + // lenght (all in one row) if that is true then we don't allow + // any special options in the paragraph and also we don't allow + // any environment other then "Standard" to be valid! + if ((in == 0) || !in->forceDefaultParagraphs(in)) { + LyXLayout const & layout = + textclasslist[params.textclass][par->layout()]; + + if (layout.intitle) { + if (already_title) { + lyxerr <<"Error in latexParagraphs: You" + " should not mix title layouts" + " with normal ones." << endl; + } else + was_title = true; + } else if (was_title && !already_title) { + ofs << "\\maketitle\n"; + texrow.newline(); + already_title = true; + was_title = false; + } + + if (layout.isEnvironment()) { + par = par->TeXEnvironment(this, params, ofs, texrow); + } else { + par = par->TeXOnePar(this, params, ofs, texrow, false); + } } else { par = par->TeXOnePar(this, params, ofs, texrow, false); } @@ -2495,32 +2552,34 @@ void Buffer::latexParagraphs(ostream & ofs, Paragraph * par, bool Buffer::isLatex() const { - return textclasslist.TextClass(params.textclass).outputType() == LATEX; + return textclasslist[params.textclass].outputType() == LATEX; } bool Buffer::isLinuxDoc() const { - return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC; + return textclasslist[params.textclass].outputType() == LINUXDOC; } bool Buffer::isLiterate() const { - return textclasslist.TextClass(params.textclass).outputType() == LITERATE; + return textclasslist[params.textclass].outputType() == LITERATE; } bool Buffer::isDocBook() const { - return textclasslist.TextClass(params.textclass).outputType() == DOCBOOK; + return textclasslist[params.textclass].outputType() == DOCBOOK; } bool Buffer::isSGML() const { - return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC || - textclasslist.TextClass(params.textclass).outputType() == DOCBOOK; + LyXTextClass const & tclass = textclasslist[params.textclass]; + + return tclass.outputType() == LINUXDOC || + tclass.outputType() == DOCBOOK; } @@ -2528,8 +2587,8 @@ void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type depth, string const & latexname) const { if (!latexname.empty() && latexname != "!-- --") - os << "" << "<" << latexname << ">"; - //os << string(depth, ' ') << "<" << latexname << ">\n"; + //os << "" << "<" << latexname << ">"; + os << string(depth, ' ') << "<" << latexname << ">\n"; } @@ -2537,8 +2596,8 @@ void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type depth, string const & latexname) const { if (!latexname.empty() && latexname != "!-- --") - os << "" << "\n"; - //os << string(depth, ' ') << "\n"; + //os << "" << "\n"; + os << string(depth, ' ') << "\n"; } @@ -2547,31 +2606,33 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) ofstream ofs(fname.c_str()); if (!ofs) { - WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname); + Alert::alert(_("LYX_ERROR:"), _("Cannot write file"), fname); return; } niceFile = nice; // this will be used by included files. - LyXTextClass const & tclass = - textclasslist.TextClass(params.textclass); + LyXTextClass const & tclass = textclasslist[params.textclass]; - LaTeXFeatures features(params, tclass.numLayouts()); + LaTeXFeatures features(params, tclass.size()); + validate(features); texrow.reset(); - string top_element = textclasslist.LatexnameOfClass(params.textclass); + string top_element = textclasslist[params.textclass].latexname(); if (!body_only) { - string sgml_includedfiles=features.getIncludedFiles(fname); + ofs << "\n\n"; - } else { - ofs << "\n\n"; + string preamble = params.preamble; + preamble += features.getIncludedFiles(fname); + preamble += features.getLyXSGMLEntities(); + + if (!preamble.empty()) { + ofs << " [ " << preamble << " ]"; } + ofs << ">\n\n"; if (params.options.empty()) sgmlOpenTag(ofs, 0, top_element); @@ -2583,7 +2644,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) } } - ofs << "\n"; @@ -2594,14 +2655,13 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) while (par) { LyXLayout const & style = - textclasslist.Style(params.textclass, - par->layout); + textclasslist[params.textclass][par->layout()]; // treat as a special case for compatibility with old code - if (par->getChar(0) == Paragraph::META_INSET) { + if (par->isInset(0)) { Inset * inset = par->getInset(0); Inset::Code lyx_code = inset->lyxCode(); - if (lyx_code == Inset::TOC_CODE){ + if (lyx_code == Inset::TOC_CODE) { string const temp = "toc"; sgmlOpenTag(ofs, depth, temp); @@ -2633,11 +2693,11 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) case LATEX_COMMAND: if (depth!= 0) - linuxDocError(par, 0, - _("Error : Wrong depth for" - " LatexType Command.\n")); + sgmlError(par, 0, + _("Error : Wrong depth for" + " LatexType Command.\n")); - if (!environment_stack[depth].empty()){ + if (!environment_stack[depth].empty()) { sgmlCloseTag(ofs, depth, environment_stack[depth]); ofs << "

"; @@ -2721,35 +2781,11 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) } -void Buffer::docBookHandleCaption(ostream & os, string & inner_tag, - Paragraph::depth_type depth, int desc_on, - Paragraph * & par) -{ - Paragraph * tpar = par; - while (tpar - && (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); - 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; - } -} - - // checks, if newcol chars should be put into this line // writes newline, if necessary. namespace { -void linux_doc_line_break(ostream & os, string::size_type & colcount, +void sgmlLineBreak(ostream & os, string::size_type & colcount, string::size_type newcol) { colcount += newcol; @@ -2794,22 +2830,20 @@ void operator|=(PAR_TAG & p1, PAR_TAG const & p2) inline void reset(PAR_TAG & p1, PAR_TAG const & p2) { - p1 = static_cast( p1 & ~p2); + p1 = static_cast(p1 & ~p2); } } // namespace anon - - // Handle internal paragraph parsing -- layout already processed. void Buffer::simpleLinuxDocOnePar(ostream & os, Paragraph * par, Paragraph::depth_type /*depth*/) { - LyXLayout const & style = textclasslist.Style(params.textclass, - par->getLayout()); - string::size_type char_line_count = 5; // Heuristic choice ;-) + LyXLayout const & style = + textclasslist[params.textclass][par->layout()]; + string::size_type char_line_count = 5; // Heuristic choice ;-) // gets paragraph main font LyXFont font_old; @@ -2827,9 +2861,9 @@ void Buffer::simpleLinuxDocOnePar(ostream & os, LyXFont::FONT_SHAPE shape_type = LyXFont::UP_SHAPE; bool is_em = false; - stack < PAR_TAG > tag_state; + stack tag_state; // parsing main loop - for (Paragraph::size_type i = 0; i < par->size(); ++i) { + for (pos_type i = 0; i < par->size(); ++i) { PAR_TAG tag_close = NONE; list < PAR_TAG > tag_open; @@ -2921,7 +2955,7 @@ void Buffer::simpleLinuxDocOnePar(ostream & os, } list < PAR_TAG > temp; - while(!tag_state.empty() && tag_close ) { + while (!tag_state.empty() && tag_close) { PAR_TAG k = tag_state.top(); tag_state.pop(); os << ""; @@ -2952,29 +2986,26 @@ void Buffer::simpleLinuxDocOnePar(ostream & os, continue; } - if ( -#ifndef NO_LATEX - font.latex() == LyXFont::ON || -#endif - style.latexparam() == "CDATA") { + if (style.latexparam() == "CDATA") { // "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) { + if (par->sgmlConvertChar(c, sgml_string) + && !style.free_spacing && !par->isFreeSpacing()) + { // in freespacing mode, spaces are // non-breaking characters if (desc_on) {// if char is ' ' then... ++char_line_count; - linux_doc_line_break(os, char_line_count, 6); + sgmlLineBreak(os, char_line_count, 6); os << ""; desc_on = false; } else { - linux_doc_line_break(os, char_line_count, 1); + sgmlLineBreak(os, char_line_count, 1); os << c; } } else { @@ -2993,19 +3024,20 @@ void Buffer::simpleLinuxDocOnePar(ostream & os, // resets description flag correctly if (desc_on) { // not closed... - linux_doc_line_break(os, char_line_count, 6); + sgmlLineBreak(os, char_line_count, 6); os << ""; } } // Print an error message. -void Buffer::linuxDocError(Paragraph * par, int pos, - string const & message) +void Buffer::sgmlError(Paragraph * par, int pos, + string const & message) const { // insert an error marker in text InsetError * new_inset = new InsetError(message); - par->insertInset(pos, new_inset); + par->insertInset(pos, new_inset, LyXFont(LyXFont::ALL_INHERIT, + params.language)); } @@ -3013,7 +3045,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) { ofstream ofs(fname.c_str()); if (!ofs) { - WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname); + Alert::alert(_("LYX_ERROR:"), _("Cannot write file"), fname); return; } @@ -3022,26 +3054,27 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) niceFile = nice; // this will be used by Insetincludes. LyXTextClass const & tclass = - textclasslist.TextClass(params.textclass); + textclasslist[params.textclass]; - LaTeXFeatures features(params, tclass.numLayouts()); + LaTeXFeatures features(params, tclass.size()); validate(features); texrow.reset(); - string top_element = textclasslist.LatexnameOfClass(params.textclass); + string top_element = textclasslist[params.textclass].latexname(); if (!only_body) { - string sgml_includedfiles = features.getIncludedFiles(fname); + ofs << "\n\n"; - else - ofs << "\n [ " << params.preamble - << sgml_includedfiles << " \n]>\n\n"; + if (!preamble.empty()) { + ofs << "\n [ " << preamble << " ]"; + } + ofs << ">\n\n"; } string top = top_element; @@ -3055,7 +3088,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } sgmlOpenTag(ofs, 0, top); - ofs << "\n"; vector environment_stack(10); @@ -3078,8 +3111,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) int desc_on = 0; // description mode LyXLayout const & style = - textclasslist.Style(params.textclass, - par->layout); + textclasslist[params.textclass][par->layout()]; // environment tag closing for (; depth > par->params().depth(); --depth) { @@ -3126,9 +3158,9 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) case LATEX_COMMAND: if (depth != 0) - linuxDocError(par, 0, - _("Error : Wrong depth for " - "LatexType Command.\n")); + sgmlError(par, 0, + _("Error : Wrong depth for " + "LatexType Command.\n")); command_name = style.latexname(); @@ -3158,10 +3190,12 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) // treat label as a special case for // more WYSIWYM handling. - if (par->getChar(0) == Paragraph::META_INSET) { + // This is a hack while paragraphs can't have + // attributes, like id in this case. + if (par->isInset(0)) { Inset * inset = par->getInset(0); Inset::Code lyx_code = inset->lyxCode(); - if (lyx_code == Inset::LABEL_CODE){ + if (lyx_code == Inset::LABEL_CODE) { command_name += " id=\""; command_name += (static_cast(inset))->getContents(); command_name += "\""; @@ -3185,7 +3219,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } if (environment_stack[depth] != style.latexname()) { - if(environment_stack.size() == depth + 1) { + if (environment_stack.size() == depth + 1) { environment_stack.push_back("!-- --"); environment_inner.push_back("!-- --"); } @@ -3208,7 +3242,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) if (style.latextype == LATEX_ENVIRONMENT) { if (!style.latexparam().empty()) { - if(style.latexparam() == "CDATA") + if (style.latexparam() == "CDATA") ofs << "next(); string end_tag; @@ -3260,7 +3292,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) break; case LATEX_ENVIRONMENT: if (!style.latexparam().empty()) { - if(style.latexparam() == "CDATA") + if (style.latexparam() == "CDATA") ofs << "]]>"; else sgmlCloseTag(ofs, depth + command_depth, @@ -3310,14 +3342,14 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } -void Buffer::simpleDocBookOnePar(ostream & os, string & extra, +void Buffer::simpleDocBookOnePar(ostream & os, Paragraph * par, int & desc_on, Paragraph::depth_type depth) const { bool emph_flag = false; - LyXLayout const & style = textclasslist.Style(params.textclass, - par->getLayout()); + LyXLayout const & style = + textclasslist[params.textclass][par->layout()]; LyXFont font_old = style.labeltype == LABEL_MANUAL ? style.labelfont : style.font; @@ -3326,8 +3358,7 @@ void Buffer::simpleDocBookOnePar(ostream & os, string & extra, // os << string(depth,' '); // parsing main loop - for (Paragraph::size_type i = 0; - i < par->size(); ++i) { + for (pos_type i = 0; i < par->size(); ++i) { LyXFont font = par->getFont(params, i); // handle tag @@ -3335,63 +3366,38 @@ void Buffer::simpleDocBookOnePar(ostream & os, string & extra, if (font.emph() == LyXFont::ON) { os << ""; emph_flag = true; - }else if(i) { + } else if (i) { os << ""; emph_flag = false; } } - char c = par->getChar(i); - if (c == Paragraph::META_INSET) { + if (par->isInset(i)) { Inset * inset = par->getInset(i); - ostringstream ost; - inset->docBook(this, ost); - string tmp_out = ost.str().c_str(); - - // - // 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; + // don't print the inset in position 0 if desc_on == 3 (label) + if ( i || desc_on != 3) { + if(style.latexparam() == "CDATA") + os << "]]>"; + inset->docbook(this, os); + if(style.latexparam() == "CDATA") + os << " SGML-Mode on. - if (c != '\0') - os << c; - ++char_line_count; -#endif } else { + char c = par->getChar(i); 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; - } + par->sgmlConvertChar(c, sgml_string); + + if (style.pass_thru) { + os << c; + } else if (style.free_spacing || par->isFreeSpacing() || c != ' ') { + os << sgml_string; + } else if (desc_on ==1) { + ++char_line_count; + os << "\n"; + desc_on = 2; } else { - os << sgml_string; + os << ' '; } } font_old = font; @@ -3406,7 +3412,7 @@ void Buffer::simpleDocBookOnePar(ostream & os, string & extra, // not closed... os << ""; } - if(style.free_spacing) os << '\n'; + if (style.free_spacing) os << '\n'; } @@ -3421,10 +3427,10 @@ int Buffer::runChktex() // get LaTeX-Filename string const name = getLatexName(); - string path = OnlyPath(filename); + string path = filePath(); string const org_path = path; - if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) { + if (lyxrc.use_tempdir || !IsDirWriteable(path)) { path = tmppath; } @@ -3438,11 +3444,11 @@ int Buffer::runChktex() 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) { - WriteAlert(_("chktex did not work!"), + Alert::alert(_("chktex did not work!"), _("Could not run with file:"), name); } else if (res > 0) { // Insert all errors as errors boxes @@ -3451,9 +3457,9 @@ 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 (removedErrorInsets || res){ + if (removedErrorInsets || res) { users->redraw(); - users->fitCursor(users->text); + users->fitCursor(); } users->owner()->allowInput(); @@ -3464,12 +3470,11 @@ int Buffer::runChktex() void Buffer::validate(LaTeXFeatures & features) const { Paragraph * par = paragraph; - LyXTextClass const & tclass = - textclasslist.TextClass(params.textclass); + LyXTextClass const & tclass = textclasslist[params.textclass]; // AMS Style is at document level - features.amsstyle = (params.use_amsmath || - tclass.provides(LyXTextClass::amsmath)); + if (params.use_amsmath || tclass.provides(LyXTextClass::amsmath)) + features.require("amsmath"); while (par) { // We don't use "lyxerr.debug" because of speed. (Asger) @@ -3498,12 +3503,12 @@ void Buffer::validate(LaTeXFeatures & features) const || c == 25 || c == 26 || c == 31) { - features.latexsym = true; + features.require("latexsym"); } } else if (font == 1) { - features.amssymb = true; + features.require("amssymb"); } else if ((font >= 2 && font <= 5)) { - features.pifont = true; + features.require("pifont"); } } } @@ -3514,33 +3519,6 @@ void Buffer::validate(LaTeXFeatures & features) const } -void Buffer::setPaperStuff() -{ - params.papersize = BufferParams::PAPER_DEFAULT; - char const c1 = params.paperpackage; - if (c1 == BufferParams::PACKAGE_NONE) { - char const c2 = params.papersize2; - if (c2 == BufferParams::VM_PAPER_USLETTER) - params.papersize = BufferParams::PAPER_USLETTER; - else if (c2 == BufferParams::VM_PAPER_USLEGAL) - params.papersize = BufferParams::PAPER_LEGALPAPER; - else if (c2 == BufferParams::VM_PAPER_USEXECUTIVE) - params.papersize = BufferParams::PAPER_EXECUTIVEPAPER; - else if (c2 == BufferParams::VM_PAPER_A3) - params.papersize = BufferParams::PAPER_A3PAPER; - else if (c2 == BufferParams::VM_PAPER_A4) - params.papersize = BufferParams::PAPER_A4PAPER; - else if (c2 == BufferParams::VM_PAPER_A5) - params.papersize = BufferParams::PAPER_A5PAPER; - else if ((c2 == BufferParams::VM_PAPER_B3) || (c2 == BufferParams::VM_PAPER_B4) || - (c2 == BufferParams::VM_PAPER_B5)) - params.papersize = BufferParams::PAPER_B5PAPER; - } else if ((c1 == BufferParams::PACKAGE_A4) || (c1 == BufferParams::PACKAGE_A4WIDE) || - (c1 == BufferParams::PACKAGE_WIDEMARGINSA4)) - params.papersize = BufferParams::PAPER_A4PAPER; -} - - // This function should be in Buffer because it's a buffer's property (ale) string const Buffer::getIncludeonlyList(char delim) { @@ -3587,15 +3565,13 @@ Buffer::Lists const Buffer::getLists() const { Lists l; Paragraph * par = paragraph; - bool found; - LyXTextClassList::size_type cap; - boost::tie(found, cap) = textclasslist - .NumberOfLayout(params.textclass, "Caption"); + + LyXTextClass const & textclass = textclasslist[params.textclass]; + bool found = textclass.hasLayout("caption"); + string const layout("caption"); while (par) { - char const labeltype = - textclasslist.Style(params.textclass, - par->getLayout()).labeltype; + char const labeltype = textclass[par->layout()].labeltype; if (labeltype >= LABEL_COUNTER_CHAPTER && labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) { @@ -3603,7 +3579,7 @@ Buffer::Lists const Buffer::getLists() const SingleList & item = l["TOC"]; int depth = max(0, labeltype - - textclasslist.TextClass(params.textclass).maxcounter()); + textclass.maxcounter()); item.push_back(TocItem(par, depth, par->asString(this, true))); } // For each paragrph, traverse its insets and look for @@ -3627,7 +3603,7 @@ Buffer::Lists const Buffer::getLists() const // the inset... Paragraph * tmp = il->inset.paragraph(); while (tmp) { - if (tmp->layout == cap) { + if (tmp->layout() == layout) { SingleList & item = l[type]; string const str = tostr(item.size()+1) + ". " + tmp->asString(this, false); @@ -3760,35 +3736,31 @@ void Buffer::resizeInsets(BufferView * bv) void Buffer::redraw() { users->redraw(); - users->fitCursor(users->text); + users->fitCursor(); } void Buffer::changeLanguage(Language const * from, Language const * to) { - Paragraph * par = paragraph; - while (par) { - par->changeLanguage(params, from, to); - par = par->next(); - } + ParIterator end = par_iterator_end(); + for (ParIterator it = par_iterator_begin(); it != end; ++it) + (*it)->changeLanguage(params, from, to); } bool Buffer::isMultiLingual() { - Paragraph * par = paragraph; - while (par) { - if (par->isMultiLingual(params)) + ParIterator end = par_iterator_end(); + for (ParIterator it = par_iterator_begin(); it != end; ++it) + if ((*it)->isMultiLingual(params)) return true; - par = par->next(); - } + return false; } -Buffer::inset_iterator::inset_iterator(Paragraph * paragraph, - Paragraph::size_type pos) +Buffer::inset_iterator::inset_iterator(Paragraph * paragraph, pos_type pos) : par(paragraph) { it = par->InsetIterator(pos); @@ -3843,3 +3815,15 @@ Paragraph * Buffer::getParFromID(int id) const } return 0; } + + +ParIterator Buffer::par_iterator_begin() +{ + return ParIterator(paragraph); +} + + +ParIterator Buffer::par_iterator_end() +{ + return ParIterator(); +}