X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.C;h=de4866e3b9b9d6aa9ae4fec9dac6902fe679cb8e;hb=0233b6753d5a7ef67263c3111411be04765c629b;hp=68e11ca773c89ceb83e0c568d4ebef6c651081a7;hpb=8ac09fc110330afe2dfeff72cf2bd6fdf734d82c;p=lyx.git diff --git a/src/buffer.C b/src/buffer.C index 68e11ca773..de4866e3b9 100644 --- a/src/buffer.C +++ b/src/buffer.C @@ -4,9 +4,9 @@ * LyX, The Document Processor * * Copyright 1995 Matthias Ettrich - * Copyright 1995-2000 The LyX Team. + * Copyright 1995-2001 The LyX Team. * - * This file is Copyright 1996-1999 + * This file is Copyright 1996-2001 * Lars Gullik Bjønnes * * ====================================================== @@ -32,6 +32,8 @@ #include #endif +#include + #ifdef __GNUG__ #pragma implementation #endif @@ -49,12 +51,13 @@ #include "lyxfont.h" #include "version.h" #include "mathed/formulamacro.h" -#include "insets/lyxinset.h" +#include "mathed/formula.h" +#include "insets/inset.h" #include "insets/inseterror.h" #include "insets/insetlabel.h" #include "insets/insetref.h" #include "insets/inseturl.h" -#include "insets/insetinfo.h" +#include "insets/insetnote.h" #include "insets/insetquotes.h" #include "insets/insetlatexaccent.h" #include "insets/insetbib.h" @@ -73,13 +76,17 @@ #include "insets/insetmarginal.h" #include "insets/insetminipage.h" #include "insets/insetfloat.h" -#include "insets/insetlist.h" #include "insets/insettabular.h" +#if 0 #include "insets/insettheorem.h" +#include "insets/insetlist.h" +#endif #include "insets/insetcaption.h" #include "insets/insetfloatlist.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" @@ -98,8 +105,10 @@ #include "exporter.h" #include "Lsstream.h" #include "converter.h" +#include "BufferView.h" +#include "ParagraphParameters.h" +#include "iterators.h" -using std::stringstream; using std::ostream; using std::ofstream; using std::ifstream; @@ -123,7 +132,7 @@ extern LyXAction lyxaction; namespace { -const int LYX_FORMAT = 218; +const int LYX_FORMAT = 220; } // namespace anon @@ -164,8 +173,8 @@ Buffer::~Buffer() DestroyBufferTmpDir(tmppath); } - LyXParagraph * par = paragraph; - LyXParagraph * tmppar; + Paragraph * par = paragraph; + Paragraph * tmppar; while (par) { tmppar = par->next(); delete par; @@ -177,12 +186,11 @@ Buffer::~Buffer() string const Buffer::getLatexName(bool no_path) const { + string name = ChangeExtension(MakeLatexName(filename), ".tex"); if (no_path) - return OnlyFilename(ChangeExtension(MakeLatexName(filename), - ".tex")); + return OnlyFilename(name); else - return ChangeExtension(MakeLatexName(filename), - ".tex"); + return name; } @@ -195,7 +203,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, @@ -204,7 +212,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 @@ -244,7 +252,7 @@ bool Buffer::saveParamsAsDefaults() // const defaults.params = params; // add an empty paragraph. Is this enough? - defaults.paragraph = new LyXParagraph; + defaults.paragraph = new Paragraph; return defaults.writeFile(defaults.filename, false); } @@ -275,6 +283,31 @@ void Buffer::setFileName(string const & newfile) } +// We'll remove this later. (Lgb) +namespace { + +string last_inset_read; + +#ifndef NO_COMPABILITY +struct ErtComp +{ + ErtComp() : active(false), in_tabular(false) { + } + string contents; + bool active; + bool in_tabular; +}; + +std::stack ert_stack; +ErtComp ert_comp; +#endif + +#warning And _why_ is this here? (Lgb) +int unknown_layouts; + +} // anon + + // candidate for move to BufferView // (at least some parts in the beginning of the func) // @@ -283,111 +316,153 @@ void Buffer::setFileName(string const & newfile) // if par = 0 normal behavior // else insert behavior // Returns false if "\the_end" is not read for formats >= 2.13. (Asger) -bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par) +bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par) { + unknown_layouts = 0; +#ifndef NO_COMPABILITY + ert_comp.contents.erase(); + ert_comp.active = false; + ert_comp.in_tabular = false; +#endif int pos = 0; - char depth = 0; // signed or unsigned? + Paragraph::depth_type depth = 0; bool the_end_read = false; - LyXParagraph * return_par = 0; + Paragraph * first_par = 0; LyXFont font(LyXFont::ALL_INHERIT, params.language); if (file_format < 216 && 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) { - par = new LyXParagraph; + par = new Paragraph; } else { - users->text->BreakParagraph(users); - return_par = users->text->FirstParagraph(); + // We are inserting into an existing document + users->text->breakParagraph(users); + first_par = users->text->firstParagraph(); 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(); - pretoken = lex.GetString(); + string const pretoken = lex.getString(); if (pretoken == "\\layout") { - has_token = true; + lex.pushToken(pretoken); break; } } } - while (lex.IsOK()) { - if (has_token) { - has_token = false; - } else { - lex.nextToken(); - pretoken = lex.GetString(); - } + while (lex.isOK()) { + lex.nextToken(); + string const token = lex.getString(); + + if (token.empty()) continue; - if (pretoken.empty()) continue; + lyxerr[Debug::PARSER] << "Handling token: `" + << token << "'" << endl; the_end_read = - parseSingleLyXformat2Token(lex, par, return_par, - pretoken, pos, depth, - font - ); + parseSingleLyXformat2Token(lex, par, first_par, + token, pos, depth, + font); } - if (!return_par) - return_par = par; + if (!first_par) + first_par = par; - paragraph = return_par; - - return the_end_read; -} + paragraph = first_par; + if (unknown_layouts > 0) { + string s = _("Couldn't set the layout for "); + if (unknown_layouts == 1) { + s += _("one paragraph"); + } else { + s += tostr(unknown_layouts); + s += _(" paragraphs"); + } + WriteAlert(_("Textclass Loading Error!"), s, + _("When reading " + fileName())); + } -// We'll remove this later. (Lgb) -namespace { + return the_end_read; +} -string last_inset_read; -} // anon +#ifndef NO_COMPABILITY +void Buffer::insertErtContents(Paragraph * par, int & pos, + LyXFont const & font, 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); + ert_comp.contents.erase(); + } + if (set_inactive) { + ert_comp.active = false; + } +} +#endif bool -Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, - LyXParagraph *& return_par, +Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par, + Paragraph *& first_par, string const & token, int & pos, - char & depth, LyXFont & font + Paragraph::depth_type & depth, + LyXFont & font ) { 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. - static int call_depth = 0; + static int call_depth; ++call_depth; bool checkminipage = false; - static LyXParagraph * minipar = 0; - static LyXParagraph * parBeforeMinipage = 0; + static Paragraph * minipar; + static Paragraph * parBeforeMinipage; +#endif #endif - if (token[0] != '\\') { +#ifndef NO_COMPABILITY + if (ert_comp.active) { + ert_comp.contents += token; + } else { +#endif for (string::const_iterator cit = token.begin(); - cit != token.end(); ++cit) - { - par->InsertChar(pos, (*cit), font); + cit != token.end(); ++cit) { + par->insertChar(pos, (*cit), font); ++pos; } - checkminipage = true; +#ifndef NO_COMPABILITY + } +#endif } else if (token == "\\i") { Inset * inset = new InsetLatexAccent; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); + inset->read(this, lex); + par->insertInset(pos, inset, font); ++pos; } else if (token == "\\layout") { - lex.EatLine(); - string const layoutname = lex.GetString(); +#ifndef NO_COMPABILITY + ert_comp.in_tabular = false; + // Do the insetert. + insertErtContents(par, pos, font); +#endif + lex.eatLine(); + string const layoutname = lex.getString(); pair pp = textclasslist.NumberOfLayout(params.textclass, layoutname); +#ifndef NO_COMPABILITY + if (compare_no_case(layoutname, "latex") == 0) { + ert_comp.active = true; + } +#endif #ifdef USE_CAPTION // The is the compability reading of layout caption. // It can be removed in LyX version 1.3.0. (Lgb) @@ -441,19 +516,28 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, ++pos; } else { #endif - if (!return_par) - return_par = par; + if (!first_par) + first_par = par; else { - par->fitToSize(); - par = new LyXParagraph(par); + par = new Paragraph(par); } pos = 0; if (pp.first) { par->layout = pp.second; +#ifndef NO_COMPABILITY + } else if (ert_comp.active) { + par->layout = 0; +#endif } 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); } // Test whether the layout is obsolete. LyXLayout const & layout = @@ -464,7 +548,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, .NumberOfLayout(params.textclass, layout.obsoleted_by()) .second; - par->params.depth(depth); + par->params().depth(depth); font = LyXFont(LyXFont::ALL_INHERIT, params.language); if (file_format < 216 && params.language->lang() == "hebrew") @@ -473,11 +557,17 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } #endif +#ifndef NO_COMPABILITY } else if (token == "\\begin_float") { + insertErtContents(par, pos, font); + //insertErtContents(par, pos, font, 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; @@ -485,42 +575,56 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& 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"; + old_float << "placement htbp\n" + << "wide false\n" + << "collapsed false\n"; } else if (tmptok == "tab") { inset = new InsetFloat("table"); - old_float << "placement htbp\n"; + old_float << "placement htbp\n" + << "wide false\n" + << "collapsed false\n"; } else if (tmptok == "alg") { inset = new InsetFloat("algorithm"); - old_float << "placement htbp\n"; + old_float << "placement htbp\n" + << "wide false\n" + << "collapsed false\n"; } else if (tmptok == "wide-fig") { - InsetFloat * tmp = new InsetFloat("figure"); - tmp->wide(true); - inset = tmp; - old_float << "placement htbp\n"; + inset = new InsetFloat("figure"); + //InsetFloat * tmp = new InsetFloat("figure"); + //tmp->wide(true); + //inset = tmp; + old_float << "placement htbp\n" + << "wide true\n" + << "collapsed false\n"; } else if (tmptok == "wide-tab") { - InsetFloat * tmp = new InsetFloat("table"); - tmp->wide(true); - inset = tmp; - old_float << "placement htbp\n"; + inset = new InsetFloat("table"); + //InsetFloat * tmp = new InsetFloat("table"); + //tmp->wide(true); + //inset = tmp; + old_float << "placement htbp\n" + << "wide true\n" + << "collapsed false\n"; } if (!inset) { +#ifndef NO_PEXTRA_REALLY --call_depth; +#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) { @@ -543,9 +647,11 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, istringstream istr(old_float.str()); LyXLex nylex(0, 0); nylex.setStream(istr); - inset->Read(this, nylex); - par->InsertInset(pos, inset, font); + inset->read(this, nylex); + par->insertInset(pos, inset, font); ++pos; + insertErtContents(par, pos, font); +#endif } else if (token == "\\begin_deeper") { ++depth; } else if (token == "\\end_deeper") { @@ -558,15 +664,15 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } else if (token == "\\begin_preamble") { params.readPreamble(lex); } else if (token == "\\textclass") { - lex.EatLine(); + lex.eatLine(); pair pp = - textclasslist.NumberOfClass(lex.GetString()); + textclasslist.NumberOfClass(lex.getString()); if (pp.first) { params.textclass = pp.second; } else { WriteAlert(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; } @@ -583,52 +689,52 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, 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); + par->params().noindent(true); } else if (token == "\\fill_top") { - par->params.spaceTop(VSpace(VSpace::VFILL)); + par->params().spaceTop(VSpace(VSpace::VFILL)); } else if (token == "\\fill_bottom") { - par->params.spaceBottom(VSpace(VSpace::VFILL)); + par->params().spaceBottom(VSpace(VSpace::VFILL)); } else if (token == "\\line_top") { - par->params.lineTop(true); + par->params().lineTop(true); } else if (token == "\\line_bottom") { - par->params.lineBottom(true); + par->params().lineBottom(true); } else if (token == "\\pagebreak_top") { - par->params.pagebreakTop(true); + par->params().pagebreakTop(true); } else if (token == "\\pagebreak_bottom") { - par->params.pagebreakBottom(true); + par->params().pagebreakBottom(true); } else if (token == "\\start_of_appendix") { - par->params.startOfAppendix(true); + par->params().startOfAppendix(true); } else if (token == "\\paragraph_separation") { - int 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 = static_cast(tmpret); } else if (token == "\\defskip") { lex.nextToken(); - params.defskip = VSpace(lex.GetString()); + params.defskip = VSpace(lex.getString()); } 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") { - int 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 = @@ -657,7 +763,7 @@ 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; @@ -666,13 +772,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& 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; @@ -680,75 +786,81 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& 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(); + } else if (token == "\\use_numerical_citations") { + lex.nextToken(); + params.use_numerical_citations = lex.getInteger(); } else if (token == "\\paperorientation") { - int 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); } 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 @@ -759,9 +871,9 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } } else if (token == "\\bulletLaTeX") { 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 @@ -772,19 +884,19 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& 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") { @@ -796,64 +908,68 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& 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'"); } // Small hack so that files written with klyx will be // parsed correctly. - if (return_par) { - par->params.spacing(Spacing(tmp_space, tmp_val)); + if (first_par) { + par->params().spacing(Spacing(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()); + string const tmp = strip(lex.getString()); if (tmp == "single") { - par->params.spacing(Spacing(Spacing::Single)); + par->params().spacing(Spacing(Spacing::Single)); } else if (tmp == "onehalf") { - par->params.spacing(Spacing(Spacing::Onehalf)); + par->params().spacing(Spacing(Spacing::Onehalf)); } else if (tmp == "double") { - par->params.spacing(Spacing(Spacing::Double)); + par->params().spacing(Spacing(Spacing::Double)); } else if (tmp == "other") { lex.next(); - par->params.spacing(Spacing(Spacing::Other, - lex.GetFloat())); + par->params().spacing(Spacing(Spacing::Other, + 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()); + 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 + string const tok = lex.getString(); + if (tok == "no_latex") { + // Do the insetert. + insertErtContents(par, pos, font); + } else if (tok == "latex") { + ert_comp.active = true; + } else if (tok == "default") { + // Do the insetert. + insertErtContents(par, pos, font); + } else { lex.printError("Unknown LaTeX font flag " "`$$Token'"); + } +#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); @@ -863,13 +979,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& 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); @@ -882,47 +998,49 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& 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)); //lyxerr << "Tmpret2 = " << tmpret2 << endl; - par->params.align(LyXAlignment(tmpret2)); + par->params().align(LyXAlignment(tmpret2)); } } else if (token == "\\added_space_top") { lex.nextToken(); - par->params.spaceTop(VSpace(lex.GetString())); + par->params().spaceTop(VSpace(lex.getString())); } else if (token == "\\added_space_bottom") { lex.nextToken(); - par->params.spaceBottom(VSpace(lex.GetString())); + par->params().spaceBottom(VSpace(lex.getString())); +#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" @@ -933,22 +1051,32 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, // But insets should read it, it is a part of // the inset isn't it? Lgb. } else if (token == "\\begin_inset") { +#ifndef NO_COMPABILITY + insertErtContents(par, pos, font, false); + ert_stack.push(ert_comp); + ert_comp = ErtComp(); +#endif readInset(lex, par, pos, font); +#ifndef NO_COMPABILITY + ert_comp = ert_stack.top(); + ert_stack.pop(); + insertErtContents(par, pos, font); +#endif } else if (token == "\\SpecialChar") { LyXLayout const & layout = textclasslist.Style(params.textclass, - par->GetLayout()); + par->getLayout()); // Insets don't make sense in a free-spacing context! ---Kayvan if (layout.free_spacing) { - if (lex.IsOK()) { + if (lex.isOK()) { lex.next(); - string next_token = lex.GetString(); + string next_token = lex.getString(); if (next_token == "\\-") { - par->InsertChar(pos, '-', font); + par->insertChar(pos, '-', font); } else if (next_token == "\\protected_separator" || next_token == "~") { - par->InsertChar(pos, ' ', font); + par->insertChar(pos, ' ', font); } else { lex.printError("Token `$$Token' " "is in free space " @@ -958,23 +1086,37 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, } } else { Inset * inset = new InsetSpecialChar; - inset->Read(this, lex); - par->InsertInset(pos, inset, font); + inset->read(this, lex); + par->insertInset(pos, inset, font); } ++pos; } else if (token == "\\newline") { - par->InsertChar(pos, LyXParagraph::META_NEWLINE, font); +#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); + + par->insertChar(pos, Paragraph::META_NEWLINE, font); + ++pos; + } +#else + par->insertChar(pos, Paragraph::META_NEWLINE, font); ++pos; +#endif } else if (token == "\\LyXTable") { +#ifndef NO_COMPABILITY + ert_comp.in_tabular = true; +#endif Inset * inset = new InsetTabular(*this); - inset->Read(this, lex); - par->InsertInset(pos, inset, font); + inset->read(this, lex); + par->insertInset(pos, inset, font); ++pos; - // because of OLD_TABULAR_READ where tabulars have been - // one paragraph. - checkminipage = true; } else if (token == "\\hfill") { - par->InsertChar(pos, LyXParagraph::META_HFILL, font); + par->insertChar(pos, Paragraph::META_HFILL, font); ++pos; } else if (token == "\\protected_separator") { // obsolete // This is a backward compability thingie. (Lgb) @@ -982,13 +1124,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, // 2.16. (Lgb) LyXLayout const & layout = textclasslist.Style(params.textclass, - par->GetLayout()); + par->getLayout()); if (layout.free_spacing) { - par->InsertChar(pos, ' ', font); + par->insertChar(pos, ' ', font); } else { Inset * inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR); - par->InsertInset(pos, inset, font); + par->insertInset(pos, inset, font); } ++pos; } else if (token == "\\bibitem") { // ale970302 @@ -996,25 +1138,61 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, InsetCommandParams p("bibitem", "dummy"); par->bibkey = new InsetBibKey(p); } - par->bibkey->Read(this, lex); + par->bibkey->read(this, lex); } else if (token == "\\backslash") { - par->InsertChar(pos, '\\', font); +#ifndef NO_COMPABILITY + if (ert_comp.active) { + ert_comp.contents += "\\"; + } else { +#endif + par->insertChar(pos, '\\', font); ++pos; +#ifndef NO_COMPABILITY + } +#endif } else if (token == "\\the_end") { +#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); +#endif the_end_read = true; +#ifndef NO_COMPABILITY +#ifndef NO_PEXTRA_REALLY minipar = parBeforeMinipage = 0; +#endif +#endif } else { +#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); + par->insertChar(pos, (*cit), font); ++pos; } +#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()) { + // It is possible that this will check to often, + // but that should not be an correctness issue. + // Only a speed issue. + checkminipage = true; + } + // now check if we have a minipage paragraph as at this // point we already read all the necessary data! // this cannot be done in layout because there we did @@ -1034,53 +1212,53 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, if (checkminipage && (call_depth == 1)) { checkminipage = false; if (minipar && (minipar != par) && - (par->params.pextraType()==LyXParagraph::PEXTRA_MINIPAGE)) + (par->params().pextraType()==Paragraph::PEXTRA_MINIPAGE)) { lyxerr << "minipages in a row" << endl; - if (par->params.pextraStartMinipage()) { + if (par->params().pextraStartMinipage()) { lyxerr << "start new minipage" << endl; // minipages in a row par->previous()->next(0); par->previous(0); - LyXParagraph * tmp = minipar; + Paragraph * tmp = minipar; while (tmp) { - tmp->params.pextraType(0); - tmp->params.pextraWidth(string()); - tmp->params.pextraWidthp(string()); - tmp->params.pextraAlignment(0); - tmp->params.pextraHfill(false); - tmp->params.pextraStartMinipage(false); + tmp->params().pextraType(0); + tmp->params().pextraWidth(string()); + tmp->params().pextraWidthp(string()); + tmp->params().pextraAlignment(0); + tmp->params().pextraHfill(false); + tmp->params().pextraStartMinipage(false); tmp = tmp->next(); } // create a new paragraph to insert the // minipages in the following case - if (par->params.pextraStartMinipage() && - !par->params.pextraHfill()) + if (par->params().pextraStartMinipage() && + !par->params().pextraHfill()) { - LyXParagraph * p = new LyXParagraph; + Paragraph * p = new Paragraph; p->layout = 0; p->previous(parBeforeMinipage); parBeforeMinipage->next(p); p->next(0); - p->params.depth(parBeforeMinipage->params.depth()); + p->params().depth(parBeforeMinipage->params().depth()); parBeforeMinipage = p; } InsetMinipage * mini = new InsetMinipage; - mini->pos(static_cast(par->params.pextraAlignment())); - mini->width(par->params.pextraWidth()); - if (!par->params.pextraWidthp().empty()) { + mini->pos(static_cast(par->params().pextraAlignment())); + mini->width(par->params().pextraWidth()); + if (!par->params().pextraWidthp().empty()) { lyxerr << "WP:" << mini->width() << endl; - mini->width(tostr(par->params.pextraWidthp())+"%"); + mini->width(tostr(par->params().pextraWidthp())+"%"); } - mini->inset.par = par; + mini->inset.paragraph(par); // Insert the minipage last in the // previous paragraph. - if (par->params.pextraHfill()) { - parBeforeMinipage->InsertChar - (parBeforeMinipage->size(), LyXParagraph::META_HFILL); + if (par->params().pextraHfill()) { + parBeforeMinipage->insertChar + (parBeforeMinipage->size(), Paragraph::META_HFILL); } - parBeforeMinipage->InsertInset + parBeforeMinipage->insertInset (parBeforeMinipage->size(), mini); minipar = par; @@ -1099,20 +1277,20 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, par->previous()->next(0); par->previous(parBeforeMinipage); parBeforeMinipage->next(par); - LyXParagraph * tmp = minipar; + Paragraph * tmp = minipar; while (tmp) { - tmp->params.pextraType(0); - tmp->params.pextraWidth(string()); - tmp->params.pextraWidthp(string()); - tmp->params.pextraAlignment(0); - tmp->params.pextraHfill(false); - tmp->params.pextraStartMinipage(false); + tmp->params().pextraType(0); + tmp->params().pextraWidth(string()); + tmp->params().pextraWidthp(string()); + tmp->params().pextraAlignment(0); + tmp->params().pextraHfill(false); + tmp->params().pextraStartMinipage(false); tmp = tmp->next(); } - depth = parBeforeMinipage->params.depth(); + depth = parBeforeMinipage->params().depth(); minipar = parBeforeMinipage = 0; } else if (!minipar && - (par->params.pextraType() == LyXParagraph::PEXTRA_MINIPAGE)) + (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE)) { // par is the first paragraph in a minipage lyxerr << "begin minipage" << endl; @@ -1121,52 +1299,106 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par, // the first minipage in // a sequence of minipages // in its own paragraph. - LyXParagraph * p = new LyXParagraph; + Paragraph * p = new Paragraph; p->layout = 0; p->previous(par->previous()); p->next(0); - p->params.depth(depth); - par->params.depth(0); + p->params().depth(depth); + par->params().depth(0); depth = 0; if (par->previous()) par->previous()->next(p); par->previous(0); parBeforeMinipage = p; minipar = par; - if (!return_par || (return_par == par)) - return_par = p; + if (!first_par || (first_par == par)) + first_par = p; InsetMinipage * mini = new InsetMinipage; - mini->pos(static_cast(minipar->params.pextraAlignment())); - mini->width(minipar->params.pextraWidth()); - if (!par->params.pextraWidthp().empty()) { + mini->pos(static_cast(minipar->params().pextraAlignment())); + mini->width(minipar->params().pextraWidth()); + if (!par->params().pextraWidthp().empty()) { lyxerr << "WP:" << mini->width() << endl; - mini->width(tostr(par->params.pextraWidthp())+"%"); + mini->width(tostr(par->params().pextraWidthp())+"%"); } - mini->inset.par = minipar; + mini->inset.paragraph(minipar); // Insert the minipage last in the // previous paragraph. - if (minipar->params.pextraHfill()) { - parBeforeMinipage->InsertChar - (parBeforeMinipage->size(),LyXParagraph::META_HFILL); + if (minipar->params().pextraHfill()) { + parBeforeMinipage->insertChar + (parBeforeMinipage->size(),Paragraph::META_HFILL); } - parBeforeMinipage->InsertInset + parBeforeMinipage->insertInset (parBeforeMinipage->size(), mini); } } // End of pextra_minipage compability -#endif --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 +{ + LyXLayout const & layout = textclasslist.Style(params.textclass, + par->getLayout()); + // insert the string, don't insert doublespace + bool space_inserted = true; + for(string::const_iterator cit = str.begin(); + cit != str.end(); ++cit) { + if (*cit == '\n') { + if (par->size() || layout.keepempty) { + par->breakParagraph(params, pos, + layout.isEnvironment()); + par = par->next(); + pos = 0; + space_inserted = true; + } else { + continue; + } + // do not insert consecutive spaces if !free_spacing + } else if ((*cit == ' ' || *cit == '\t') + && space_inserted && !layout.free_spacing) { + continue; + } else if (*cit == '\t') { + if (!layout.free_spacing) { + // 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) { + par->insertChar(pos, ' ', font); + ++pos; + } + space_inserted = true; + } + } else if (!IsPrintable(*cit)) { + // Ignore unprintables + continue; + } else { + // just insert the character + par->insertChar(pos, *cit, font); + ++pos; + space_inserted = (*cit == ' '); + } + + } +} + -void Buffer::readInset(LyXLex & lex, LyXParagraph *& par, +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; } @@ -1174,17 +1406,19 @@ void Buffer::readInset(LyXLex & lex, LyXParagraph *& par, Inset * inset = 0; lex.next(); - string const tmptok = lex.GetString(); + string const tmptok = lex.getString(); last_inset_read = tmptok; // test the different insets if (tmptok == "LatexCommand") { InsetCommandParams inscmd; - inscmd.Read(lex); + inscmd.read(lex); string const cmdName = inscmd.getCmdName(); - if (cmdName == "cite") { + // This strange command allows LyX to recognize "natbib" style + // citations: citet, citep, Citet etc. + if (compare_no_case(cmdName, "cite", 4) == 0) { inset = new InsetCitation(inscmd); } else if (cmdName == "bibitem") { lex.printError("Wrong place for bibitem"); @@ -1223,6 +1457,7 @@ void Buffer::readInset(LyXLex & lex, LyXParagraph *& par, inset = new InsetParent(inscmd, *this); } } else { + bool alreadyread = false; if (tmptok == "Quotes") { inset = new InsetQuotes; } else if (tmptok == "External") { @@ -1231,10 +1466,18 @@ void Buffer::readInset(LyXLex & lex, LyXParagraph *& par, inset = new InsetFormulaMacro; } else if (tmptok == "Formula") { inset = new InsetFormula; - } else if (tmptok == "Figure") { + } else if (tmptok == "Figure") { // Backward compatibility inset = new InsetFig(100, 100, *this); - } else if (tmptok == "Info") { - inset = new InsetInfo; + //inset = new InsetGraphics; + } else if (tmptok == "Graphics") { + inset = new InsetGraphics; + } else if (tmptok == "Info") {// backwards compatibility + inset = new InsetNote(this, + lex.getLongString("\\end_inset"), + true); + alreadyread = true; + } else if (tmptok == "Note") { + inset = new InsetNote; } else if (tmptok == "Include") { InsetCommandParams p( "Include" ); inset = new InsetInclude(p, *this); @@ -1252,38 +1495,38 @@ void Buffer::readInset(LyXLex & lex, LyXParagraph *& 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") { inset = new InsetList; } else if (tmptok == "Theorem") { inset = new InsetList; +#endif } else if (tmptok == "Caption") { inset = new InsetCaption; - } else if (tmptok == "GRAPHICS") { - inset = new InsetGraphics; } else if (tmptok == "FloatList") { inset = new InsetFloatList; } - if (inset) inset->Read(this, lex); + if (inset && !alreadyread) inset->read(this, lex); } if (inset) { - par->InsertInset(pos, inset, font); + par->insertInset(pos, inset, font); ++pos; } } -bool Buffer::readFile(LyXLex & lex, LyXParagraph * 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(".,"); @@ -1328,7 +1571,6 @@ bool Buffer::readFile(LyXLex & lex, LyXParagraph * par) } - // Should probably be moved to somewhere else: BufferView? LyXView? bool Buffer::save() const { @@ -1341,7 +1583,7 @@ bool Buffer::save() const s = fileName() + '~'; if (!lyxrc.backupdir_path.empty()) s = AddName(lyxrc.backupdir_path, - subst(CleanupPath(s),'/','!')); + subst(os::slashify_path(s),'/','!')); // Rename is the wrong way of making a backup, // this is the correct way. @@ -1362,7 +1604,7 @@ bool Buffer::save() const _exit(0) */ - // Should proabaly have some more error checking here. + // Should probably have some more error checking here. // Should be cleaned up in 0.13, at least a bit. // Doing it this way, also makes the inodes stay the same. // This is still not a very good solution, in particular we @@ -1387,7 +1629,7 @@ bool Buffer::save() const } } else { lyxerr << "LyX was not able to make " - "backupcopy. Beware." << endl; + "backup copy. Beware." << endl; } } } @@ -1464,7 +1706,7 @@ bool Buffer::writeFile(string const & fname, bool flag) const // now write out the buffer paramters. params.writeFile(ofs); - char depth = 0; + Paragraph::depth_type depth = 0; // this will write out all the paragraphs // using recursive descent. @@ -1500,37 +1742,33 @@ bool Buffer::writeFile(string const & fname, bool flag) const } -string const Buffer::asciiParagraph(LyXParagraph const * par, +string const Buffer::asciiParagraph(Paragraph const * par, unsigned int linelen) const { ostringstream buffer; - LyXFont font1; - LyXFont font2; - Inset const * inset; - char c; - char depth = 0; + Paragraph::depth_type depth = 0; int ltype = 0; - int ltype_depth = 0; + Paragraph::depth_type ltype_depth = 0; unsigned int 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) { + // 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) { + while (par->params().depth() < depth) { --depth; } } } - /* First write the layout */ + // First write the layout string const tmp = textclasslist.NameOfLayout(params.textclass, par->layout); if (tmp == "Itemize") { ltype = 1; @@ -1538,10 +1776,10 @@ string const Buffer::asciiParagraph(LyXParagraph const * par, } 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") { @@ -1572,27 +1810,26 @@ string const Buffer::asciiParagraph(LyXParagraph const * par, } else { lyxerr << "Should this ever happen?" << endl; } - - font1 = LyXFont(LyXFont::ALL_INHERIT, params.language); - for (LyXParagraph::size_type i = 0; i < par->size(); ++i) { + + for (Paragraph::size_type i = 0; i < par->size(); ++i) { if (!i && !noparbreak) { if (linelen > 0) buffer << "\n\n"; - for (char j = 0; j < depth; ++j) + 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 */ + case 0: // Standard + case 4: // (Sub)Paragraph + case 5: // Description break; - case 6: /* Abstract */ + case 6: // Abstract if (linelen > 0) buffer << "Abstract\n\n"; else buffer << "Abstract: "; break; - case 7: /* Bibliography */ + case 7: // Bibliography if (!ref_printed) { if (linelen > 0) buffer << "References\n\n"; @@ -1602,71 +1839,74 @@ string const Buffer::asciiParagraph(LyXParagraph const * par, } break; default: - buffer << par->params.labelString() << " "; + buffer << par->params().labelString() << " "; break; } if (ltype_depth > depth) { - for (char j = ltype_depth - 1; j > depth; --j) + for (Paragraph::depth_type 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->GetUChar(params, i); + + char c = par->getUChar(params, i); if (islatex) continue; switch (c) { - case LyXParagraph::META_INSET: - if ((inset = par->GetInset(i))) { - if (!inset->Ascii(this, buffer)) { + case Paragraph::META_INSET: + { + Inset const * inset = par->getInset(i); + if (inset) { + if (!inset->ascii(this, buffer)) { string dummy; - string s = rsplit(buffer.str().c_str(), - dummy, '\n'); + string const 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: + } + break; + + case Paragraph::META_NEWLINE: if (linelen > 0) { buffer << "\n"; - for (char j = 0; j < depth; ++j) + for (Paragraph::depth_type j = 0; + j < depth; ++j) buffer << " "; } currlinelen = depth * 2; if (ltype_depth > depth) { - for (char j = ltype_depth; - j > depth; --j) + for (Paragraph::depth_type j = ltype_depth; + j > depth; --j) buffer << " "; currlinelen += (ltype_depth - depth) * 2; } break; - case LyXParagraph::META_HFILL: + + case Paragraph::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) + for (Paragraph::depth_type j = 0; + j < depth; ++j) buffer << " "; currlinelen = depth * 2; if (ltype_depth > depth) { - for (char j = ltype_depth; + for (Paragraph::depth_type j = ltype_depth; j > depth; --j) buffer << " "; currlinelen += (ltype_depth-depth)*2; @@ -1674,7 +1914,7 @@ string const Buffer::asciiParagraph(LyXParagraph const * par, } else if (c != '\0') buffer << c; else if (c == '\0') - lyxerr.debug() << "writeAsciiFile: NULL char in structure." << endl; + lyxerr[Debug::INFO] << "writeAsciiFile: NULL char in structure." << endl; ++currlinelen; break; } @@ -1696,7 +1936,7 @@ void Buffer::writeFileAscii(string const & fname, int linelen) void Buffer::writeFileAscii(ostream & ofs, int linelen) { - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; while (par) { ofs << asciiParagraph(par, linelen); par = par->next(); @@ -1744,7 +1984,7 @@ void Buffer::makeLaTeXFile(string const & fname, texrow.newline(); texrow.newline(); } - lyxerr.debug() << "lyx header finished" << endl; + lyxerr[Debug::INFO] << "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 @@ -1764,7 +2004,7 @@ void Buffer::makeLaTeXFile(string const & fname, if (!original_path.empty()) { ofs << "\\makeatletter\n" << "\\def\\input@path{{" - << original_path << "/}}\n" + << os::external_path(original_path) << "/}}\n" << "\\makeatother\n"; texrow.newline(); texrow.newline(); @@ -1778,8 +2018,7 @@ void Buffer::makeLaTeXFile(string const & fname, if (tokenPos(tclass.opt_fontsize(), '|', params.fontsize) >= 0) { // only write if existing in list (and not default) - options << params.fontsize; - options << "pt,"; + options << params.fontsize << "pt,"; } @@ -1833,7 +2072,7 @@ void Buffer::makeLaTeXFile(string const & fname, // language should be a parameter to \documentclass use_babel = false; - string language_options; + ostringstream language_options; if (params.language->babel() == "hebrew" && default_language->babel() != "hebrew") // This seems necessary @@ -1846,10 +2085,10 @@ void Buffer::makeLaTeXFile(string const & fname, for (LaTeXFeatures::LanguageList::const_iterator cit = features.UsedLanguages.begin(); cit != features.UsedLanguages.end(); ++cit) - language_options += (*cit)->babel() + ','; - language_options += params.language->babel(); + language_options << (*cit)->babel() << ','; + language_options << params.language->babel(); if (lyxrc.language_global_options) - options << language_options << ','; + options << language_options.str() << ','; } // the user-defined options @@ -2036,8 +2275,9 @@ void Buffer::makeLaTeXFile(string const & fname, string tmp = lyxrc.language_package; if (!lyxrc.language_global_options && tmp == "\\usepackage{babel}") - tmp = "\\usepackage[" + - language_options + "]{babel}"; + tmp = string("\\usepackage[") + + language_options.str().c_str() + + "]{babel}"; ofs << tmp << "\n"; texrow.newline(); } @@ -2160,7 +2400,7 @@ void Buffer::makeLaTeXFile(string const & fname, ofs << "\\begin{document}\n"; texrow.newline(); } // only_body - lyxerr.debug() << "preamble finished, now the body." << endl; + lyxerr[Debug::INFO] << "preamble finished, now the body." << endl; if (!lyxrc.language_auto_begin) { ofs << subst(lyxrc.language_command_begin, "$$lang", @@ -2206,15 +2446,15 @@ void Buffer::makeLaTeXFile(string const & fname, lyxerr << "File was not closed properly." << endl; } - lyxerr.debug() << "Finished making latex file." << endl; + lyxerr[Debug::INFO] << "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 +void Buffer::latexParagraphs(ostream & ofs, Paragraph * par, + Paragraph * endpar, TexRow & texrow) const { bool was_title = false; bool already_title = false; @@ -2284,19 +2524,21 @@ bool Buffer::isSGML() const } -void Buffer::sgmlOpenTag(ostream & os, int depth, +void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type depth, string const & latexname) const { if (!latexname.empty() && latexname != "!-- --") - os << string(depth, ' ') << "<" << latexname << ">\n"; + os << "" << "<" << latexname << ">"; + //os << string(depth, ' ') << "<" << latexname << ">\n"; } -void Buffer::sgmlCloseTag(ostream & os, int depth, +void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type depth, string const & latexname) const { if (!latexname.empty() && latexname != "!-- --") - os << string(depth, ' ') << "\n"; + os << "" << "\n"; + //os << string(depth, ' ') << "\n"; } @@ -2345,8 +2587,8 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) << " created this file. For more info see http://www.lyx.org/" << " -->\n"; - int depth = 0; // paragraph depth - LyXParagraph * par = paragraph; + Paragraph::depth_type depth = 0; // paragraph depth + Paragraph * par = paragraph; string item_name; vector environment_stack(5); @@ -2356,9 +2598,9 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) par->layout); // treat as a special case for compatibility with old code - if (par->GetChar(0) == LyXParagraph::META_INSET) { - Inset * inset = par->GetInset(0); - Inset::Code lyx_code = inset->LyxCode(); + if (par->getChar(0) == Paragraph::META_INSET) { + Inset * inset = par->getInset(0); + Inset::Code lyx_code = inset->lyxCode(); if (lyx_code == Inset::TOC_CODE){ string const temp = "toc"; sgmlOpenTag(ofs, depth, temp); @@ -2369,7 +2611,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) } // environment tag closing - for (; depth > par->params.depth(); --depth) { + for (; depth > par->params().depth(); --depth) { sgmlCloseTag(ofs, depth, environment_stack[depth]); environment_stack[depth].erase(); } @@ -2377,7 +2619,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) // write opening SGML tags switch (style.latextype) { case LATEX_PARAGRAPH: - if (depth == par->params.depth() + if (depth == par->params().depth() && !environment_stack[depth].empty()) { sgmlCloseTag(ofs, depth, environment_stack[depth]); environment_stack[depth].erase(); @@ -2391,7 +2633,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) case LATEX_COMMAND: if (depth!= 0) - LinuxDocError(par, 0, + linuxDocError(par, 0, _("Error : Wrong depth for" " LatexType Command.\n")); @@ -2407,14 +2649,14 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) case LATEX_ENVIRONMENT: case LATEX_ITEM_ENVIRONMENT: - if (depth == par->params.depth() + if (depth == par->params().depth() && environment_stack[depth] != style.latexname()) { sgmlCloseTag(ofs, depth, environment_stack[depth]); environment_stack[depth].erase(); } - if (depth < par->params.depth()) { - depth = par->params.depth(); + if (depth < par->params().depth()) { + depth = par->params().depth(); environment_stack[depth].erase(); } if (environment_stack[depth] != style.latexname()) { @@ -2445,7 +2687,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) break; } - SimpleLinuxDocOnePar(ofs, par, depth); + simpleLinuxDocOnePar(ofs, par, depth); par = par->next(); @@ -2479,11 +2721,11 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only) } -void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag, - int depth, int desc_on, - LyXParagraph * & par) +void Buffer::docBookHandleCaption(ostream & os, string & inner_tag, + Paragraph::depth_type depth, int desc_on, + Paragraph * & par) { - LyXParagraph * tpar = par; + Paragraph * tpar = par; while (tpar && (tpar->layout != textclasslist.NumberOfLayout(params.textclass, "Caption").second)) @@ -2494,7 +2736,7 @@ void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag, "Caption").second) { sgmlOpenTag(os, depth + 1, inner_tag); string extra_par; - SimpleDocBookOnePar(os, extra_par, tpar, + simpleDocBookOnePar(os, extra_par, tpar, desc_on, depth + 2); sgmlCloseTag(os, depth+1, inner_tag); if (!extra_par.empty()) @@ -2561,11 +2803,12 @@ void reset(PAR_TAG & p1, PAR_TAG const & p2) // Handle internal paragraph parsing -- layout already processed. -void Buffer::SimpleLinuxDocOnePar(ostream & os, - LyXParagraph * par, int /*depth*/) +void Buffer::simpleLinuxDocOnePar(ostream & os, + Paragraph * par, + Paragraph::depth_type /*depth*/) { LyXLayout const & style = textclasslist.Style(params.textclass, - par->GetLayout()); + par->getLayout()); string::size_type char_line_count = 5; // Heuristic choice ;-) // gets paragraph main font @@ -2584,9 +2827,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 (LyXParagraph::size_type i = 0; i < par->size(); ++i) { + for (Paragraph::size_type i = 0; i < par->size(); ++i) { PAR_TAG tag_close = NONE; list < PAR_TAG > tag_open; @@ -2700,16 +2943,16 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, os << "<" << tag_name(*j) << ">"; } - char c = par->GetChar(i); + char c = par->getChar(i); - if (c == LyXParagraph::META_INSET) { - Inset * inset = par->GetInset(i); - inset->Linuxdoc(this, os); + if (c == Paragraph::META_INSET) { + Inset * inset = par->getInset(i); + inset->linuxdoc(this, os); font_old = font; continue; } - if (font.latex() == LyXFont::ON || style.latexparam() == "CDATA") { + if (style.latexparam() == "CDATA") { // "TeX"-Mode on == > SGML-Mode on. if (c != '\0') os << c; @@ -2753,12 +2996,12 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, // Print an error message. -void Buffer::LinuxDocError(LyXParagraph * par, int pos, +void Buffer::linuxDocError(Paragraph * par, int pos, string const & message) { // insert an error marker in text InsetError * new_inset = new InsetError(message); - par->InsertInset(pos, new_inset); + par->insertInset(pos, new_inset); } @@ -2770,7 +3013,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) return; } - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; niceFile = nice; // this will be used by Insetincludes. @@ -2816,10 +3059,10 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) vector command_stack(10); bool command_flag = false; - int command_depth = 0; - int command_base = 0; - int cmd_depth = 0; - int depth = 0; // paragraph depth + Paragraph::depth_type command_depth = 0; + Paragraph::depth_type command_base = 0; + Paragraph::depth_type cmd_depth = 0; + Paragraph::depth_type depth = 0; // paragraph depth string item_name; string command_name; @@ -2835,7 +3078,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) par->layout); // environment tag closing - for (; depth > par->params.depth(); --depth) { + for (; depth > par->params().depth(); --depth) { if (environment_inner[depth] != "!-- --") { item_name = "listitem"; sgmlCloseTag(ofs, command_depth + depth, @@ -2850,7 +3093,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) environment_inner[depth].erase(); } - if (depth == par->params.depth() + if (depth == par->params().depth() && environment_stack[depth] != style.latexname() && !environment_stack[depth].empty()) { if (environment_inner[depth] != "!-- --") { @@ -2879,7 +3122,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) case LATEX_COMMAND: if (depth != 0) - LinuxDocError(par, 0, + linuxDocError(par, 0, _("Error : Wrong depth for " "LatexType Command.\n")); @@ -2892,11 +3135,11 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) if (command_flag) { if (cmd_depth < command_base) { - for (int j = command_depth; j >= command_base; --j) + for (Paragraph::depth_type j = command_depth; j >= command_base; --j) sgmlCloseTag(ofs, j, command_stack[j]); command_depth = command_base = cmd_depth; } else if (cmd_depth <= command_depth) { - for (int j = command_depth; j >= cmd_depth; --j) + for (int j = command_depth; j >= int(cmd_depth); --j) sgmlCloseTag(ofs, j, command_stack[j]); command_depth = cmd_depth; } else @@ -2906,14 +3149,14 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) command_flag = true; } if (command_stack.size() == command_depth + 1) - command_stack.push_back(""); + command_stack.push_back(string()); command_stack[command_depth] = command_name; // treat label as a special case for // more WYSIWYM handling. - if (par->GetChar(0) == LyXParagraph::META_INSET) { - Inset * inset = par->GetInset(0); - Inset::Code lyx_code = inset->LyxCode(); + if (par->getChar(0) == Paragraph::META_INSET) { + Inset * inset = par->getInset(0); + Inset::Code lyx_code = inset->lyxCode(); if (lyx_code == Inset::LABEL_CODE){ command_name += " id=\""; command_name += (static_cast(inset))->getContents(); @@ -2932,8 +3175,8 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) case LATEX_ENVIRONMENT: case LATEX_ITEM_ENVIRONMENT: - if (depth < par->params.depth()) { - depth = par->params.depth(); + if (depth < par->params().depth()) { + depth = par->params().depth(); environment_stack[depth].erase(); } @@ -2997,7 +3240,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } string extra_par; - SimpleDocBookOnePar(ofs, extra_par, par, desc_on, + simpleDocBookOnePar(ofs, extra_par, par, desc_on, depth + 1 + command_depth); par = par->next(); @@ -3035,7 +3278,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } // Close open tags - for (; depth >= 0; --depth) { + for (int d = depth; d >= 0; --d) { if (!environment_stack[depth].empty()) { if (environment_inner[depth] != "!-- --") { item_name = "listitem"; @@ -3051,7 +3294,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } } - for (int j = command_depth; j >= command_base; --j) + for (int j = command_depth; j >= 0 ; --j) if (!command_stack[j].empty()) sgmlCloseTag(ofs, j, command_stack[j]); @@ -3063,23 +3306,23 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body) } -void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, - LyXParagraph * par, int & desc_on, - int depth) const +void Buffer::simpleDocBookOnePar(ostream & os, string & extra, + Paragraph * par, int & desc_on, + Paragraph::depth_type depth) const { bool emph_flag = false; LyXLayout const & style = textclasslist.Style(params.textclass, - par->GetLayout()); + par->getLayout()); LyXFont font_old = style.labeltype == LABEL_MANUAL ? style.labelfont : style.font; int char_line_count = depth; - if (!style.free_spacing) - os << string(depth,' '); + //if (!style.free_spacing) + // os << string(depth,' '); // parsing main loop - for (LyXParagraph::size_type i = 0; + for (Paragraph::size_type i = 0; i < par->size(); ++i) { LyXFont font = par->getFont(params, i); @@ -3094,12 +3337,12 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, } } - char c = par->GetChar(i); + char c = par->getChar(i); - if (c == LyXParagraph::META_INSET) { - Inset * inset = par->GetInset(i); - std::ostringstream ost; - inset->DocBook(this, ost); + if (c == Paragraph::META_INSET) { + Inset * inset = par->getInset(i); + ostringstream ost; + inset->docBook(this, ost); string tmp_out = ost.str().c_str(); // @@ -3122,11 +3365,6 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, else os << tmp_out; } - } else if (font.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) @@ -3157,7 +3395,7 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra, // not closed... os << ""; } - os << '\n'; + if(style.free_spacing) os << '\n'; } @@ -3168,14 +3406,14 @@ int Buffer::runChktex() { if (!users->text) return 0; - ProhibitInput(users); + users->owner()->prohibitInput(); // get LaTeX-Filename string const name = getLatexName(); string path = OnlyPath(filename); string const org_path = path; - if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) { + if (lyxrc.use_tempdir || !IsDirWriteable(path)) { path = tmppath; } @@ -3204,9 +3442,9 @@ int Buffer::runChktex() // error insets after we ran chktex, this must be run: if (removedErrorInsets || res){ users->redraw(); - users->fitCursor(users->text); + users->fitCursor(); } - AllowInput(users); + users->owner()->allowInput(); return res; } @@ -3214,12 +3452,11 @@ int Buffer::runChktex() void Buffer::validate(LaTeXFeatures & features) const { - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; LyXTextClass const & tclass = textclasslist.TextClass(params.textclass); // AMS Style is at document level - features.amsstyle = (params.use_amsmath || tclass.provides(LyXTextClass::amsmath)); @@ -3299,7 +3536,7 @@ string const Buffer::getIncludeonlyList(char delim) string lst; for (inset_iterator it = inset_iterator_begin(); it != inset_iterator_end(); ++it) { - if ((*it)->LyxCode() == Inset::INCLUDE_CODE) { + if ((*it)->lyxCode() == Inset::INCLUDE_CODE) { InsetInclude * insetinc = static_cast(*it); if (insetinc->isIncludeOnly()) { @@ -3309,7 +3546,7 @@ string const Buffer::getIncludeonlyList(char delim) } } } - lyxerr.debug() << "Includeonly(" << lst << ')' << endl; + lyxerr[Debug::INFO] << "Includeonly(" << lst << ')' << endl; return lst; } @@ -3338,7 +3575,7 @@ vector const Buffer::getLabelList() Buffer::Lists const Buffer::getLists() const { Lists l; - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; bool found; LyXTextClassList::size_type cap; boost::tie(found, cap) = textclasslist @@ -3347,7 +3584,7 @@ Buffer::Lists const Buffer::getLists() const while (par) { char const labeltype = textclasslist.Style(params.textclass, - par->GetLayout()).labeltype; + par->getLayout()).labeltype; if (labeltype >= LABEL_COUNTER_CHAPTER && labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) { @@ -3356,19 +3593,19 @@ Buffer::Lists const Buffer::getLists() const int depth = max(0, labeltype - textclasslist.TextClass(params.textclass).maxcounter()); - item.push_back(TocItem(par, depth, par->String(this, true))); + item.push_back(TocItem(par, depth, par->asString(this, true))); } // For each paragrph, traverse its insets and look for // FLOAT_CODE if (found) { - LyXParagraph::inset_iterator it = + Paragraph::inset_iterator it = par->inset_iterator_begin(); - LyXParagraph::inset_iterator end = + Paragraph::inset_iterator end = par->inset_iterator_end(); for (; it != end; ++it) { - if ((*it)->LyxCode() == Inset::FLOAT_CODE) { + if ((*it)->lyxCode() == Inset::FLOAT_CODE) { InsetFloat * il = static_cast(*it); @@ -3377,12 +3614,12 @@ Buffer::Lists const Buffer::getLists() const // Now find the caption in the float... // We now tranverse the paragraphs of // the inset... - LyXParagraph * tmp = il->inset.par; + Paragraph * tmp = il->inset.paragraph(); while (tmp) { if (tmp->layout == cap) { SingleList & item = l[type]; string const str = - tostr(item.size()+1) + ". " + tmp->String(this, false); + tostr(item.size()+1) + ". " + tmp->asString(this, false); item.push_back(TocItem(tmp, 0 , str)); } tmp = tmp->next(); @@ -3411,11 +3648,11 @@ vector > const Buffer::getBibkeyList() } vector > keys; - LyXParagraph * par = paragraph; + Paragraph * par = paragraph; while (par) { if (par->bibkey) keys.push_back(pair(par->bibkey->getContents(), - par->String(this, false))); + par->asString(this, false))); par = par->next(); } @@ -3424,11 +3661,11 @@ vector > const Buffer::getBibkeyList() for (inset_iterator it = inset_iterator_begin(); it != inset_iterator_end(); ++it) { // Search for Bibtex or Include inset - if ((*it)->LyxCode() == Inset::BIBTEX_CODE) { + 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) { + } else if ((*it)->lyxCode() == Inset::INCLUDE_CODE) { vector > const tmp = static_cast(*it)->getKeys(); keys.insert(keys.end(), tmp.begin(), tmp.end()); @@ -3473,18 +3710,18 @@ void Buffer::markDepClean(string const & name) } -bool Buffer::Dispatch(string const & command) +bool Buffer::dispatch(string const & command) { // Split command string into command and argument string cmd; string line = frontStrip(command); string const arg = strip(frontStrip(split(line, cmd, ' '))); - return Dispatch(lyxaction.LookupFunc(cmd), arg); + return dispatch(lyxaction.LookupFunc(cmd), arg); } -bool Buffer::Dispatch(int action, string const & argument) +bool Buffer::dispatch(int action, string const & argument) { bool dispatched = true; switch (action) { @@ -3499,60 +3736,56 @@ bool Buffer::Dispatch(int action, string const & argument) } -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; + Paragraph * par = paragraph; for (; par; par = par->next()) { par->resizeInsetsLyXText(bv); } } -void Buffer::ChangeLanguage(Language const * from, Language const * to) +void Buffer::redraw() +{ + users->redraw(); + users->fitCursor(); +} + + +void Buffer::changeLanguage(Language const * from, Language const * to) { - LyXParagraph * 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() { - LyXParagraph * 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(LyXParagraph * paragraph, - LyXParagraph::size_type pos) +Buffer::inset_iterator::inset_iterator(Paragraph * paragraph, + Paragraph::size_type pos) : par(paragraph) { it = par->InsetIterator(pos); if (it == par->inset_iterator_end()) { par = par->next(); - SetParagraph(); + setParagraph(); } } -void Buffer::inset_iterator::SetParagraph() +void Buffer::inset_iterator::setParagraph() { while (par) { it = par->inset_iterator_begin(); @@ -3563,3 +3796,48 @@ void Buffer::inset_iterator::SetParagraph() //it = 0; // We maintain an invariant that whenever par = 0 then it = 0 } + + +Inset * Buffer::getInsetFromID(int id_arg) const +{ + for (inset_iterator it = inset_const_iterator_begin(); + it != inset_const_iterator_end(); ++it) + { + if ((*it)->id() == id_arg) + return *it; + Inset * in = (*it)->getInsetFromID(id_arg); + if (in) + return in; + } + return 0; +} + + +Paragraph * Buffer::getParFromID(int id) const +{ + if (id < 0) return 0; + Paragraph * par = paragraph; + while (par) { + if (par->id() == id) { + return par; + } + Paragraph * tmp = par->getParFromID(id); + if (tmp) { + return tmp; + } + par = par->next(); + } + return 0; +} + + +ParIterator Buffer::par_iterator_begin() +{ + return ParIterator(paragraph); +} + + +ParIterator Buffer::par_iterator_end() +{ + return ParIterator(); +}