X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=2e3a09feb90743f57049f9464cc9308d89bdad66;hb=9a5f7d1fe43ddbc1308f69bc609825ac9d618922;hp=a993aaf11669c350cdd66de18ebdfe94abffa960;hpb=1a32c26a5ee4af362e249418dc6d441b7ab5d695;p=lyx.git diff --git a/src/paragraph.C b/src/paragraph.C index a993aaf116..2e3a09feb9 100644 --- a/src/paragraph.C +++ b/src/paragraph.C @@ -4,41 +4,48 @@ * LyX, The Document Processor * * Copyright 1995 Matthias Ettrich - * Copyright 1995-2000 The LyX Team. + * Copyright 1995-2001 The LyX Team. * * ====================================================== */ #include #ifdef __GNUG__ -#pragma implementation "lyxparagraph.h" +#pragma implementation #endif -#include -#include -#include - -#include "lyxparagraph.h" -#include "support/textutils.h" +#include "paragraph.h" +#include "paragraph_pimpl.h" #include "lyxrc.h" #include "layout.h" +#include "language.h" #include "tex-strings.h" #include "buffer.h" #include "bufferparams.h" -#include "support/FileInfo.h" -#include "support/LAssert.h" #include "debug.h" #include "LaTeXFeatures.h" -#include "insets/insetinclude.h" -#include "insets/insetbib.h" -#include "insets/insettext.h" -#include "support/filetools.h" #include "lyx_gui_misc.h" #include "texrow.h" -#include "support/lyxmanip.h" #include "BufferView.h" #include "encoding.h" #include "ParameterStruct.h" +#include "gettext.h" +#include "lyxtextclasslist.h" + +#include "insets/insetinclude.h" +#include "insets/insetbib.h" +#include "insets/insettext.h" + +#include "support/filetools.h" +#include "support/lstrings.h" +#include "support/lyxmanip.h" +#include "support/FileInfo.h" +#include "support/LAssert.h" +#include "support/textutils.h" + +#include +#include +#include using std::ostream; using std::endl; @@ -48,57 +55,52 @@ using std::lower_bound; using std::upper_bound; using std::reverse; +using lyx::pos_type; +using lyx::layout_type; + int tex_code_break_column = 72; // needs non-zero initialization. set later. -// this is a bad idea, but how can LyXParagraph find its buffer to get +// this is a bad idea, but how can Paragraph find its buffer to get // parameters? (JMarc) extern string bibitemWidest(Buffer const *); // this is a minibuffer -static char minibuffer_char; -static LyXFont minibuffer_font; -static Inset * minibuffer_inset; +namespace { -extern BufferView * current_view; +char minibuffer_char; +LyXFont minibuffer_font; +Inset * minibuffer_inset; -// Initialization of the counter for the paragraph id's, -// declared in lyxparagraph.h -unsigned int LyXParagraph::paragraph_id = 0; +} // namespace anon -// Initialize static member. -ShareContainer LyXParagraph::FontTable::container; + +extern BufferView * current_view; -LyXParagraph::LyXParagraph() +Paragraph::Paragraph() + : layout(0), pimpl_(new Paragraph::Pimpl(this)) { - text.reserve(500); // is this number too big? - for (int i = 0; i < 10; ++i) setCounter(i , 0); - enumdepth = 0; - itemdepth = 0; + for (int i = 0; i < 10; ++i) + setCounter(i, 0); next_ = 0; previous_ = 0; -#ifndef NEW_INSETS - footnoteflag = LyXParagraph::NO_FOOTNOTE; - footnotekind = LyXParagraph::FOOTNOTE; // should not be needed -#endif - - inset_owner = 0; - id_ = paragraph_id++; - bibkey = 0; // ale970302 - Clear(); + enumdepth = 0; + itemdepth = 0; + bibkey = 0; // ale970302 + clear(); } -// This konstruktor inserts the new paragraph in a list. -LyXParagraph::LyXParagraph(LyXParagraph * par) +// This constructor inserts the new paragraph in a list. +Paragraph::Paragraph(Paragraph * par) + : layout(0), pimpl_(new Paragraph::Pimpl(this)) { - text.reserve(500); - par->fitToSize(); - - for (int i = 0; i < 10; ++i) setCounter(i, 0); + for (int i = 0; i < 10; ++i) + setCounter(i, 0); enumdepth = 0; itemdepth = 0; + // double linked list begin next_ = par->next_; if (next_) @@ -106,172 +108,181 @@ LyXParagraph::LyXParagraph(LyXParagraph * par) previous_ = par; previous_->next_ = this; // end -#ifndef NEW_INSETS - footnoteflag = LyXParagraph::NO_FOOTNOTE; - footnotekind = LyXParagraph::FOOTNOTE; -#endif - inset_owner = 0; - id_ = paragraph_id++; - bibkey = 0; // ale970302 - - Clear(); + bibkey = 0; // ale970302 + + clear(); } -void LyXParagraph::writeFile(Buffer const * buf, ostream & os, - BufferParams const & bparams, - char footflag, char dth) const +Paragraph::Paragraph(Paragraph const & lp, bool same_ids) + : layout(0), pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids)) { -#ifndef NEW_INSETS - if (footnoteflag != LyXParagraph::NO_FOOTNOTE || - !previous_ - || previous_->footnoteflag == LyXParagraph::NO_FOOTNOTE) { - // The beginning or the end of a footnote environment? - if (footflag != footnoteflag) { - footflag = footnoteflag; - if (footflag) { - os << "\n\\begin_float " - << string_footnotekinds[footnotekind] - << " "; - } else { - os << "\n\\end_float "; - } - } -#endif - // The beginning or end of a deeper (i.e. nested) area? - if (dth != params.depth()) { - if (params.depth() > dth) { - while (params.depth() > dth) { - os << "\n\\begin_deeper "; - ++dth; - } - } else { - while (params.depth() < dth) { - os << "\n\\end_deeper "; - --dth; - } - } - } + for (int i = 0; i < 10; ++i) + setCounter(i, 0); + enumdepth = 0; + itemdepth = 0; + next_ = 0; + previous_ = 0; - // First write the layout - os << "\n\\layout " - << textclasslist.NameOfLayout(bparams.textclass, layout) - << "\n"; - - // Maybe some vertical spaces. - if (params.spaceTop().kind() != VSpace::NONE) - os << "\\added_space_top " - << params.spaceTop().asLyXCommand() << " "; - if (params.spaceBottom().kind() != VSpace::NONE) - os << "\\added_space_bottom " - << params.spaceBottom().asLyXCommand() << " "; - - // Maybe the paragraph has special spacing - params.spacing().writeFile(os, true); - - // The labelwidth string used in lists. - if (!params.labelWidthString().empty()) - os << "\\labelwidthstring " - << params.labelWidthString() << '\n'; - - // Lines above or below? - if (params.lineTop()) - os << "\\line_top "; - if (params.lineBottom()) - os << "\\line_bottom "; - - // Pagebreaks above or below? - if (params.pagebreakTop()) - os << "\\pagebreak_top "; - if (params.pagebreakBottom()) - os << "\\pagebreak_bottom "; - - // Start of appendix? - if (params.startOfAppendix()) - os << "\\start_of_appendix "; + // this is because of the dummy layout of the paragraphs that + // follow footnotes + layout = lp.layout; - // Noindent? - if (params.noindent()) - os << "\\noindent "; - - // Alignment? - if (params.align() != LYX_ALIGN_LAYOUT) { - int h = 0; - switch (params.align()) { - case LYX_ALIGN_LEFT: h = 1; break; - case LYX_ALIGN_RIGHT: h = 2; break; - case LYX_ALIGN_CENTER: h = 3; break; - default: h = 0; break; - } - os << "\\align " << string_align[h] << " "; - } -#ifndef NO_PEXTRA - if (params.pextraType() != PEXTRA_NONE) { - os << "\\pextra_type " << params.pextraType(); - if (params.pextraType() == PEXTRA_MINIPAGE) { - os << " \\pextra_alignment " - << params.pextraAlignment(); - if (params.pextraHfill()) - os << " \\pextra_hfill " - << params.pextraHfill(); - if (params.pextraStartMinipage()) - os << " \\pextra_start_minipage " - << params.pextraStartMinipage(); - } - if (!params.pextraWidth().empty()) { - os << " \\pextra_width " - << VSpace(params.pextraWidth()).asLyXCommand(); - } else if (!params.pextraWidthp().empty()) { - os << " \\pextra_widthp " - << params.pextraWidthp(); - } - os << '\n'; - } -#endif -#ifndef NEW_INSETS + // ale970302 + if (lp.bibkey) { + bibkey = static_cast + (lp.bibkey->clone(*current_view->buffer())); } else { - // Dummy layout. This means that a footnote ended. - os << "\n\\end_float "; - footflag = LyXParagraph::NO_FOOTNOTE; + bibkey = 0; + } + + // copy everything behind the break-position to the new paragraph + insetlist = lp.insetlist; + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) + { + it->inset = it->inset->clone(*current_view->buffer(), same_ids); + // tell the new inset who is the boss now + it->inset->parOwner(this); + } +} + + +// the destructor removes the new paragraph from the list +Paragraph::~Paragraph() +{ + if (previous_) + previous_->next_ = next_; + if (next_) + next_->previous_ = previous_; + + for (InsetList::iterator it = insetlist.begin(); + it != insetlist.end(); ++it) { + delete it->inset; } -#endif + // ale970302 + delete bibkey; + + delete pimpl_; + // + //lyxerr << "Paragraph::paragraph_id = " + // << Paragraph::paragraph_id << endl; +} + + +void Paragraph::writeFile(Buffer const * buf, ostream & os, + BufferParams const & bparams, + depth_type dth) const +{ + // The beginning or end of a deeper (i.e. nested) area? + if (dth != params().depth()) { + if (params().depth() > dth) { + while (params().depth() > dth) { + os << "\n\\begin_deeper "; + ++dth; + } + } else { + while (params().depth() < dth) { + os << "\n\\end_deeper "; + --dth; + } + } + } + + // First write the layout + os << "\n\\layout " + << textclasslist.NameOfLayout(bparams.textclass, layout) + << "\n"; + + // Maybe some vertical spaces. + if (params().spaceTop().kind() != VSpace::NONE) + os << "\\added_space_top " + << params().spaceTop().asLyXCommand() << " "; + if (params().spaceBottom().kind() != VSpace::NONE) + os << "\\added_space_bottom " + << params().spaceBottom().asLyXCommand() << " "; + + // Maybe the paragraph has special spacing + params().spacing().writeFile(os, true); + + // The labelwidth string used in lists. + if (!params().labelWidthString().empty()) + os << "\\labelwidthstring " + << params().labelWidthString() << '\n'; + + // Lines above or below? + if (params().lineTop()) + os << "\\line_top "; + if (params().lineBottom()) + os << "\\line_bottom "; + + // Pagebreaks above or below? + if (params().pagebreakTop()) + os << "\\pagebreak_top "; + if (params().pagebreakBottom()) + os << "\\pagebreak_bottom "; + + // Start of appendix? + if (params().startOfAppendix()) + os << "\\start_of_appendix "; + + // Noindent? + if (params().noindent()) + os << "\\noindent "; + + // Alignment? + if (params().align() != LYX_ALIGN_LAYOUT) { + int h = 0; + switch (params().align()) { + case LYX_ALIGN_LEFT: h = 1; break; + case LYX_ALIGN_RIGHT: h = 2; break; + case LYX_ALIGN_CENTER: h = 3; break; + default: h = 0; break; + } + os << "\\align " << string_align[h] << " "; + } + // bibitem ale970302 if (bibkey) - bibkey->Write(buf, os); - + bibkey->write(buf, os); + LyXFont font1(LyXFont::ALL_INHERIT, bparams.language); - + int column = 0; - for (size_type i = 0; i < size(); ++i) { + for (pos_type i = 0; i < size(); ++i) { if (!i) { os << "\n"; column = 0; } // Write font changes - LyXFont font2 = GetFontSettings(bparams, i); + LyXFont font2 = getFontSettings(bparams, i); if (font2 != font1) { +#ifndef INHERIT_LANGUAGE font2.lyxWriteChanges(font1, os); +#else + font2.lyxWriteChanges(font1, bparams.language, os); +#endif column = 0; font1 = font2; } - - value_type const c = GetChar(i); + + value_type const c = getChar(i); switch (c) { case META_INSET: { - Inset const * inset = GetInset(i); + Inset const * inset = getInset(i); if (inset) - if (inset->DirectWrite()) { + if (inset->directWrite()) { // international char, let it write // code directly so it's shorter in // the file - inset->Write(buf, os); + inset->write(buf, os); } else { os << "\n\\begin_inset "; - inset->Write(buf, os); + inset->write(buf, os); os << "\n\\end_inset \n\n"; column = 0; } @@ -290,7 +301,7 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, column = 0; break; case '.': - if (i + 1 < size() && GetChar(i + 1) == ' ') { + if (i + 1 < size() && getChar(i + 1) == ' ') { os << ".\n"; column = 0; } else @@ -307,7 +318,7 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, if (c != '\0') os << c; else - lyxerr << "ERROR (LyXParagraph::writeFile):" + lyxerr << "ERROR (Paragraph::writeFile):" " NULL char in structure." << endl; ++column; break; @@ -316,106 +327,94 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, // now write the next paragraph if (next_) - next_->writeFile(buf, os, bparams, footflag, dth); + next_->writeFile(buf, os, bparams, dth); } -void LyXParagraph::validate(LaTeXFeatures & features) const +void Paragraph::validate(LaTeXFeatures & features) const { BufferParams const & bparams = features.bufferParams(); -#ifndef NEW_INSETS - // this will be useful later - LyXLayout const & layout = - textclasslist.Style(bparams.textclass, - GetLayout()); -#endif - // check the params. - if (params.lineTop() || params.lineBottom()) - features.lyxline = true; - if (!params.spacing().isDefault()) - features.setspace = true; + if (params().lineTop() || params().lineBottom()) + features.require("lyxline"); + if (!params().spacing().isDefault()) + features.require("setspace"); // then the layouts - features.layout[GetLayout()] = true; + features.useLayout(getLayout()); // then the fonts Language const * doc_language = bparams.language; - for (FontList::const_iterator cit = fontlist.begin(); - cit != fontlist.end(); ++cit) { - if ((*cit).font().noun() == LyXFont::ON) { + for (Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); + cit != pimpl_->fontlist.end(); ++cit) { + if (cit->font().noun() == LyXFont::ON) { lyxerr[Debug::LATEX] << "font.noun: " - << (*cit).font().noun() + << cit->font().noun() << endl; - features.noun = true; + features.require("noun"); lyxerr[Debug::LATEX] << "Noun enabled. Font: " - << (*cit).font().stateText(0) + << cit->font().stateText(0) << endl; } - switch ((*cit).font().color()) { + switch (cit->font().color()) { case LColor::none: case LColor::inherit: case LColor::ignore: + // probably we should put here all interface colors used for + // font displaying! For now I just add this ones I know of (Jug) + case LColor::latex: + case LColor::note: break; default: - features.color = true; + features.require("color"); lyxerr[Debug::LATEX] << "Color enabled. Font: " - << (*cit).font().stateText(0) + << cit->font().stateText(0) << endl; } - Language const * language = (*cit).font().language(); - if (language->babel() != doc_language->babel()) { - features.UsedLanguages.insert(language); + Language const * language = cit->font().language(); + if (language->babel() != doc_language->babel() && + language != ignore_language && +#ifdef INHERIT_LANGUAGE + language != inherit_language && +#endif + language != latex_language) + { + features.useLanguage(language); lyxerr[Debug::LATEX] << "Found language " << language->babel() << endl; } } // then the insets + LyXLayout const & layout = + textclasslist.Style(bparams.textclass, getLayout()); + for (InsetList::const_iterator cit = insetlist.begin(); cit != insetlist.end(); ++cit) { - if ((*cit).inset) - (*cit).inset->Validate(features); + if (cit->inset) { + cit->inset->validate(features); + if (layout.needprotect && + cit->inset->lyxCode() == Inset::FOOT_CODE) + features.require("NeedLyXFootnoteCode"); + } } - -#ifndef NO_PEXTRA - if (params.pextraType() == PEXTRA_INDENT) - features.LyXParagraphIndent = true; - if (params.pextraType() == PEXTRA_FLOATFLT) - features.floatflt = true; -#endif -#ifndef NEW_INSETS - if (layout.needprotect - && next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) - features.NeedLyXFootnoteCode = true; -#endif -#ifndef NO_PEXTRA - if (bparams.paragraph_separation == BufferParams::PARSEP_INDENT - && params.pextraType() == LyXParagraph::PEXTRA_MINIPAGE) - features.NeedLyXMinipageIndent = true; -#endif -#ifndef NEW_INSETS - if (footnoteflag != NO_FOOTNOTE && footnotekind == ALGORITHM) - features.algorithm = true; -#endif } // First few functions needed for cut and paste and paragraph breaking. -void LyXParagraph::CopyIntoMinibuffer(Buffer const & buffer, - LyXParagraph::size_type pos) const +void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const { BufferParams bparams = buffer.params; - minibuffer_char = GetChar(pos); - minibuffer_font = GetFontSettings(bparams, pos); + minibuffer_char = getChar(pos); + minibuffer_font = getFontSettings(bparams, pos); minibuffer_inset = 0; - if (minibuffer_char == LyXParagraph::META_INSET) { - if (GetInset(pos)) { - minibuffer_inset = GetInset(pos)->Clone(buffer); + if (minibuffer_char == Paragraph::META_INSET) { + if (getInset(pos)) { + minibuffer_inset = getInset(pos)->clone(buffer); } else { minibuffer_inset = 0; minibuffer_char = ' '; @@ -425,15 +424,14 @@ void LyXParagraph::CopyIntoMinibuffer(Buffer const & buffer, } -void LyXParagraph::CutIntoMinibuffer(BufferParams const & bparams, - LyXParagraph::size_type pos) +void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos) { - minibuffer_char = GetChar(pos); - minibuffer_font = GetFontSettings(bparams, pos); + minibuffer_char = getChar(pos); + minibuffer_font = getFontSettings(bparams, pos); minibuffer_inset = 0; - if (minibuffer_char == LyXParagraph::META_INSET) { - if (GetInset(pos)) { - minibuffer_inset = GetInset(pos); + if (minibuffer_char == Paragraph::META_INSET) { + if (getInset(pos)) { + minibuffer_inset = getInset(pos); // This is a little hack since I want exactly // the inset, not just a clone. Otherwise // the inset would be deleted when calling Erase(pos) @@ -442,9 +440,11 @@ void LyXParagraph::CutIntoMinibuffer(BufferParams const & bparams, InsetList::iterator it = lower_bound(insetlist.begin(), insetlist.end(), - search_elem, matchIT()); - if (it != insetlist.end() && (*it).pos == pos) - (*it).inset = 0; + search_elem, Pimpl::matchIT()); + if (it != insetlist.end() && it->pos == pos) + it->inset = 0; + // the inset is not in a paragraph anymore + minibuffer_inset->parOwner(0); } else { minibuffer_inset = 0; minibuffer_char = ' '; @@ -457,15 +457,20 @@ void LyXParagraph::CutIntoMinibuffer(BufferParams const & bparams, } -bool LyXParagraph::InsertFromMinibuffer(LyXParagraph::size_type pos) +bool Paragraph::insertFromMinibuffer(pos_type pos) { - if ((minibuffer_char == LyXParagraph::META_INSET) && - !InsertInsetAllowed(minibuffer_inset)) - return false; - if (minibuffer_char == LyXParagraph::META_INSET) - InsertInset(pos, minibuffer_inset, minibuffer_font); - else - InsertChar(pos, minibuffer_char, minibuffer_font); + if (minibuffer_char == Paragraph::META_INSET) { + if (!insetAllowed(minibuffer_inset->lyxCode())) { + return false; + } + insertInset(pos, minibuffer_inset, minibuffer_font); + } else { + LyXFont f = minibuffer_font; + if (!checkInsertChar(f)) { + return false; + } + insertChar(pos, minibuffer_char, f); + } return true; } @@ -473,254 +478,79 @@ bool LyXParagraph::InsertFromMinibuffer(LyXParagraph::size_type pos) -void LyXParagraph::Clear() +void Paragraph::clear() { - params.clear(); + params().clear(); layout = 0; bibkey = 0; } -// the destructor removes the new paragraph from the list -LyXParagraph::~LyXParagraph() +void Paragraph::erase(pos_type pos) { - if (previous_) - previous_->next_ = next_; - if (next_) - next_->previous_ = previous_; - - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - delete (*it).inset; - } - - // ale970302 - delete bibkey; - // - //lyxerr << "LyXParagraph::paragraph_id = " - // << LyXParagraph::paragraph_id << endl; + pimpl_->erase(pos); } -void LyXParagraph::Erase(LyXParagraph::size_type pos) +bool Paragraph::checkInsertChar(LyXFont & font) { -#ifndef NEW_INSETS - // > because last is the next unused position, and you can - // use it if you want - if (pos > size()) { - if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - NextAfterFootnote()->Erase(pos - text.size() - 1); - else - lyxerr.debug() << "ERROR (LyXParagraph::Erase): " - "position does not exist." << endl; - return; - } -#else - Assert(pos < size()); -#endif -#ifndef NEW_INSETS - if (pos < size()) { // last is free for insertation, but should be empty -#endif - // if it is an inset, delete the inset entry - if (text[pos] == LyXParagraph::META_INSET) { - // find the entry - InsetTable search_inset(pos, 0); - InsetList::iterator it = - lower_bound(insetlist.begin(), - insetlist.end(), - search_inset, matchIT()); - if (it != insetlist.end() && (*it).pos == pos) { - delete (*it).inset; - insetlist.erase(it); - } - } - - text.erase(text.begin() + pos); - - // Erase entries in the tables. - FontTable search_font(pos, LyXFont()); - - FontList::iterator it = - lower_bound(fontlist.begin(), - fontlist.end(), - search_font, matchFT()); - if (it != fontlist.end() && (*it).pos() == pos && - (pos == 0 || - (it != fontlist.begin() && (*(it - 1)).pos() == pos - 1))) { - // If it is a multi-character font - // entry, we just make it smaller - // (see update below), otherwise we - // should delete it. - unsigned int const i = it - fontlist.begin(); - fontlist.erase(fontlist.begin() + i); - it = fontlist.begin() + i; - if (i > 0 && i < fontlist.size() && - fontlist[i - 1].font() == fontlist[i].font()) { - fontlist.erase(fontlist.begin() + i - 1); - it = fontlist.begin() + i - 1; - } - } - - // Update all other entries. - FontList::iterator fend = fontlist.end(); - for (; it != fend; ++it) - (*it).pos((*it).pos() - 1); - - // Update the inset table. - InsetTable search_inset(pos, 0); - InsetList::iterator lend = insetlist.end(); - for (InsetList::iterator it = - upper_bound(insetlist.begin(), - lend, - search_inset, matchIT()); - it != lend; ++it) - --(*it).pos; -#ifndef NEW_INSETS - } else { - lyxerr << "ERROR (LyXParagraph::Erase): " - "can't erase non-existant char." << endl; - } -#endif + if (pimpl_->inset_owner) + return pimpl_->inset_owner->checkInsertChar(font); + return true; } -void LyXParagraph::InsertChar(LyXParagraph::size_type pos, - LyXParagraph::value_type c) +void Paragraph::insertChar(pos_type pos, Paragraph::value_type c) { LyXFont const f(LyXFont::ALL_INHERIT); - InsertChar(pos, c, f); + insertChar(pos, c, f); } -void LyXParagraph::InsertChar(LyXParagraph::size_type pos, - LyXParagraph::value_type c, - LyXFont const & font) +void Paragraph::insertChar(pos_type pos, Paragraph::value_type c, + LyXFont const & font) { -#ifndef NEW_INSETS - // > because last is the next unused position, and you can - // use it if you want - if (pos > size()) { - if (next_ - && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - NextAfterFootnote()->InsertChar(pos - text.size() - 1, - c); - else - lyxerr.debug() << "ERROR (LyXParagraph::InsertChar): " - "position does not exist." << endl; - return; - } -#else - Assert(pos <= size()); -#endif - text.insert(text.begin() + pos, c); - - // Update the font table. - FontTable search_font(pos, LyXFont()); - for (FontList::iterator it = lower_bound(fontlist.begin(), - fontlist.end(), - search_font, matchFT()); - it != fontlist.end(); ++it) - (*it).pos((*it).pos() + 1); - - // Update the inset table. - InsetTable search_inset(pos, 0); - for (InsetList::iterator it = lower_bound(insetlist.begin(), - insetlist.end(), - search_inset, matchIT()); - it != insetlist.end(); ++it) - ++(*it).pos; - - SetFont(pos, font); + pimpl_->insertChar(pos, c, font); } -void LyXParagraph::InsertInset(LyXParagraph::size_type pos, - Inset * inset) +void Paragraph::insertInset(pos_type pos, Inset * inset) { LyXFont const f(LyXFont::ALL_INHERIT); - InsertInset(pos, inset, f); + insertInset(pos, inset, f); } -void LyXParagraph::InsertInset(LyXParagraph::size_type pos, - Inset * inset, LyXFont const & font) +void Paragraph::insertInset(pos_type pos, Inset * inset, LyXFont const & font) { - Assert(inset); - -#ifndef NEW_INSETS - // > because last is the next unused position, and you can - // use it if you want - if (pos > size()) { - if (next_ - && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - NextAfterFootnote() - ->InsertInset(pos - text.size() - 1, - inset, font); - else - lyxerr << "ERROR (LyXParagraph::InsertInset): " - "position does not exist: " << pos << endl; - return; - } -#else - Assert(pos <= size()); -#endif - - InsertChar(pos, META_INSET, font); - Assert(text[pos] == META_INSET); - - // Add a new entry in the inset table. - InsetTable search_inset(pos, 0); - InsetList::iterator it = lower_bound(insetlist.begin(), - insetlist.end(), - search_inset, matchIT()); - if (it != insetlist.end() && (*it).pos == pos) - lyxerr << "ERROR (LyXParagraph::InsertInset): " - "there is an inset in position: " << pos << endl; - else - insetlist.insert(it, InsetTable(pos, inset)); - if (inset_owner) - inset->setOwner(inset_owner); + pimpl_->insertInset(pos, inset, font); } -bool LyXParagraph::InsertInsetAllowed(Inset * inset) +bool Paragraph::insetAllowed(Inset::Code code) { - //lyxerr << "LyXParagraph::InsertInsetAllowed" << endl; + //lyxerr << "Paragraph::InsertInsetAllowed" << endl; - if (inset_owner) - return inset_owner->InsertInsetAllowed(inset); + if (pimpl_->inset_owner) + return pimpl_->inset_owner->insetAllowed(code); return true; } -Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos) +Inset * Paragraph::getInset(pos_type pos) { -#ifndef NEW_INSETS - if (pos >= size()) { - if (next_ - && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote() - ->GetInset(pos - text.size() - 1); - else - lyxerr << "ERROR (LyXParagraph::GetInset): " - "position does not exist: " - << pos << endl; - - return 0; - } -#else - Assert(pos < size()); -#endif + lyx::Assert(pos < size()); + // Find the inset. InsetTable search_inset(pos, 0); InsetList::iterator it = lower_bound(insetlist.begin(), insetlist.end(), - search_inset, matchIT()); - if (it != insetlist.end() && (*it).pos == pos) - return (*it).inset; + search_inset, Pimpl::matchIT()); + if (it != insetlist.end() && it->pos == pos) + return it->inset; - lyxerr << "ERROR (LyXParagraph::GetInset): " + lyxerr << "ERROR (Paragraph::getInset): " "Inset does not exist: " << pos << endl; //::raise(SIGSTOP); @@ -733,33 +563,19 @@ Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos) } -Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const +Inset const * Paragraph::getInset(pos_type pos) const { -#ifndef NEW_INSETS - if (pos >= size()) { - if (next_ - && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote() - ->GetInset(pos - text.size() - 1); - else - lyxerr << "ERROR (LyXParagraph::GetInset): " - "position does not exist: " - << pos << endl; + lyx::Assert(pos < size()); - return 0; - } -#else - Assert(pos < size()); -#endif // Find the inset. InsetTable search_inset(pos, 0); InsetList::const_iterator cit = lower_bound(insetlist.begin(), insetlist.end(), - search_inset, matchIT()); - if (cit != insetlist.end() && (*cit).pos == pos) - return (*cit).inset; + search_inset, Pimpl::matchIT()); + if (cit != insetlist.end() && cit->pos == pos) + return cit->inset; - lyxerr << "ERROR (LyXParagraph::GetInset): " + lyxerr << "ERROR (Paragraph::GetInset): " "Inset does not exist: " << pos << endl; //::raise(SIGSTOP); //text[pos] = ' '; // WHY!!! does this set the pos to ' '???? @@ -772,71 +588,37 @@ Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const // Gets uninstantiated font setting at position. -// Optimized after profiling. (Asger) -LyXFont const LyXParagraph::GetFontSettings(BufferParams const & bparams, - LyXParagraph::size_type pos) const +LyXFont const Paragraph::getFontSettings(BufferParams const & bparams, + pos_type pos) const { -#ifdef NEW_INSETS - Assert(pos <= size()); -#endif -#ifndef NEW_INSETS - if (pos < size()) { -#endif - FontTable search_font(pos, LyXFont()); - FontList::const_iterator cit = lower_bound(fontlist.begin(), - fontlist.end(), - search_font, matchFT()); - if (cit != fontlist.end()) - return (*cit).font(); -#ifndef NEW_INSETS - } -#endif -#ifndef NEW_INSETS - // > because last is the next unused position, and you can - // use it if you want - else if (pos > size()) { - if (next_ - && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote() - ->GetFontSettings(bparams, - pos - text.size() - 1); - else - // Why is it an error to ask for the font of a - // position that does not exist? Would it be - // enough for this to be enabled on debug? - // We want strict error checking, but it's ok to only - // have it when debugging. (Asger) - lyxerr << "ERROR (LyXParagraph::GetFontSettings): " - "position does not exist. " - << pos << " (" << static_cast(pos) - << ")" << endl; - } else if (pos > 0) { - return GetFontSettings(bparams, pos - 1); - } -#else - if (pos == size() && size()) - return GetFontSettings(bparams, pos - 1); + lyx::Assert(pos <= size()); + + Pimpl::FontTable search_font(pos, LyXFont()); + Pimpl::FontList::const_iterator cit = lower_bound(pimpl_->fontlist.begin(), + pimpl_->fontlist.end(), + search_font, Pimpl::matchFT()); + LyXFont retfont; + if (cit != pimpl_->fontlist.end()) { + retfont = cit->font(); + } else if (pos == size() && size()) { + retfont = getFontSettings(bparams, pos - 1); + } else + retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams)); +#ifdef INHERIT_LANGUAGE + if (retfont.language() == inherit_language) + retfont.setLanguage(bparams.language); #endif - //else - // pos = size() = 0 - return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams)); - //return LyXFont(LyXFont::ALL_INHERIT); + return retfont; } // Gets uninstantiated font setting at position 0 -LyXFont const LyXParagraph::GetFirstFontSettings() const +LyXFont const Paragraph::getFirstFontSettings() const { - if (size() > 0) { - if (!fontlist.empty()) - return fontlist[0].font(); - } + if (size() > 0 && !pimpl_->fontlist.empty()) + return pimpl_->fontlist[0].font(); -#ifndef NEW_INSETS - else if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) - return NextAfterFootnote()->GetFirstFontSettings(); -#endif return LyXFont(LyXFont::ALL_INHERIT); } @@ -848,77 +630,87 @@ LyXFont const LyXParagraph::GetFirstFontSettings() const // the true picture of the buffer. (Asger) // If position is -1, we get the layout font of the paragraph. // If position is -2, we get the font of the manual label of the paragraph. -LyXFont const LyXParagraph::getFont(BufferParams const & bparams, - LyXParagraph::size_type pos) const +LyXFont const Paragraph::getFont(BufferParams const & bparams, + pos_type pos) const { - LyXFont tmpfont; + lyx::Assert(pos >= 0); + LyXLayout const & layout = textclasslist.Style(bparams.textclass, - GetLayout()); - LyXParagraph::size_type main_body = 0; + getLayout()); + pos_type main_body = 0; if (layout.labeltype == LABEL_MANUAL) - main_body = BeginningOfMainBody(); + main_body = beginningOfMainBody(); - if (pos >= 0) { - LyXFont layoutfont; - if (pos < main_body) - layoutfont = layout.labelfont; - else - layoutfont = layout.font; - tmpfont = GetFontSettings(bparams, pos); - tmpfont.realize(layoutfont); - } else { - // process layoutfont for pos == -1 and labelfont for pos < -1 - if (pos == -1) - tmpfont = layout.font; - else - tmpfont = layout.labelfont; - tmpfont.setLanguage(getParLanguage(bparams)); - } + LyXFont layoutfont; + if (pos < main_body) + layoutfont = layout.labelfont; + else + layoutfont = layout.font; + + LyXFont tmpfont = getFontSettings(bparams, pos); +#ifndef INHERIT_LANGUAGE + tmpfont.realize(layoutfont); +#else + tmpfont.realize(layoutfont, bparams.language); +#endif - // check for environment font information - char par_depth = GetDepth(); - LyXParagraph const * par = this; - while (par && par_depth && !tmpfont.resolved()) { - par = par->DepthHook(par_depth - 1); - if (par) { - tmpfont.realize(textclasslist. - Style(bparams.textclass, - par->GetLayout()).font); - par_depth = par->GetDepth(); - } - } + return pimpl_->realizeFont(tmpfont, bparams); +} + + +LyXFont const Paragraph::getLabelFont(BufferParams const & bparams) const +{ + LyXLayout const & layout = + textclasslist.Style(bparams.textclass, getLayout()); + + LyXFont tmpfont = layout.labelfont; + tmpfont.setLanguage(getParLanguage(bparams)); + + return pimpl_->realizeFont(tmpfont, bparams); +} - tmpfont.realize(textclasslist - .TextClass(bparams.textclass) - .defaultfont()); - return tmpfont; + +LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams) const +{ + LyXLayout const & layout = + textclasslist.Style(bparams.textclass, + getLayout()); + + LyXFont tmpfont = layout.font; + tmpfont.setLanguage(getParLanguage(bparams)); + + return pimpl_->realizeFont(tmpfont, bparams); } /// Returns the height of the highest font in range LyXFont::FONT_SIZE -LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos, - LyXParagraph::size_type endpos) const +Paragraph::highestFontInRange(pos_type startpos, pos_type endpos, + LyXFont::FONT_SIZE const def_size) const { + if (pimpl_->fontlist.empty()) + return def_size; + LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY; - if (fontlist.empty()) - return maxsize; - - FontTable end_search(endpos, LyXFont()); - FontList::const_iterator end_it = lower_bound(fontlist.begin(), - fontlist.end(), - end_search, matchFT()); - if (end_it != fontlist.end()) + Pimpl::FontTable end_search(endpos, LyXFont()); + Pimpl::FontList::const_iterator end_it = + lower_bound(pimpl_->fontlist.begin(), + pimpl_->fontlist.end(), + end_search, Pimpl::matchFT()); + if (end_it != pimpl_->fontlist.end()) ++end_it; - FontTable start_search(startpos, LyXFont()); - for (FontList::const_iterator cit = - lower_bound(fontlist.begin(), - fontlist.end(), - start_search, matchFT()); - cit != end_it; ++cit) { - LyXFont::FONT_SIZE size = (*cit).font().size(); + Pimpl::FontTable start_search(startpos, LyXFont()); + Pimpl::FontList::const_iterator cit = + lower_bound(pimpl_->fontlist.begin(), + pimpl_->fontlist.end(), + start_search, Pimpl::matchFT()); + + for (; cit != end_it; ++cit) { + LyXFont::FONT_SIZE size = cit->font().size(); + if (size == LyXFont::INHERIT_SIZE) + size = def_size; if (size > maxsize && size <= LyXFont::SIZE_HUGER) maxsize = size; } @@ -926,75 +718,12 @@ LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos, } -LyXParagraph::value_type -LyXParagraph::GetChar(LyXParagraph::size_type pos) const +Paragraph::value_type +Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const { -#ifndef NEW_INSETS - Assert(pos >= 0); -#else - Assert(pos <= size()); - if (!size() || pos == size()) return '\0'; -#endif - -#ifndef NEW_INSETS - if (pos < size()) { -#endif - return text[pos]; -#ifndef NEW_INSETS - } -#endif -#ifndef NEW_INSETS - // > because last is the next unused position, and you can - // use it if you want - else if (pos > size()) { - if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) - return NextAfterFootnote() - ->GetChar(pos - text.size() - 1); - else - { - lyxerr << "ERROR (LyXParagraph::GetChar const): " - "position does not exist." - << pos << " (" << static_cast(pos) - << ")\n"; - Assert(false); - } - return '\0'; - } else { - // We should have a footnote environment. - if (!next_ || next_->footnoteflag == LyXParagraph::NO_FOOTNOTE) { - // Notice that LyX does request the - // last char from time to time. (Asger) - //lyxerr << "ERROR (LyXParagraph::GetChar): " - // "expected footnote." << endl; - return '\0'; - } - switch (next_->footnotekind) { - case LyXParagraph::FOOTNOTE: - return LyXParagraph::META_FOOTNOTE; - case LyXParagraph::MARGIN: - return LyXParagraph::META_MARGIN; - case LyXParagraph::FIG: - case LyXParagraph::WIDE_FIG: - return LyXParagraph::META_FIG; - case LyXParagraph::TAB: - case LyXParagraph::WIDE_TAB: - return LyXParagraph::META_TAB; - case LyXParagraph::ALGORITHM: - return LyXParagraph::META_ALGORITHM; - } - return '\0'; // to shut up gcc - } -#endif -} - - -LyXParagraph::value_type -LyXParagraph::GetUChar(BufferParams const & bparams, - LyXParagraph::size_type pos) const -{ - value_type c = GetChar(pos); - if (!lyxrc.rtl_support) - return c; + value_type c = getChar(pos); + if (!lyxrc.rtl_support) + return c; value_type uc = c; switch (c) { @@ -1023,134 +752,16 @@ LyXParagraph::GetUChar(BufferParams const & bparams, uc = '<'; break; } - if (uc != c && GetFontSettings(bparams, pos).isRightToLeft()) + if (uc != c && getFontSettings(bparams, pos).isRightToLeft()) return uc; else return c; } -// return an string of the current word, and the end of the word in lastpos. -string const LyXParagraph::GetWord(LyXParagraph::size_type & lastpos) const -{ - Assert(lastpos >= 0); - - // the current word is defined as starting at the first character - // from the immediate left of lastpospos which meets the definition - // of IsLetter(), continuing to the last character to the right - // of this meeting IsLetter. - - string theword; - - // grab a word - - // move back until we have a letter - - //there's no real reason to have firstpos & lastpos as - //separate variables as this is written, but maybe someon - // will want to return firstpos in the future. - - //since someone might have typed a punctuation first - int firstpos = lastpos; - - while ((firstpos >= 0) && !IsLetter(firstpos)) - --firstpos; - - // now find the beginning by looking for a nonletter - - while ((firstpos>= 0) && IsLetter(firstpos)) - --firstpos; - - // the above is now pointing to the preceeding non-letter - ++firstpos; - lastpos = firstpos; - - // so copy characters into theword until we get a nonletter - // note that this can easily exceed lastpos, wich means - // that if used in the middle of a word, the whole word - // is included - - while (IsLetter(lastpos)) theword += GetChar(lastpos++); - - return theword; - -} - - -#ifndef NEW_INSETS -LyXParagraph::size_type LyXParagraph::Last() const -{ - if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return text.size() + NextAfterFootnote()->Last() + 1; - // the 1 is the symbol - // for the footnote - else - return text.size(); -} -#endif - - -#ifndef NEW_INSETS -LyXParagraph * LyXParagraph::ParFromPos(LyXParagraph::size_type pos) -{ - // > because last is the next unused position, and you can - // use it if you want - if (pos > size()) { - if (next_ - && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote() - ->ParFromPos(pos - text.size() - 1); - else - lyxerr << "ERROR (LyXParagraph::ParFromPos): " - "position does not exist." << endl; - return this; - } else - return this; -} -#endif - - -#ifndef NEW_INSETS -int LyXParagraph::PositionInParFromPos(LyXParagraph::size_type pos) const -{ - // > because last is the next unused position, and you can - // use it if you want - if (pos > size()) { - if (next_ - && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - return NextAfterFootnote() - ->PositionInParFromPos(pos - text.size() - 1); - else - lyxerr << - "ERROR (LyXParagraph::PositionInParFromPos): " - "position does not exist." << endl; - return pos; - } - else - return pos; -} -#endif - -void LyXParagraph::SetFont(LyXParagraph::size_type pos, - LyXFont const & font) +void Paragraph::setFont(pos_type pos, LyXFont const & font) { -#ifndef NEW_INSETS - // > because last is the next unused position, and you can - // use it if you want - if (pos > size()) { - if (next_ && - next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - NextAfterFootnote()->SetFont(pos - text.size() - 1, - font); - } else - lyxerr << "ERROR (LyXParagraph::SetFont): " - "position does not exist." << endl; - - return; - } -#else - Assert(pos <= size()); -#endif + lyx::Assert(pos <= size()); // First, reduce font against layout/label font // Update: The SetCharFont() routine in text2.C already @@ -1159,913 +770,338 @@ void LyXParagraph::SetFont(LyXParagraph::size_type pos, // in a new kernel. (Asger) // Next search font table - FontTable search_font(pos, LyXFont()); - FontList::iterator it = lower_bound(fontlist.begin(), - fontlist.end(), - search_font, matchFT()); - unsigned int i = it - fontlist.begin(); - bool notfound = it == fontlist.end(); + Pimpl::FontTable search_font(pos, LyXFont()); + Pimpl::FontList::iterator it = lower_bound(pimpl_->fontlist.begin(), + pimpl_->fontlist.end(), + search_font, Pimpl::matchFT()); + unsigned int i = it - pimpl_->fontlist.begin(); + bool notfound = it == pimpl_->fontlist.end(); - if (!notfound && fontlist[i].font() == font) + if (!notfound && pimpl_->fontlist[i].font() == font) return; bool begin = pos == 0 || notfound || - (i > 0 && fontlist[i-1].pos() == pos - 1); + (i > 0 && pimpl_->fontlist[i-1].pos() == pos - 1); // Is position pos is a beginning of a font block? - bool end = !notfound && fontlist[i].pos() == pos; + bool end = !notfound && pimpl_->fontlist[i].pos() == pos; // Is position pos is the end of a font block? if (begin && end) { // A single char block - if (i + 1 < fontlist.size() && - fontlist[i + 1].font() == font) { + if (i + 1 < pimpl_->fontlist.size() && + pimpl_->fontlist[i + 1].font() == font) { // Merge the singleton block with the next block - fontlist.erase(fontlist.begin() + i); - if (i > 0 && fontlist[i - 1].font() == font) - fontlist.erase(fontlist.begin() + i-1); - } else if (i > 0 && fontlist[i - 1].font() == font) { + pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i); + if (i > 0 && pimpl_->fontlist[i - 1].font() == font) + pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i-1); + } else if (i > 0 && pimpl_->fontlist[i - 1].font() == font) { // Merge the singleton block with the previous block - fontlist[i - 1].pos(pos); - fontlist.erase(fontlist.begin() + i); + pimpl_->fontlist[i - 1].pos(pos); + pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i); } else - fontlist[i].font(font); + pimpl_->fontlist[i].font(font); } else if (begin) { - if (i > 0 && fontlist[i - 1].font() == font) - fontlist[i - 1].pos(pos); + if (i > 0 && pimpl_->fontlist[i - 1].font() == font) + pimpl_->fontlist[i - 1].pos(pos); else - fontlist.insert(fontlist.begin() + i, - FontTable(pos, font)); + pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i, + Pimpl::FontTable(pos, font)); } else if (end) { - fontlist[i].pos(pos - 1); - if (!(i + 1 < fontlist.size() && - fontlist[i + 1].font() == font)) - fontlist.insert(fontlist.begin() + i + 1, - FontTable(pos, font)); + pimpl_->fontlist[i].pos(pos - 1); + if (!(i + 1 < pimpl_->fontlist.size() && + pimpl_->fontlist[i + 1].font() == font)) + pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1, + Pimpl::FontTable(pos, font)); } else { // The general case. The block is splitted into 3 blocks - fontlist.insert(fontlist.begin() + i, - FontTable(pos - 1, fontlist[i].font())); - fontlist.insert(fontlist.begin() + i + 1, - FontTable(pos, font)); + pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i, + Pimpl::FontTable(pos - 1, pimpl_->fontlist[i].font())); + pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1, + Pimpl::FontTable(pos, font)); } } -void LyXParagraph::next(LyXParagraph * p) +void Paragraph::next(Paragraph * p) { next_ = p; } // This function is able to hide closed footnotes. -LyXParagraph * LyXParagraph::next() -{ -#ifndef NEW_INSETS - if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - LyXParagraph * tmp = next_; - while (tmp - && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - tmp = tmp->next_; - if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp->next(); /* there can be more than one - footnote in a logical - paragraph */ - else - return next_; // This should never happen! - } else -#endif - return next_; -} - - -LyXParagraph const * LyXParagraph::next() const -{ -#ifndef NEW_INSETS - if (next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - LyXParagraph * tmp = next_; - while (tmp - && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - tmp = tmp->next_; - if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp->next(); /* there can be more than one - footnote in a logical - paragraph */ - else - return next_; // This should never happen! - } else -#endif - return next_; -} - - -#ifndef NEW_INSETS -LyXParagraph * LyXParagraph::NextAfterFootnote() +Paragraph * Paragraph::next() { - if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - LyXParagraph * tmp = next_; - while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) - tmp = tmp->next_; - if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp; /* there can be more than one footnote - in a logical paragraph */ - else - return next_; // This should never happen! - } else - return next_; -} -#endif - - -#ifndef NEW_INSETS -LyXParagraph const * LyXParagraph::NextAfterFootnote() const -{ - if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - LyXParagraph * tmp = next_; - while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) - tmp = tmp->next_; - if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp; /* there can be more than one footnote - in a logical paragraph */ - else - return next_; // This should never happen! - } else - return next_; -} -#endif - - -#ifndef NEW_INSETS -LyXParagraph * LyXParagraph::PreviousBeforeFootnote() -{ - LyXParagraph * tmp; - if (previous_ && previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - tmp = previous_; - while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) - tmp = tmp->previous_; - if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp; /* there can be more than one footnote - in a logical paragraph */ - else - return previous_; // This should never happen! - } else - return previous_; -} -#endif - - -#ifndef NEW_INSETS -LyXParagraph * LyXParagraph::LastPhysicalPar() -{ - if (footnoteflag != LyXParagraph::NO_FOOTNOTE) - return this; - - LyXParagraph * tmp = this; - while (tmp->next_ - && tmp->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) - tmp = tmp->NextAfterFootnote(); - - return tmp; -} -#endif - - -#ifndef NEW_INSETS -LyXParagraph const * LyXParagraph::LastPhysicalPar() const -{ - if (footnoteflag != LyXParagraph::NO_FOOTNOTE) - return this; - - LyXParagraph const * tmp = this; - while (tmp->next_ - && tmp->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE) - tmp = tmp->NextAfterFootnote(); - - return tmp; -} -#endif - - -#ifndef NEW_INSETS -LyXParagraph * LyXParagraph::FirstPhysicalPar() -{ - if (!IsDummy()) - return this; - LyXParagraph * tmppar = this; - - while (tmppar && - (tmppar->IsDummy() - || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE)) - tmppar = tmppar->previous_; - - if (!tmppar) { - return this; - } else - return tmppar; + return next_; } -#endif -#ifndef NEW_INSETS -LyXParagraph const * LyXParagraph::FirstPhysicalPar() const +Paragraph const * Paragraph::next() const { - if (!IsDummy()) - return this; - LyXParagraph const * tmppar = this; - - while (tmppar && - (tmppar->IsDummy() - || tmppar->footnoteflag != LyXParagraph::NO_FOOTNOTE)) - tmppar = tmppar->previous_; - - if (!tmppar) { - return this; - } else - return tmppar; + return next_; } -#endif -void LyXParagraph::previous(LyXParagraph * p) +void Paragraph::previous(Paragraph * p) { previous_ = p; } // This function is able to hide closed footnotes. -LyXParagraph * LyXParagraph::previous() +Paragraph * Paragraph::previous() { -#ifndef NEW_INSETS - LyXParagraph * tmp = previous_; - if (!tmp) - return tmp; - - if (tmp->previous_ - && tmp->previous_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - tmp = tmp->previous_; - while (tmp - && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - tmp = tmp->previous_; - if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp->next_->previous(); - - else - return previous_; - } else -#endif - return previous_; + return previous_; } // This function is able to hide closed footnotes. -LyXParagraph const * LyXParagraph::previous() const +Paragraph const * Paragraph::previous() const { -#ifndef NEW_INSETS - LyXParagraph * tmp = previous_; - if (!tmp) - return tmp; - if (tmp->previous_ - && tmp->previous_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - tmp = tmp->previous_; - while (tmp - && tmp->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) - tmp = tmp->previous_; - if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) - return tmp->next_->previous(); - - else - return previous_; - } else -#endif - return previous_; + return previous_; } -void LyXParagraph::BreakParagraph(BufferParams const & bparams, - LyXParagraph::size_type pos, +void Paragraph::breakParagraph(BufferParams const & bparams, + pos_type pos, int flag) { - size_type i; - size_type j; // create a new paragraph -#ifndef NEW_INSETS - size_type pos_end; - size_type pos_first; - LyXParagraph * par = ParFromPos(pos); - LyXParagraph * firstpar = FirstPhysicalPar(); - - LyXParagraph * tmp = new LyXParagraph(par); -#else - //LyXParagraph * par = this; - //LyXParagraph * firstpar = this; - LyXParagraph * tmp = new LyXParagraph(this); -#endif - -#ifndef NEW_INSETS - tmp->footnoteflag = footnoteflag; - tmp->footnotekind = footnotekind; -#endif + Paragraph * tmp = new Paragraph(this); + // remember to set the inset_owner + tmp->setInsetOwner(inInset()); + // this is an idea for a more userfriendly layout handling, I will // see what the users say - -#ifndef NEW_INSETS - // layout stays the same with latex-environments - if (flag) { - tmp->SetOnlyLayout(bparams, firstpar->layout); - tmp->SetLabelWidthString(firstpar->params.labelWidthString()); - } -#else + // layout stays the same with latex-environments if (flag) { - tmp->SetOnlyLayout(bparams, layout); - tmp->SetLabelWidthString(params.labelWidthString()); + tmp->setOnlyLayout(layout); + tmp->setLabelWidthString(params().labelWidthString()); } -#endif -#ifndef NEW_INSETS - if (Last() > pos || !Last() || flag == 2) { - tmp->SetOnlyLayout(bparams, firstpar->layout); - tmp->params.align(firstpar->params.align()); - tmp->SetLabelWidthString(firstpar->params.labelWidthString()); - - tmp->params.lineBottom(firstpar->params.lineBottom()); - firstpar->params.lineBottom(false); - tmp->params.pagebreakBottom(firstpar->params.pagebreakBottom()); - firstpar->params.pagebreakBottom(false); - tmp->params.spaceBottom(firstpar->params.spaceBottom()); - firstpar->params.spaceBottom(VSpace(VSpace::NONE)); - - tmp->params.depth(firstpar->params.depth()); - tmp->params.noindent(firstpar->params.noindent()); -#else + if (size() > pos || !size() || flag == 2) { - tmp->SetOnlyLayout(bparams, layout); - tmp->params.align(params.align()); - tmp->SetLabelWidthString(params.labelWidthString()); - - tmp->params.lineBottom(params.lineBottom()); - params.lineBottom(false); - tmp->params.pagebreakBottom(params.pagebreakBottom()); - params.pagebreakBottom(false); - tmp->params.spaceBottom(params.spaceBottom()); - params.spaceBottom(VSpace(VSpace::NONE)); - - tmp->params.depth(params.depth()); - tmp->params.noindent(params.noindent()); -#endif + tmp->setOnlyLayout(layout); + tmp->params().align(params().align()); + tmp->setLabelWidthString(params().labelWidthString()); + + tmp->params().lineBottom(params().lineBottom()); + params().lineBottom(false); + tmp->params().pagebreakBottom(params().pagebreakBottom()); + params().pagebreakBottom(false); + tmp->params().spaceBottom(params().spaceBottom()); + params().spaceBottom(VSpace(VSpace::NONE)); + + tmp->params().depth(params().depth()); + tmp->params().noindent(params().noindent()); + // copy everything behind the break-position // to the new paragraph -#ifndef NEW_INSETS - pos_first = 0; - while (ParFromPos(pos_first) != par) - ++pos_first; - pos_end = pos_first + par->text.size() - 1; - - - for (i = j = pos; i <= pos_end; ++i) { - par->CutIntoMinibuffer(bparams, i - pos_first); - if (tmp->InsertFromMinibuffer(j - pos)) - ++j; - } - - tmp->fitToSize(); - - for (i = pos_end; i >= pos; --i) - par->Erase(i - pos_first); - - par->fitToSize(); -#else - size_type pos_end = text.size() - 1; - - for (i = j = pos; i <= pos_end; ++i) { - CutIntoMinibuffer(bparams, i); - if (tmp->InsertFromMinibuffer(j - pos)) + pos_type pos_end = pimpl_->size() - 1; + pos_type i = pos; + pos_type j = pos; + for (; i <= pos_end; ++i) { + cutIntoMinibuffer(bparams, i); + if (tmp->insertFromMinibuffer(j - pos)) ++j; } - tmp->fitToSize(); - for (i = pos_end; i >= pos; --i) - Erase(i); - - fitToSize(); -#endif - } - -#ifndef NEW_INSETS - // just an idea of me - if (!pos) { - tmp->params.lineTop(firstpar->params.lineTop()); - tmp->params.pagebreakTop(firstpar->params.pagebreakTop()); - tmp->params.spaceTop(firstpar->params.spaceTop()); - tmp->bibkey = firstpar->bibkey; - firstpar->Clear(); - // layout stays the same with latex-environments - if (flag) { - firstpar->SetOnlyLayout(bparams, tmp->layout); - firstpar->SetLabelWidthString(tmp->params.labelWidthString()); - firstpar->params.depth(tmp->params.depth()); + for (i = pos_end; i >= pos; --i) { + erase(i); } } -#else + // just an idea of me if (!pos) { - tmp->params.lineTop(params.lineTop()); - tmp->params.pagebreakTop(params.pagebreakTop()); - tmp->params.spaceTop(params.spaceTop()); + tmp->params().lineTop(params().lineTop()); + tmp->params().pagebreakTop(params().pagebreakTop()); + tmp->params().spaceTop(params().spaceTop()); tmp->bibkey = bibkey; - Clear(); + clear(); // layout stays the same with latex-environments if (flag) { - SetOnlyLayout(bparams, tmp->layout); - SetLabelWidthString(tmp->params.labelWidthString()); - params.depth(tmp->params.depth()); + setOnlyLayout(tmp->layout); + setLabelWidthString(tmp->params().labelWidthString()); + params().depth(tmp->params().depth()); } } -#endif } - - -void LyXParagraph::MakeSameLayout(LyXParagraph const * par) -{ -#ifndef NEW_INSETS - par = par->FirstPhysicalPar(); - footnoteflag = par->footnoteflag; - footnotekind = par->footnotekind; -#endif - layout = par->layout; - params.makeSame(par->params); - // This can be changed after NEW_INSETS is in effect. (Lgb) - SetLabelWidthString(par->params.labelWidthString()); -} - -#ifndef NEW_INSETS -LyXParagraph * LyXParagraph::FirstSelfrowPar() +void Paragraph::makeSameLayout(Paragraph const * par) { - LyXParagraph * tmppar = this; - while (tmppar && ( - (tmppar->IsDummy() - && tmppar->previous_->footnoteflag == - LyXParagraph::CLOSED_FOOTNOTE) - || tmppar->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE)) - tmppar = tmppar->previous_; - - if (!tmppar) - return this; // This should never happen! - else - return tmppar; + layout = par->layout; + // move to pimpl? + params() = par->params(); } -#endif -int LyXParagraph::StripLeadingSpaces(LyXTextClassList::size_type tclass) +int Paragraph::stripLeadingSpaces(lyx::textclass_type tclass) { - if (textclasslist.Style(tclass, GetLayout()).free_spacing) + if (textclasslist.Style(tclass, getLayout()).free_spacing || + isFreeSpacing()) + { return 0; + } int i = 0; -#ifndef NEW_INSETS - if (!IsDummy()) { - while (Last() -#else - while (size() -#endif - && (IsNewline(0) || IsLineSeparator(0))){ - Erase(0); - ++i; - } -#ifndef NEW_INSETS + while (size() && (isNewline(0) || isLineSeparator(0))) { + erase(0); + ++i; } -#endif - return i; -} - - -LyXParagraph * LyXParagraph::Clone() const -{ - // create a new paragraph - LyXParagraph * result = new LyXParagraph; - - result->MakeSameLayout(this); - // this is because of the dummy layout of the paragraphs that - // follow footnotes - result->layout = layout; - - result->inset_owner = inset_owner; - - // ale970302 - if (bibkey) - result->bibkey = static_cast - (bibkey->Clone(*current_view->buffer())); - else - result->bibkey = 0; - - // copy everything behind the break-position to the new paragraph - - result->text = text; - result->fontlist = fontlist; - result->insetlist = insetlist; - for (InsetList::iterator it = result->insetlist.begin(); - it != result->insetlist.end(); ++it) - (*it).inset = (*it).inset->Clone(*current_view->buffer()); - return result; + return i; } -bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const +bool Paragraph::hasSameLayout(Paragraph const * par) const { -#ifndef NEW_INSETS - par = par->FirstPhysicalPar(); -#endif - return -#ifndef NEW_INSETS - par->footnoteflag == footnoteflag && - par->footnotekind == footnotekind && -#endif par->layout == layout && - params.sameLayout(par->params); + params().sameLayout(par->params()); } -void LyXParagraph::BreakParagraphConservative(BufferParams const & bparams, - LyXParagraph::size_type pos) +void Paragraph::breakParagraphConservative(BufferParams const & bparams, + pos_type pos) { -#ifndef NEW_INSETS - // create a new paragraph - LyXParagraph * par = ParFromPos(pos); - - LyXParagraph * tmp = new LyXParagraph(par); - - tmp->MakeSameLayout(par); - - // When can pos < Last()? - // I guess pos == Last() is possible. - if (Last() > pos) { - // copy everything behind the break-position to the new - // paragraph - size_type pos_first = 0; - while (ParFromPos(pos_first) != par) - ++pos_first; - size_type pos_end = pos_first + par->text.size() - 1; - - size_type i, j; - for (i = j = pos; i <= pos_end; ++i) { - par->CutIntoMinibuffer(bparams, i - pos_first); - if (tmp->InsertFromMinibuffer(j - pos)) - ++j; - } - - tmp->fitToSize(); - - for (size_type i = pos_end; i >= pos; --i) - par->Erase(i - pos_first); - - par->fitToSize(); - } -#else // create a new paragraph - LyXParagraph * tmp = new LyXParagraph(this); - tmp->MakeSameLayout(this); + Paragraph * tmp = new Paragraph(this); + tmp->makeSameLayout(this); // When can pos > Last()? // I guess pos == Last() is possible. if (size() > pos) { // copy everything behind the break-position to the new // paragraph - size_type pos_end = text.size() - 1; + pos_type pos_end = pimpl_->size() - 1; - size_type i, j; - for (i = j = pos; i <= pos_end; ++i) { - CutIntoMinibuffer(bparams, i); - if (tmp->InsertFromMinibuffer(j - pos)) + //pos_type i = pos; + //pos_type j = pos; + for (pos_type i = pos, j = pos; i <= pos_end; ++i) { + cutIntoMinibuffer(bparams, i); + if (tmp->insertFromMinibuffer(j - pos)) ++j; } - - tmp->fitToSize(); - for (size_type i = pos_end; i >= pos; --i) - Erase(i); - - fitToSize(); + for (pos_type k = pos_end; k >= pos; --k) { + erase(k); + } } -#endif } - + // Be carefull, this does not make any check at all. // This method has wrong name, it combined this par with the next par. // In that sense it is the reverse of break paragraph. (Lgb) -void LyXParagraph::PasteParagraph(BufferParams const & bparams) +void Paragraph::pasteParagraph(BufferParams const & bparams) { // copy the next paragraph to this one - LyXParagraph * the_next = next(); - + Paragraph * the_next = next(); + // first the DTP-stuff -#ifndef NEW_INSETS - LyXParagraph * firstpar = FirstPhysicalPar(); - firstpar->params.lineBottom(the_next->params.lineBottom()); - firstpar->params.spaceBottom(the_next->params.spaceBottom()); - firstpar->params.pagebreakBottom(the_next->params.pagebreakBottom()); - - size_type pos_end = the_next->text.size() - 1; - size_type pos_insert = Last(); -#else - params.lineBottom(the_next->params.lineBottom()); - params.spaceBottom(the_next->params.spaceBottom()); - params.pagebreakBottom(the_next->params.pagebreakBottom()); + params().lineBottom(the_next->params().lineBottom()); + params().spaceBottom(the_next->params().spaceBottom()); + params().pagebreakBottom(the_next->params().pagebreakBottom()); - size_type pos_end = the_next->text.size() - 1; - size_type pos_insert = size(); -#endif + pos_type pos_end = the_next->pimpl_->size() - 1; + pos_type pos_insert = size(); // ok, now copy the paragraph - size_type i, j; - for (i = j = 0; i <= pos_end; ++i) { - the_next->CutIntoMinibuffer(bparams, i); - if (InsertFromMinibuffer(pos_insert + j)) + for (pos_type i = 0, j = 0; i <= pos_end; ++i) { + the_next->cutIntoMinibuffer(bparams, i); + if (insertFromMinibuffer(pos_insert + j)) ++j; } - + // delete the next paragraph - LyXParagraph * ppar = the_next->previous_; - LyXParagraph * npar = the_next->next_; + Paragraph * ppar = the_next->previous_; + Paragraph * npar = the_next->next_; delete the_next; ppar->next(npar); } -#ifndef NEW_INSETS -void LyXParagraph::OpenFootnote(LyXParagraph::size_type pos) -{ - LyXParagraph * par = ParFromPos(pos); - par = par->next_; - while (par && par->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - par->footnoteflag = LyXParagraph::OPEN_FOOTNOTE; - par = par->next_; - } -} - - -void LyXParagraph::CloseFootnote(LyXParagraph::size_type pos) -{ - LyXParagraph * par = ParFromPos(pos); - par = par->next_; - while (par && par->footnoteflag == LyXParagraph::OPEN_FOOTNOTE) { - par->footnoteflag = LyXParagraph::CLOSED_FOOTNOTE; - par = par->next_; - } -} -#endif - - -int LyXParagraph::GetEndLabel(BufferParams const & bparams) const +int Paragraph::getEndLabel(BufferParams const & bparams) const { - LyXParagraph const * par = this; - int par_depth = GetDepth(); + Paragraph const * par = this; + depth_type par_depth = getDepth(); while (par) { - LyXTextClass::LayoutList::size_type layout = par->GetLayout(); + layout_type layout = par->getLayout(); int const endlabeltype = textclasslist.Style(bparams.textclass, layout).endlabeltype; if (endlabeltype != END_LABEL_NO_LABEL) { - LyXParagraph const * last = this; -#ifndef NEW_INSETS - if (footnoteflag == NO_FOOTNOTE) - last = LastPhysicalPar(); - else if (next_->footnoteflag == NO_FOOTNOTE) - return endlabeltype; -#else - last = this; -#endif - - if (!last || !last->next_) + if (!next_) return endlabeltype; - int next_depth = last->next_->GetDepth(); + depth_type const next_depth = next_->getDepth(); if (par_depth > next_depth || - (par_depth == next_depth && layout != last->next_->GetLayout() )) + (par_depth == next_depth + && layout != next_->getLayout())) return endlabeltype; break; } if (par_depth == 0) break; - par = par->DepthHook(par_depth - 1); + par = par->outerHook(); if (par) - par_depth = par->GetDepth(); + par_depth = par->getDepth(); } return END_LABEL_NO_LABEL; } -LyXTextClass::size_type LyXParagraph::GetLayout() const +Paragraph::depth_type Paragraph::getDepth() const { -#ifndef NEW_INSETS - return FirstPhysicalPar()->layout; -#else - return layout; -#endif -} - - -char LyXParagraph::GetDepth() const -{ -#ifndef NEW_INSETS - return FirstPhysicalPar()->params.depth(); -#else - return params.depth(); -#endif + return params().depth(); } -char LyXParagraph::GetAlign() const +char Paragraph::getAlign() const { -#ifndef NEW_INSETS - return FirstPhysicalPar()->params.align(); -#else - return params.align(); -#endif + return params().align(); } -string const & LyXParagraph::GetLabelstring() const +string const & Paragraph::getLabelstring() const { -#ifndef NEW_INSETS - return FirstPhysicalPar()->params.labelString(); -#else - return params.labelString(); -#endif + return params().labelString(); } -int LyXParagraph::GetFirstCounter(int i) const +int Paragraph::getFirstCounter(int i) const { -#ifndef NEW_INSETS - return FirstPhysicalPar()->counter_[i]; -#else - return counter_[i]; -#endif + return pimpl_->counter_[i]; } // the next two functions are for the manual labels -string const LyXParagraph::GetLabelWidthString() const +string const Paragraph::getLabelWidthString() const { -#ifndef NEW_INSETS - if (!FirstPhysicalPar()->params.labelWidthString().empty()) - return FirstPhysicalPar()->params.labelWidthString(); -#else - if (!params.labelWidthString().empty()) - return params.labelWidthString(); -#endif + if (!params().labelWidthString().empty()) + return params().labelWidthString(); else return _("Senseless with this layout!"); } -void LyXParagraph::SetLabelWidthString(string const & s) +void Paragraph::setLabelWidthString(string const & s) { -#ifndef NEW_INSETS - LyXParagraph * par = FirstPhysicalPar(); - - par->params.labelWidthString(s); -#else - params.labelWidthString(s); -#endif + params().labelWidthString(s); } -void LyXParagraph::SetOnlyLayout(BufferParams const & bparams, - LyXTextClass::size_type new_layout) +void Paragraph::setOnlyLayout(layout_type new_layout) { -#ifndef NEW_INSETS - LyXParagraph * par = FirstPhysicalPar(); -#else - LyXParagraph * par = this; -#endif - LyXParagraph * ppar = 0; - LyXParagraph * npar = 0; + layout = new_layout; +} - par->layout = new_layout; -#ifndef NO_PEXTRA - if (par->params.pextraType() == PEXTRA_NONE) { -#endif - if (par->previous()) { -#ifndef NEW_INSETS - ppar = par->previous()->FirstPhysicalPar(); -#else - ppar = par->previous(); -#endif - while(ppar - && ppar->previous() - && (ppar->params.depth() > par->params.depth())) -#ifndef NEW_INSETS - ppar = ppar->previous()->FirstPhysicalPar(); -#else - ppar = ppar->previous(); -#endif - } - if (par->next()) { -#ifndef NEW_INSETS - npar = par->next()->NextAfterFootnote(); -#else - npar = par->next(); -#endif - while(npar - && npar->next() - && (npar->params.depth() > par->params.depth())) -#ifndef NEW_INSETS - npar = npar->next()->NextAfterFootnote(); -#else - npar = npar->next(); -#endif - } -#ifndef NO_PEXTRA - if (ppar && (ppar->params.pextraType() != PEXTRA_NONE)) { - string p1 = ppar->params.pextraWidth(); - string p2 = ppar->params.pextraWidthp(); - ppar->SetPExtraType(bparams, - ppar->params.pextraType(), - p1, p2); - } - if ((par->params.pextraType() == PEXTRA_NONE) && - npar && (npar->params.pextraType() != PEXTRA_NONE)) { - string const p1 = npar->params.pextraWidth(); - string const p2 = npar->params.pextraWidthp(); - npar->SetPExtraType(bparams, npar->params.pextraType(), - p1, p2); - } - } -#endif -} - - -void LyXParagraph::SetLayout(BufferParams const & bparams, - LyXTextClass::size_type new_layout) -{ - LyXParagraph -#ifndef NEW_INSETS - * par = FirstPhysicalPar(), -#else - * par = this, -#endif - * ppar = 0, - * npar = 0; - - par->layout = new_layout; - par->params.labelWidthString(string()); - par->params.align(LYX_ALIGN_LAYOUT); - par->params.spaceTop(VSpace(VSpace::NONE)); - par->params.spaceBottom(VSpace(VSpace::NONE)); - par->params.spacing(Spacing(Spacing::Default)); - -#ifndef NO_PEXTRA - if (par->params.pextraType() == PEXTRA_NONE) { -#endif - if (par->previous()) { -#ifndef NEW_INSETS - ppar = par->previous()->FirstPhysicalPar(); -#else - ppar = par->previous(); -#endif - while(ppar - && ppar->previous() - && (ppar->params.depth() > par->params.depth())) -#ifndef NEW_INSETS - ppar = ppar->previous()->FirstPhysicalPar(); -#else - ppar = ppar->previous(); -#endif - } - if (par->next()) { -#ifndef NEW_INSETS - npar = par->next()->NextAfterFootnote(); -#else - npar = par->next(); -#endif - while(npar - && npar->next() - && (npar->params.depth() > par->params.depth())) -#ifndef NEW_INSETS - npar = npar->next()->NextAfterFootnote(); -#else - npar = npar->next(); -#endif - } -#ifndef NO_PEXTRA - if (ppar && (ppar->params.pextraType() != PEXTRA_NONE)) { - string const p1 = ppar->params.pextraWidth(); - string const p2 = ppar->params.pextraWidthp(); - ppar->SetPExtraType(bparams, ppar->params.pextraType(), - p1, p2); - } - if ((par->params.pextraType() == PEXTRA_NONE) && - npar && (npar->params.pextraType() != PEXTRA_NONE)) { - string const p1 = npar->params.pextraWidth(); - string const p2 = npar->params.pextraWidthp(); - npar->SetPExtraType(bparams, npar->params.pextraType(), - p1, p2); - } - } -#endif +void Paragraph::setLayout(layout_type new_layout) +{ + layout = new_layout; + params().labelWidthString(string()); + params().align(LYX_ALIGN_LAYOUT); + params().spaceTop(VSpace(VSpace::NONE)); + params().spaceBottom(VSpace(VSpace::NONE)); + params().spacing(Spacing(Spacing::Default)); } @@ -2076,235 +1112,198 @@ void LyXParagraph::SetLayout(BufferParams const & bparams, // because there cannot be a newline or a blank <= the beginning of the // main body in TeX. -int LyXParagraph::BeginningOfMainBody() const +int Paragraph::beginningOfMainBody() const { -#ifndef NEW_INSETS - if (FirstPhysicalPar() != this) - return -1; -#endif // Unroll the first two cycles of the loop // and remember the previous character to // remove unnecessary GetChar() calls - size_type i = 0; + pos_type i = 0; if (i < size() - && GetChar(i) != LyXParagraph::META_NEWLINE - ) { + && getChar(i) != Paragraph::META_NEWLINE) { ++i; char previous_char = 0; char temp = 0; if (i < size() - && (previous_char = GetChar(i)) != LyXParagraph::META_NEWLINE) { + && (previous_char = getChar(i)) != Paragraph::META_NEWLINE) { // Yes, this ^ is supposed to be "= " not "==" ++i; while (i < size() && previous_char != ' ' - && (temp = GetChar(i)) != LyXParagraph::META_NEWLINE) { + && (temp = getChar(i)) != Paragraph::META_NEWLINE) { ++i; previous_char = temp; } } } -#ifndef NEW_INSETS - if (i == 0 && i == size() && - !(footnoteflag == LyXParagraph::NO_FOOTNOTE - && next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE)) - ++i; /* the cursor should not jump - * to the main body if there - * is nothing in! */ -#endif return i; } -LyXParagraph * LyXParagraph::DepthHook(int deth) +Paragraph * Paragraph::depthHook(depth_type depth) { - LyXParagraph * newpar = this; - if (deth < 0) - return 0; - + Paragraph * newpar = this; + do { -#ifndef NEW_INSETS - newpar = newpar->FirstPhysicalPar()->previous(); -#else newpar = newpar->previous(); -#endif - } while (newpar && newpar->GetDepth() > deth -#ifndef NEW_INSETS - && newpar->footnoteflag == footnoteflag -#endif - ); - + } while (newpar && newpar->getDepth() > depth); + if (!newpar) { - if (previous() || GetDepth()) - lyxerr << "ERROR (LyXParagraph::DepthHook): " + if (previous() || getDepth()) + lyxerr << "ERROR (Paragraph::DepthHook): " "no hook." << endl; newpar = this; } -#ifndef NEW_INSETS - return newpar->FirstPhysicalPar(); -#else + return newpar; -#endif } -LyXParagraph const * LyXParagraph::DepthHook(int deth) const +Paragraph const * Paragraph::depthHook(depth_type depth) const { - LyXParagraph const * newpar = this; - if (deth < 0) - return 0; - + Paragraph const * newpar = this; + do { -#ifndef NEW_INSETS - newpar = newpar->FirstPhysicalPar()->previous(); -#else newpar = newpar->previous(); -#endif - } while (newpar && newpar->GetDepth() > deth -#ifndef NEW_INSETS - && newpar->footnoteflag == footnoteflag -#endif - ); - + } while (newpar && newpar->getDepth() > depth); + if (!newpar) { - if (previous() || GetDepth()) - lyxerr << "ERROR (LyXParagraph::DepthHook): " + if (previous() || getDepth()) + lyxerr << "ERROR (Paragraph::DepthHook): " "no hook." << endl; newpar = this; } -#ifndef NEW_INSETS - return newpar->FirstPhysicalPar(); -#else + return newpar; -#endif } +Paragraph * Paragraph::outerHook() +{ + if(!getDepth()) + return 0; + return depthHook(depth_type(getDepth() - 1)); +} -int LyXParagraph::AutoDeleteInsets() +Paragraph const * Paragraph::outerHook() const { - int count = 0; - InsetList::size_type index = 0; - while (index < insetlist.size()) { - if (insetlist[index].inset && insetlist[index].inset->AutoDelete()) { - Erase(insetlist[index].pos); - // Erase() calls to insetlist.erase(&insetlist[index]) - // so index shouldn't be increased. - ++count; - } else - ++index; - } - return count; + if(!getDepth()) + return 0; + return depthHook(depth_type(getDepth() - 1)); } -LyXParagraph::inset_iterator -LyXParagraph::InsetIterator(LyXParagraph::size_type pos) +Paragraph::inset_iterator +Paragraph::InsetIterator(pos_type pos) { InsetTable search_inset(pos, 0); InsetList::iterator it = lower_bound(insetlist.begin(), insetlist.end(), - search_inset, matchIT()); + search_inset, Pimpl::matchIT()); return inset_iterator(it); } // returns -1 if inset not found -int LyXParagraph::GetPositionOfInset(Inset * inset) const +int Paragraph::getPositionOfInset(Inset const * inset) const { // Find the entry. for (InsetList::const_iterator cit = insetlist.begin(); cit != insetlist.end(); ++cit) { - if ((*cit).inset == inset) { - return (*cit).pos; + if (cit->inset == inset) { + return cit->pos; } } if (inset == bibkey) return 0; -#ifndef NEW_INSETS - // Think about footnotes. - if (footnoteflag == LyXParagraph::NO_FOOTNOTE - && next_ && next_->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { - int const further = - NextAfterFootnote()->GetPositionOfInset(inset); - if (further != -1) - return text.size() + 1 + further; - } -#endif return -1; } -LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow, - bool moving_arg -#ifndef NEW_INSETS - , - ostream & foot, - TexRow & foot_texrow, - int & foot_count -#endif - ) +Paragraph * Paragraph::TeXOnePar(Buffer const * buf, + BufferParams const & bparams, + ostream & os, TexRow & texrow, + bool moving_arg) { lyxerr[Debug::LATEX] << "TeXOnePar... " << this << endl; - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - layout); - + Inset const * in = inInset(); bool further_blank_line = false; -#ifndef NEW_INSETS - if (IsDummy()) - lyxerr << "ERROR (LyXParagraph::TeXOnePar) is dummy." << endl; -#endif - - if (params.startOfAppendix()) { - os << "\\appendix\n"; - texrow.newline(); - } + LyXLayout style; + + // 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)) { + style = textclasslist.Style(bparams.textclass, layout); + + if (params().startOfAppendix()) { + os << "\\appendix\n"; + texrow.newline(); + } - if (!params.spacing().isDefault() - && (!previous() || !previous()->HasSameLayout(this))) { - os << params.spacing().writeEnvirBegin() << "\n"; - texrow.newline(); - } + if (!params().spacing().isDefault() + && (!previous() || !previous()->hasSameLayout(this))) { + os << params().spacing().writeEnvirBegin() << "\n"; + texrow.newline(); + } - if (tex_code_break_column && style.isCommand()){ - os << '\n'; - texrow.newline(); - } + if (tex_code_break_column && style.isCommand()){ + os << '\n'; + texrow.newline(); + } - if (params.pagebreakTop()) { - os << "\\newpage"; - further_blank_line = true; - } - if (params.spaceTop().kind() != VSpace::NONE) { - os << params.spaceTop().asLatexCommand(bparams); - further_blank_line = true; - } - - if (params.lineTop()) { - os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}' - << "\\vspace{-1\\parskip}"; - further_blank_line = true; - } + if (params().pagebreakTop()) { + os << "\\newpage"; + further_blank_line = true; + } + if (params().spaceTop().kind() != VSpace::NONE) { + os << params().spaceTop().asLatexCommand(bparams); + further_blank_line = true; + } - if (further_blank_line){ - os << '\n'; - texrow.newline(); + if (params().lineTop()) { + os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}' + << "\\vspace{-1\\parskip}"; + further_blank_line = true; + } + + if (further_blank_line){ + os << '\n'; + texrow.newline(); + } + } else { + style = textclasslist.Style(bparams.textclass, 0); } Language const * language = getParLanguage(bparams); Language const * doc_language = bparams.language; - Language const * previous_language = previous_ - ? previous_->getParLanguage(bparams) : doc_language; - if (language->babel() != doc_language->babel() && - language->babel() != previous_language->babel()) { - os << subst(lyxrc.language_command_begin, "$$lang", - language->babel()) - << endl; - texrow.newline(); + Language const * previous_language = previous() + ? previous()->getParLanguage(bparams) : doc_language; + + if (language->babel() != previous_language->babel() + // check if we already put language command in TeXEnvironment() + && !(style.isEnvironment() + && (!previous() || previous()->layout != layout || + previous()->params().depth() != params().depth()))) + { + if (!lyxrc.language_command_end.empty() && + previous_language->babel() != doc_language->babel()) + { + os << subst(lyxrc.language_command_end, "$$lang", + previous_language->babel()) + << endl; + texrow.newline(); + } + + if (lyxrc.language_command_end.empty() || + language->babel() != doc_language->babel()) + { + os << subst(lyxrc.language_command_begin, "$$lang", + language->babel()) + << endl; + texrow.newline(); + } } if (bparams.inputenc == "auto" && @@ -2314,7 +1313,7 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, << "}" << endl; texrow.newline(); } - + switch (style.latextype) { case LATEX_COMMAND: os << '\\' @@ -2323,7 +1322,7 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, break; case LATEX_ITEM_ENVIRONMENT: if (bibkey) { - bibkey->Latex(buf, os, false, false); + bibkey->latex(buf, os, false, false); } else os << "\\item "; break; @@ -2334,57 +1333,8 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, break; } - bool need_par = SimpleTeXOnePar(buf, bparams, os, texrow, moving_arg); + bool need_par = simpleTeXOnePar(buf, bparams, os, texrow, moving_arg); - LyXParagraph * par = next_; -#ifndef NEW_INSETS - // Spit out footnotes - if (lyxrc.rtl_support) { - if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE - && next_->footnoteflag != footnoteflag) { - LyXParagraph * p = 0; - bool is_rtl = (size() > 0) - ? GetFontSettings(bparams, - size()-1).isRightToLeft() - : language->RightToLeft(); - if ((p = NextAfterFootnote()) != 0 && - p->size() > 0 && - p->GetFontSettings(bparams, 0).isRightToLeft() != is_rtl) - is_rtl = getParLanguage(bparams)->RightToLeft(); - while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE - && par->footnoteflag != footnoteflag) { - par = par->TeXFootnote(buf, bparams, - os, texrow, foot, - foot_texrow, foot_count, - is_rtl); - par->SimpleTeXOnePar(buf, bparams, - os, texrow, moving_arg); - is_rtl = (par->size() > 0) - ? par->GetFontSettings(bparams, - par->size()-1).isRightToLeft() - : language->RightToLeft(); - if (par->next_ && - par->next_->footnoteflag != LyXParagraph::NO_FOOTNOTE && - (p = par->NextAfterFootnote()) != 0 && - p->size() > 0 && - p->GetFontSettings(bparams, 0).isRightToLeft() != is_rtl) - is_rtl = language->RightToLeft(); - par = par->next_; - } - } - } else { - while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE - && par->footnoteflag != footnoteflag) { - par = par->TeXFootnote(buf, bparams, - os, texrow, - foot, foot_texrow, foot_count, - false); - par->SimpleTeXOnePar(buf, bparams, os, texrow, moving_arg); - par = par->next_; - } - } -#endif - // Make sure that \\par is done with the font of the last // character if this has another size as the default. // This is necessary because LaTeX (and LyX on the screen) @@ -2394,13 +1344,12 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, // Is this really needed ? (Dekel) // We do not need to use to change the font for the last paragraph // or for a command. -#ifndef NEW_INSETS - LyXFont font = getFont(bparams, Last() - 1); -#else - LyXFont font = getFont(bparams, size() - 1); -#endif - bool is_command = textclasslist.Style(bparams.textclass, - GetLayout()).isCommand(); + LyXFont const font = + (size() == 0 + ? getLayoutFont(bparams) : getFont(bparams, size() - 1)); + + bool is_command = style.isCommand(); + if (style.resfont.size() != font.size() && next_ && !is_command) { if (!need_par) os << "{"; @@ -2410,141 +1359,136 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, } else if (is_command) os << "}"; - if (language->babel() != doc_language->babel() && - (!par -#ifndef NEW_INSETS - || (footnoteflag != NO_FOOTNOTE && par->footnoteflag != footnoteflag) -#endif - || par->getParLanguage(bparams)->babel() != language->babel())) { - os << endl - << subst(lyxrc.language_command_end, "$$lang", - doc_language->babel()); - } - switch (style.latextype) { case LATEX_ITEM_ENVIRONMENT: case LATEX_LIST_ENVIRONMENT: - if (par && (params.depth() < par->params.depth())) { - os << '\n'; - texrow.newline(); - } + if (next_ && (params().depth() < next_->params().depth())) { + os << '\n'; + texrow.newline(); + } break; case LATEX_ENVIRONMENT: // if its the last paragraph of the current environment // skip it otherwise fall through - if (par - && (par->layout != layout - || par->params.depth() != params.depth() -#ifndef NO_PEXTRA - || par->params.pextraType() != params.pextraType() -#endif - )) + if (next_ + && (next_->layout != layout + || next_->params().depth() != params().depth())) break; + // fall through possible default: // we don't need it for the last paragraph!!! - // or for tables in floats - // -- effectively creates a \par where there isn't one which - // breaks a \subfigure or \subtable. if (next_) { -// && footnoteflag == LyXParagraph::NO_FOOTNOTE) { os << '\n'; texrow.newline(); } } - further_blank_line = false; - if (params.lineBottom()) { -#ifndef NEW_INSETS - os << "\\lyxline{\\" << getFont(bparams, - Last() - 1).latexSize() << '}'; -#else - os << "\\lyxline{\\" << getFont(bparams, - size() - 1).latexSize() << '}'; -#endif - further_blank_line = true; - } + if ((in == 0) || !in->forceDefaultParagraphs(in)) { + further_blank_line = false; + if (params().lineBottom()) { + os << "\\lyxline{\\" << font.latexSize() << '}'; + further_blank_line = true; + } - if (params.spaceBottom().kind() != VSpace::NONE) { - os << params.spaceBottom().asLatexCommand(bparams); - further_blank_line = true; - } - - if (params.pagebreakBottom()) { - os << "\\newpage"; - further_blank_line = true; - } + if (params().spaceBottom().kind() != VSpace::NONE) { + os << params().spaceBottom().asLatexCommand(bparams); + further_blank_line = true; + } - if (further_blank_line){ - os << '\n'; - texrow.newline(); - } + if (params().pagebreakBottom()) { + os << "\\newpage"; + further_blank_line = true; + } - if (!params.spacing().isDefault() - && (!par || !par->HasSameLayout(this))) { - os << params.spacing().writeEnvirEnd() << "\n"; - texrow.newline(); + if (further_blank_line){ + os << '\n'; + texrow.newline(); + } + + if (!params().spacing().isDefault() + && (!next_ || !next_->hasSameLayout(this))) { + os << params().spacing().writeEnvirEnd() << "\n"; + texrow.newline(); + } } // we don't need it for the last paragraph!!! - if (next_ -#ifndef NEW_INSETS - && !(footnoteflag != LyXParagraph::NO_FOOTNOTE && par && - par->footnoteflag == LyXParagraph::NO_FOOTNOTE) -#endif - ) { + if (next_) { os << '\n'; texrow.newline(); + } else { + // Since \selectlanguage write the language to the aux file, + // we need to reset the language at the end of footnote or + // float. + + if (language->babel() != doc_language->babel()) { + if (lyxrc.language_command_end.empty()) + os << subst(lyxrc.language_command_begin, + "$$lang", + doc_language->babel()) + << endl; + else + os << subst(lyxrc.language_command_end, + "$$lang", + language->babel()) + << endl; + texrow.newline(); + } } - lyxerr[Debug::LATEX] << "TeXOnePar...done " << par << endl; - return par; + lyxerr[Debug::LATEX] << "TeXOnePar...done " << next_ << endl; + return next_; } // This one spits out the text of the paragraph -bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow, - bool moving_arg) +bool Paragraph::simpleTeXOnePar(Buffer const * buf, + BufferParams const & bparams, + ostream & os, TexRow & texrow, + bool moving_arg) { lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl; bool return_value = false; - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - GetLayout()); - LyXFont basefont, last_font; + LyXLayout style; + + // 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! + bool asdefault = + (inInset() && inInset()->forceDefaultParagraphs(inInset())); + + if (asdefault) { + style = textclasslist.Style(bparams.textclass, 0); + } else { + style = textclasslist.Style(bparams.textclass, layout); + } + + LyXFont basefont; // Maybe we have to create a optional argument. - size_type main_body; + pos_type main_body; if (style.labeltype != LABEL_MANUAL) main_body = 0; else - main_body = BeginningOfMainBody(); + main_body = beginningOfMainBody(); + + int column = 0; if (main_body > 0) { os << '['; - basefont = getFont(bparams, -2); // Get label font + ++column; + basefont = getLabelFont(bparams); } else { - basefont = getFont(bparams, -1); // Get layout font + basefont = getLayoutFont(bparams); } - int column = 0; - - if (main_body >= 0 - && !text.size() -#ifndef NEW_INSETS - && !IsDummy() -#endif - ) { + if (main_body >= 0 && !pimpl_->size()) { if (style.isCommand()) { os << '{'; ++column; - } else if (params.align() != LYX_ALIGN_LAYOUT) { - os << '{'; - ++column; - return_value = true; } } @@ -2557,20 +1501,16 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, texrow.start(this, 0); - for (size_type i = 0; i < size(); ++i) { + for (pos_type i = 0; i < size(); ++i) { ++column; // First char in paragraph or after label? - if (i == main_body -#ifndef NEW_INSETS - && !IsDummy() -#endif - ) { + if (i == main_body) { if (main_body > 0) { if (open_font) { column += running_font.latexWriteEndChanges(os, basefont, basefont); open_font = false; } - basefont = getFont(bparams, -1); // Now use the layout font + basefont = getLayoutFont(bparams); running_font = basefont; os << ']'; ++column; @@ -2578,80 +1518,66 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, if (style.isCommand()) { os << '{'; ++column; - } else if (params.align() != LYX_ALIGN_LAYOUT && next_) { - // We do not need \par here (Dekel) - // os << "{\\par"; - os << "{"; - ++column; - return_value = true; } - if (params.noindent()) { - os << "\\noindent "; - column += 10; - } - switch (params.align()) { - case LYX_ALIGN_NONE: - case LYX_ALIGN_BLOCK: - case LYX_ALIGN_LAYOUT: - case LYX_ALIGN_SPECIAL: - break; - case LYX_ALIGN_LEFT: - if (moving_arg) - os << "\\protect"; - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\raggedright "; - column+= 13; - } else { - os << "\\raggedleft "; - column+= 12; + if (!asdefault) { + if (params().noindent()) { + os << "\\noindent "; + column += 10; } - break; - case LYX_ALIGN_RIGHT: - if (moving_arg) - os << "\\protect"; - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\raggedleft "; - column+= 12; - } else { - os << "\\raggedright "; - column+= 13; + + switch (params().align()) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: + break; + case LYX_ALIGN_LEFT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\begin{flushleft}"; + column += 17; + } else { + os << "\\begin{flushright}"; + column += 18; + } + break; + case LYX_ALIGN_RIGHT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\begin{flushright}"; + column += 18; + } else { + os << "\\begin{flushleft}"; + column += 17; + } + break; + case LYX_ALIGN_CENTER: + os << "\\begin{center}"; + column += 14; + break; } - break; - case LYX_ALIGN_CENTER: - if (moving_arg) - os << "\\protect"; - os << "\\centering "; - column+= 11; - break; - } + } } - value_type c = GetChar(i); + value_type c = getChar(i); // Fully instantiated font LyXFont font = getFont(bparams, i); -#ifndef NEW_INSETS - LyXParagraph * p = 0; - if (i == 0 - && previous_ && - previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE && - (p = PreviousBeforeFootnote()) != 0) - last_font = p->getFont(bparams, p->size() - 1); - else -#endif - last_font = running_font; + + LyXFont const last_font = running_font; // Spaces at end of font change are simulated to be // outside font change, i.e. we write "\textXX{text} " // rather than "\textXX{text }". (Asger) - if (open_font && c == ' ' && i <= size() - 2 - && !getFont(bparams, i + 1).equalExceptLatex(running_font) - && !getFont(bparams, i + 1).equalExceptLatex(font)) { - font = getFont(bparams, i + 1); + if (open_font && c == ' ' && i <= size() - 2) { + LyXFont const next_font = getFont(bparams, i + 1); + if (next_font != running_font + && next_font != font) { + font = next_font; + } } + // We end font definition before blanks - if (!font.equalExceptLatex(running_font) && open_font) { + if (font != running_font && open_font) { column += running_font.latexWriteEndChanges(os, basefont, (i == main_body-1) ? basefont : font); @@ -2663,32 +1589,30 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, if (c == ' ') { // Do not print the separation of the optional argument if (i != main_body - 1) { - SimpleTeXBlanks(os, texrow, i, - column, font, style); + pimpl_->simpleTeXBlanks(os, texrow, i, + column, font, style); } } // Do we need to change font? - if (!font.equalExceptLatex(running_font) - && i != main_body-1) { + if (font != running_font && i != main_body - 1) { column += font.latexWriteStartChanges(os, basefont, last_font); running_font = font; open_font = true; } - if (c == LyXParagraph::META_NEWLINE) { + if (c == Paragraph::META_NEWLINE) { // newlines are handled differently here than // the default in SimpleTeXSpecialChars(). - if (!style.newline_allowed - || font.latex() == LyXFont::ON) { + if (!style.newline_allowed) { os << '\n'; } else { if (open_font) { column += running_font.latexWriteEndChanges(os, basefont, basefont); open_font = false; } - basefont = getFont(bparams, -1); + basefont = getLayoutFont(bparams); running_font = basefont; if (font.family() == LyXFont::TYPEWRITER_FAMILY) { @@ -2702,28 +1626,34 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, texrow.start(this, i + 1); column = 0; } else { - SimpleTeXSpecialChars(buf, bparams, - os, texrow, moving_arg, - font, running_font, basefont, - open_font, style, i, column, c); + pimpl_->simpleTeXSpecialChars(buf, bparams, + os, texrow, moving_arg, + font, running_font, + basefont, open_font, + style, i, column, c); } } // If we have an open font definition, we have to close it if (open_font) { - LyXParagraph * p = 0; - if (next_ -#ifndef NEW_INSETS - && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE - && (p = NextAfterFootnote()) != 0 +#ifdef FIXED_LANGUAGE_END_DETECTION + if (next_) { + running_font + .latexWriteEndChanges(os, basefont, + next_->getFont(bparams, + 0)); + } else { + running_font.latexWriteEndChanges(os, basefont, + basefont); + } #else - && (p = next_) +#ifdef WITH_WARNINGS +//#warning For now we ALWAYS have to close the foreign font settings if they are +//#warning there as we start another \selectlanguage with the next paragraph if +//#warning we are in need of this. This should be fixed sometime (Jug) +#endif + running_font.latexWriteEndChanges(os, basefont, basefont); #endif - ) - running_font.latexWriteEndChanges(os, basefont, - p->getFont(bparams, 0)); - else - running_font.latexWriteEndChanges(os, basefont, basefont); } // Needed if there is an optional argument but no contents. @@ -2732,19 +1662,51 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, return_value = false; } + if (!asdefault) { + switch (params().align()) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: + break; + case LYX_ALIGN_LEFT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\end{flushleft}"; + column+= 15; + } else { + os << "\\end{flushright}"; + column+= 16; + } + break; + case LYX_ALIGN_RIGHT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\end{flushright}"; + column+= 16; + } else { + os << "\\end{flushleft}"; + column+= 15; + } + break; + case LYX_ALIGN_CENTER: + os << "\\end{center}"; + column+= 12; + break; + } + } + lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl; return return_value; } -bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string) +bool Paragraph::sgmlConvertChar(char c, string & sgml_string) { bool retval = false; switch (c) { - case LyXParagraph::META_HFILL: + case Paragraph::META_HFILL: sgml_string.erase(); break; - case LyXParagraph::META_NEWLINE: + case Paragraph::META_NEWLINE: sgml_string = '\n'; break; case '&': @@ -2801,1300 +1763,425 @@ bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string) } -void LyXParagraph::SimpleTeXBlanks(ostream & os, TexRow & texrow, - LyXParagraph::size_type const i, - int & column, LyXFont const & font, - LyXLayout const & style) +Paragraph * Paragraph::TeXEnvironment(Buffer const * buf, + BufferParams const & bparams, + ostream & os, TexRow & texrow) { - if (column > tex_code_break_column - && i - && GetChar(i - 1) != ' ' - && (i < size() - 1) - // In LaTeX mode, we don't want to - // break lines since some commands - // do not like this - && ! (font.latex() == LyXFont::ON) - // same in FreeSpacing mode - && !style.free_spacing - // In typewriter mode, we want to avoid - // ! . ? : at the end of a line - && !(font.family() == LyXFont::TYPEWRITER_FAMILY - && (GetChar(i-1) == '.' - || GetChar(i-1) == '?' - || GetChar(i-1) == ':' - || GetChar(i-1) == '!'))) { - if (tex_code_break_column == 0) { - // in batchmode we need LaTeX to still - // see it as a space not as an extra '\n' - os << " %\n"; - } else { - os << '\n'; + lyxerr[Debug::LATEX] << "TeXEnvironment... " << this << endl; + + LyXLayout const & style = + textclasslist.Style(bparams.textclass, + layout); + + Language const * language = getParLanguage(bparams); + Language const * doc_language = bparams.language; + Language const * previous_language = previous_ + ? previous_->getParLanguage(bparams) : doc_language; + if (language->babel() != previous_language->babel()) { + + if (!lyxrc.language_command_end.empty() && + previous_language->babel() != doc_language->babel()) { + os << subst(lyxrc.language_command_end, "$$lang", + previous_language->babel()) + << endl; + texrow.newline(); } + + if (lyxrc.language_command_end.empty() || + language->babel() != doc_language->babel()) { + os << subst(lyxrc.language_command_begin, "$$lang", + language->babel()) + << endl; + texrow.newline(); + } + } + + if (style.isEnvironment()) { + if (style.latextype == LATEX_LIST_ENVIRONMENT) { + os << "\\begin{" << style.latexname() << "}{" + << params().labelWidthString() << "}\n"; + } else if (style.labeltype == LABEL_BIBLIO) { + // ale970405 + os << "\\begin{" << style.latexname() << "}{" + << bibitemWidest(buf) + << "}\n"; + } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) { + os << "\\begin{" << style.latexname() << '}' + << style.latexparam() << '\n'; + } else + os << "\\begin{" << style.latexname() << '}' + << style.latexparam() << '\n'; texrow.newline(); - texrow.start(this, i + 1); - column = 0; - } else if (font.latex() == LyXFont::OFF) { - if (style.free_spacing) { - os << '~'; - } else { - os << ' '; + } + Paragraph * par = this; + do { + par = par->TeXOnePar(buf, bparams, os, texrow, false); + + if (par && par->params().depth() > params().depth()) { + if (textclasslist.Style(bparams.textclass, + par->layout).isParagraph() + // Thinko! + // How to handle this? (Lgb) + //&& !suffixIs(os, "\n\n") + ) { + // There should be at least one '\n' already + // but we need there to be two for Standard + // paragraphs that are depth-increment'ed to be + // output correctly. However, tables can + // also be paragraphs so don't adjust them. + // ARRae + // Thinkee: + // Will it ever harm to have one '\n' too + // many? i.e. that we sometimes will have + // three in a row. (Lgb) + os << '\n'; + texrow.newline(); + } + par = par->pimpl_->TeXDeeper(buf, bparams, os, texrow); } + } while (par + && par->layout == layout + && par->params().depth() == params().depth()); + + if (style.isEnvironment()) { + os << "\\end{" << style.latexname() << "}\n"; + texrow.newline(); } + + lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl; + return par; // ale970302 } -void LyXParagraph::SimpleTeXSpecialChars(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow, - bool moving_arg, - LyXFont & font, - LyXFont & running_font, - LyXFont & basefont, - bool & open_font, - LyXLayout const & style, - LyXParagraph::size_type & i, - int & column, - LyXParagraph::value_type const c) +bool Paragraph::isHfill(pos_type pos) const { - // Two major modes: LaTeX or plain - // Handle here those cases common to both modes - // and then split to handle the two modes separately. - switch (c) { - case LyXParagraph::META_INSET: { - Inset * inset = GetInset(i); - if (inset) { - bool close = false; - int const len = os.tellp(); - //ostream::pos_type const len = os.tellp(); - if ((inset->LyxCode() == Inset::GRAPHICS_CODE - || inset->LyxCode() == Inset::MATH_CODE - || inset->LyxCode() == Inset::URL_CODE) - && running_font.isRightToLeft()) { - os << "\\L{"; - close = true; - } + return IsHfillChar(getChar(pos)); +} - int tmp = inset->Latex(buf, os, moving_arg, - style.free_spacing); - if (close) - os << "}"; +bool Paragraph::isInset(pos_type pos) const +{ + return IsInsetChar(getChar(pos)); +} - if (tmp) { - column = 0; - } else { - column += int(os.tellp()) - len; - } - for (; tmp--;) { - texrow.newline(); - } - } - } - break; - case LyXParagraph::META_NEWLINE: - if (open_font) { - column += running_font.latexWriteEndChanges(os, - basefont, - basefont); - open_font = false; - } - basefont = getFont(bparams, -1); - running_font = basefont; - break; +bool Paragraph::isNewline(pos_type pos) const +{ + return pos >= 0 && IsNewlineChar(getChar(pos)); +} - case LyXParagraph::META_HFILL: - os << "\\hfill{}"; - column += 7; - break; - default: - // And now for the special cases within each mode - // Are we in LaTeX mode? - if (font.latex() == LyXFont::ON) { - // at present we only have one option - // but I'll leave it as a switch statement - // so its simpler to extend. (ARRae) - switch (c) { - default: - // make sure that we will not print - // error generating chars to the tex - // file. This test would not be needed - // if it were done in the buffer - // itself. - if (c != '\0') { - os << c; - } - break; - } - } else { - // Plain mode (i.e. not LaTeX) - switch (c) { - case '\\': - os << "\\textbackslash{}"; - column += 15; - break; - - case '°': case '±': case '²': case '³': - case '×': case '÷': case '¹': case 'ª': - case 'º': case '¬': case 'µ': - if (bparams.inputenc == "latin1" || - (bparams.inputenc == "auto" && - font.language()->encoding()->LatexName() - == "latin1")) { - os << "\\ensuremath{" - << c - << '}'; - column += 13; - } else { - os << c; - } - break; - - case '|': case '<': case '>': - // In T1 encoding, these characters exist - if (lyxrc.fontenc == "T1") { - os << c; - //... but we should avoid ligatures - if ((c == '>' || c == '<') - && i <= size() - 2 - && GetChar(i + 1) == c) { - //os << "\\textcompwordmark{}"; - // Jean-Marc, have a look at - // this. I think this works - // equally well: - os << "\\,{}"; - // Lgb - column += 19; - } - break; - } - // Typewriter font also has them - if (font.family() == LyXFont::TYPEWRITER_FAMILY) { - os << c; - break; - } - // Otherwise, we use what LaTeX - // provides us. - switch (c) { - case '<': - os << "\\textless{}"; - column += 10; - break; - case '>': - os << "\\textgreater{}"; - column += 13; - break; - case '|': - os << "\\textbar{}"; - column += 9; - break; - } - break; - - case '-': // "--" in Typewriter mode -> "-{}-" - if (i <= size() - 2 - && GetChar(i + 1) == '-' - && font.family() == LyXFont::TYPEWRITER_FAMILY) { - os << "-{}"; - column += 2; - } else { - os << '-'; - } - break; +bool Paragraph::isSeparator(pos_type pos) const +{ + return IsSeparatorChar(getChar(pos)); +} - case '\"': - os << "\\char`\\\"{}"; - column += 9; - break; - case '£': - if (bparams.inputenc == "default") { - os << "\\pounds{}"; - column += 8; - } else { - os << c; - } - break; - - case '$': case '&': - case '%': case '#': case '{': - case '}': case '_': - os << '\\' << c; - column += 1; - break; - - case '~': - os << "\\textasciitilde{}"; - column += 16; - break; - - case '^': - os << "\\textasciicircum{}"; - column += 17; - break; - - case '*': case '[': case ']': - // avoid being mistaken for optional arguments - os << '{' << c << '}'; - column += 2; - break; - - case ' ': - // Blanks are printed before font switching. - // Sure? I am not! (try nice-latex) - // I am sure it's correct. LyX might be smarter - // in the future, but for now, nothing wrong is - // written. (Asger) - break; - - default: - /* idea for labels --- begin*/ - // Check for "LyX" - if (c == 'L' - && i <= size() - 3 - && font.family() != LyXFont::TYPEWRITER_FAMILY - && GetChar(i + 1) == 'y' - && GetChar(i + 2) == 'X') { - os << "\\LyX{}"; - i += 2; - column += 5; - } - // Check for "TeX" - else if (c == 'T' - && i <= size() - 3 - && font.family() != LyXFont::TYPEWRITER_FAMILY - && GetChar(i + 1) == 'e' - && GetChar(i + 2) == 'X') { - os << "\\TeX{}"; - i += 2; - column += 5; - } - // Check for "LaTeX2e" - else if (c == 'L' - && i <= size() - 7 - && font.family() != LyXFont::TYPEWRITER_FAMILY - && GetChar(i + 1) == 'a' - && GetChar(i + 2) == 'T' - && GetChar(i + 3) == 'e' - && GetChar(i + 4) == 'X' - && GetChar(i + 5) == '2' - && GetChar(i + 6) == 'e') { - os << "\\LaTeXe{}"; - i += 6; - column += 8; - } - // Check for "LaTeX" - else if (c == 'L' - && i <= size() - 5 - && font.family() != LyXFont::TYPEWRITER_FAMILY - && GetChar(i + 1) == 'a' - && GetChar(i + 2) == 'T' - && GetChar(i + 3) == 'e' - && GetChar(i + 4) == 'X') { - os << "\\LaTeX{}"; - i += 4; - column += 7; - /* idea for labels --- end*/ - } else if (c != '\0') { - os << c; - } - break; - } - } - } +bool Paragraph::isLineSeparator(pos_type pos) const +{ + return IsLineSeparatorChar(getChar(pos)); } -LyXParagraph * LyXParagraph::TeXDeeper(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow -#ifndef NEW_INSETS - ,ostream & foot, - TexRow & foot_texrow, - int & foot_count -#endif - ) +bool Paragraph::isKomma(pos_type pos) const { - lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl; - LyXParagraph * par = this; + return IsKommaChar(getChar(pos)); +} - while (par && - (par->params.depth() == params.depth()) -#ifndef NEW_INSETS - && (par->footnoteflag == footnoteflag) -#endif - ) { -#ifndef NEW_INSETS - if (par->IsDummy()) - lyxerr << "ERROR (LyXParagraph::TeXDeeper)" << endl; -#endif - if (textclasslist.Style(bparams.textclass, - par->layout).isEnvironment() -#ifndef NO_PEXTRA - || par->params.pextraType() != PEXTRA_NONE -#endif - ) { - par = par->TeXEnvironment(buf, bparams, - os, texrow -#ifndef NEW_INSETS - ,foot, foot_texrow, - foot_count -#endif - ); - } else { - par = par->TeXOnePar(buf, bparams, - os, texrow, false -#ifndef NEW_INSETS - , - foot, foot_texrow, - foot_count -#endif - ); - } - } - lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl; - return par; +/// Used by the spellchecker +bool Paragraph::isLetter(pos_type pos) const +{ + value_type const c = getChar(pos); + if (IsLetterChar(c)) + return true; + if (isInset(pos)) + return getInset(pos)->isLetter(); + // We want to pass the ' and escape chars to ispell + string const extra = lyxrc.isp_esc_chars + '\''; + return contains(extra, c); +} + + +bool Paragraph::isWord(pos_type pos ) const +{ + return IsWordChar(getChar(pos)) ; } -LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow -#ifndef NEW_INSETS - ,ostream & foot, - TexRow & foot_texrow, - int & foot_count -#endif - ) +Language const * +Paragraph::getParLanguage(BufferParams const & bparams) const { -#ifndef NO_PEXTRA - bool eindent_open = false; -#endif -#ifndef NEW_INSETS - bool foot_this_level = false; -#endif -#ifndef NO_PEXTRA - // flags when footnotetext should be appended to file. - static bool minipage_open = false; - static int minipage_open_depth = 0; - char par_sep = bparams.paragraph_separation; -#endif - - lyxerr[Debug::LATEX] << "TeXEnvironment... " << this << endl; -#ifndef NEW_INSETS - if (IsDummy()) - lyxerr << "ERROR (LyXParagraph::TeXEnvironment)" << endl; + if (size() > 0) { +#ifndef INHERIT_LANGUAGE + return getFirstFontSettings().language(); +#else + Language const * lang = getFirstFontSettings().language(); +#warning We should make this somewhat better, any ideas? (Jug) + if (lang == inherit_language || lang == ignore_language) + lang = bparams.language; + return lang; #endif + } else if (previous_) + return previous_->getParLanguage(bparams); + else + return bparams.language; +} - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - layout); -#ifndef NO_PEXTRA - if (params.pextraType() == PEXTRA_INDENT) { - if (!params.pextraWidth().empty()) { - os << "\\begin{LyXParagraphIndent}{" - << params.pextraWidth() << "}\n"; - } else { - //float ib = atof(pextra_widthp.c_str())/100; - // string can't handle floats at present (971109) - // so I'll do a conversion by hand knowing that - // the limits are 0.0 to 1.0. ARRae. - os << "\\begin{LyXParagraphIndent}{"; - switch (params.pextraWidthp().length()) { - case 3: - os << "1.00"; - break; - case 2: - os << "0." - << params.pextraWidthp(); - break; - case 1: - os << "0.0" - << params.pextraWidthp(); - } - os << "\\columnwidth}\n"; - } - texrow.newline(); - eindent_open = true; - } - if ((params.pextraType() == PEXTRA_MINIPAGE) && !minipage_open) { - if (params.pextraHfill() && previous() && - (previous()->params.pextraType() == PEXTRA_MINIPAGE)) { - os << "\\hfill{}\n"; - texrow.newline(); - } - if (par_sep == BufferParams::PARSEP_INDENT) { - os << "{\\setlength\\parindent{0pt}\n"; - texrow.newline(); - } - os << "\\begin{minipage}"; - switch (params.pextraAlignment()) { - case MINIPAGE_ALIGN_TOP: - os << "[t]"; - break; - case MINIPAGE_ALIGN_MIDDLE: - os << "[m]"; - break; - case MINIPAGE_ALIGN_BOTTOM: - os << "[b]"; - break; - } - if (!params.pextraWidth().empty()) { - os << '{' << params.pextraWidth() << "}\n"; - } else { - //float ib = atof(par->pextra_width.c_str())/100; - // string can't handle floats at present - // so I'll do a conversion by hand knowing that - // the limits are 0.0 to 1.0. ARRae. - os << '{'; - switch (params.pextraWidthp().length()) { - case 3: - os << "1.00"; - break; - case 2: - os << "0." - << params.pextraWidthp(); - break; - case 1: - os << "0.0" - << params.pextraWidthp(); - } - os << "\\columnwidth}\n"; - } - texrow.newline(); - if (par_sep == BufferParams::PARSEP_INDENT) { - os << "\\setlength\\parindent{\\LyXMinipageIndent}\n"; - texrow.newline(); - } - minipage_open = true; - minipage_open_depth = params.depth(); - } -#endif -#ifdef WITH_WARNINGS -#warning Define FANCY_FOOTNOTE_CODE to re-enable Allan footnote code - //I disabled it because it breaks when lists span on several - //pages (JMarc) -#endif - if (style.isEnvironment()){ - if (style.latextype == LATEX_LIST_ENVIRONMENT) { -#ifdef FANCY_FOOTNOTE_CODE - if (foot_count < 0) { - // flag that footnote[mark][text] should be - // used for any footnotes from now on - foot_count = 0; - foot_this_level = true; - } -#endif - os << "\\begin{" << style.latexname() << "}{" - << params.labelWidthString() << "}\n"; - } else if (style.labeltype == LABEL_BIBLIO) { - // ale970405 - os << "\\begin{" << style.latexname() << "}{" - << bibitemWidest(buf) - << "}\n"; - } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) { -#ifdef FANCY_FOOTNOTE_CODE - if (foot_count < 0) { - // flag that footnote[mark][text] should be - // used for any footnotes from now on - foot_count = 0; - foot_this_level = true; - } -#endif - os << "\\begin{" << style.latexname() << '}' - << style.latexparam() << '\n'; - } else - os << "\\begin{" << style.latexname() << '}' - << style.latexparam() << '\n'; - texrow.newline(); - } - LyXParagraph * par = this; - do { - par = par->TeXOnePar(buf, bparams, - os, texrow, false -#ifndef NEW_INSETS - , - foot, foot_texrow, foot_count -#endif - ); -#ifndef NO_PEXTRA - if (minipage_open && par && !style.isEnvironment() && - (par->params.pextraType() == PEXTRA_MINIPAGE) && - par->params.pextraStartMinipage()) { - os << "\\end{minipage}\n"; - texrow.newline(); - if (par_sep == BufferParams::PARSEP_INDENT) { - os << "}\n"; - texrow.newline(); - } - minipage_open = false; - } -#endif - if (par && par->params.depth() > params.depth()) { - if (textclasslist.Style(bparams.textclass, - par->layout).isParagraph() - // Thinko! - // How to handle this? (Lgb) - //&& !suffixIs(os, "\n\n") - ) { - // There should be at least one '\n' already - // but we need there to be two for Standard - // paragraphs that are depth-increment'ed to be - // output correctly. However, tables can - // also be paragraphs so don't adjust them. - // ARRae - // Thinkee: - // Will it ever harm to have one '\n' too - // many? i.e. that we sometimes will have - // three in a row. (Lgb) - os << '\n'; - texrow.newline(); - } - par = par->TeXDeeper(buf, bparams, os, texrow -#ifndef NEW_INSETS - ,foot, foot_texrow, foot_count -#endif - ); - } -#ifndef NO_PEXTRA - if (par && par->layout == layout && par->params.depth() == params.depth() && - (par->params.pextraType() == PEXTRA_MINIPAGE) && !minipage_open) { - if (par->params.pextraHfill() && par->previous() && - (par->previous()->params.pextraType() == PEXTRA_MINIPAGE)){ - os << "\\hfill{}\n"; - texrow.newline(); - } - if (par_sep == BufferParams::PARSEP_INDENT) { - os << "{\\setlength\\parindent{0pt}\n"; - texrow.newline(); - } - os << "\\begin{minipage}"; - switch (par->params.pextraAlignment()) { - case MINIPAGE_ALIGN_TOP: - os << "[t]"; - break; - case MINIPAGE_ALIGN_MIDDLE: - os << "[m]"; - break; - case MINIPAGE_ALIGN_BOTTOM: - os << "[b]"; - break; - } - if (!par->params.pextraWidth().empty()) { - os << '{' << par->params.pextraWidth() << "}\n"; - } else { - //float ib = atof(par->pextra_widthp.c_str())/100; - // string can't handle floats at present - // so I'll do a conversion by hand knowing that - // the limits are 0.0 to 1.0. ARRae. - os << '{'; - switch (par->params.pextraWidthp().length()) { - case 3: - os << "1.00"; - break; - case 2: - os << "0." << par->params.pextraWidthp(); - break; - case 1: - os << "0.0" << par->params.pextraWidthp(); - } - os << "\\columnwidth}\n"; - } - texrow.newline(); - if (par_sep == BufferParams::PARSEP_INDENT) { - os << "\\setlength\\parindent{\\LyXMinipageIndent}\n"; - texrow.newline(); - } - minipage_open = true; - minipage_open_depth = par->params.depth(); - } -#endif - } while (par - && par->layout == layout - && par->params.depth() == params.depth() -#ifndef NO_PEXTRA - && par->params.pextraType() == params.pextraType() -#endif -#ifndef NEW_INSETS - && par->footnoteflag == footnoteflag -#endif - ); - - if (style.isEnvironment()) { - os << "\\end{" << style.latexname() << '}'; -#ifndef NEW_INSETS - // maybe this should go after the minipage closes? - if (foot_this_level) { - if (foot_count >= 1) { - if (foot_count > 1) { - os << "\\addtocounter{footnote}{-" - << foot_count - 1 - << '}'; - } - os << foot; - texrow += foot_texrow; - foot.clear(); - foot_texrow.reset(); - foot_count = 0; - } +bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const +{ + return lyxrc.rtl_support + && getParLanguage(bparams)->RightToLeft(); +} + + +void Paragraph::changeLanguage(BufferParams const & bparams, + Language const * from, Language const * to) +{ + for (pos_type i = 0; i < size(); ++i) { + LyXFont font = getFontSettings(bparams, i); + if (font.language() == from) { + font.setLanguage(to); + setFont(i, font); } -#endif - } -#ifndef NO_PEXTRA - if (minipage_open && (minipage_open_depth == params.depth()) && - (!par || par->params.pextraStartMinipage() || - par->params.pextraType() != PEXTRA_MINIPAGE)) { - os << "\\end{minipage}\n"; - texrow.newline(); - if (par_sep == BufferParams::PARSEP_INDENT) { - os << "}\n"; - texrow.newline(); - } - if (par && par->params.pextraType() != PEXTRA_MINIPAGE) { - os << "\\medskip\n\n"; - texrow.newline(); - texrow.newline(); - } - minipage_open = false; - } - if (eindent_open) { - os << "\\end{LyXParagraphIndent}\n"; - texrow.newline(); - } - if (!(par && (par->params.pextraType() == PEXTRA_MINIPAGE) - && par->params.pextraHfill())) { - os << '\n'; - texrow.newline(); } -#endif - lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl; - return par; // ale970302 } -#ifndef NEW_INSETS -LyXParagraph * LyXParagraph::TeXFootnote(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow, - ostream & foot, TexRow & foot_texrow, - int & foot_count, - bool parent_is_rtl) +bool Paragraph::isMultiLingual(BufferParams const & bparams) { - lyxerr[Debug::LATEX] << "TeXFootnote... " << this << endl; - if (footnoteflag == LyXParagraph::NO_FOOTNOTE) - lyxerr << "ERROR (LyXParagraph::TeXFootnote): " - "No footnote!" << endl; - - LyXParagraph * par = this; - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - previous_->GetLayout()); - - if (style.needprotect && footnotekind != LyXParagraph::FOOTNOTE){ - lyxerr << "ERROR (LyXParagraph::TeXFootnote): " - "Float other than footnote in command" - " with moving argument is illegal" << endl; - } + Language const * doc_language = bparams.language; + for (Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); + cit != pimpl_->fontlist.end(); ++cit) + if (cit->font().language() != ignore_language && + cit->font().language() != latex_language && +#ifdef INHERIT_LANGUAGE + cit->font().language() != inherit_language && +#endif + cit->font().language() != doc_language) + return true; + return false; +} - if (footnotekind != LyXParagraph::FOOTNOTE - && footnotekind != LyXParagraph::MARGIN - && os.tellp() - // Thinko - // How to solve this? - //&& !suffixIs(file, '\n') - ) { - // we need to ensure that real floats like tables and figures - // have their \begin{} on a new line otherwise we can get - // incorrect results when using the endfloat.sty package - // especially if two floats follow one another. ARRae 981022 - // NOTE: if the file is length 0 it must have just been - // written out so we assume it ended with a '\n' - // Thinkee: - // As far as I can see there is never any harm in writing - // a '\n' too much. Please tell me if I am wrong. (Lgb) - os << '\n'; - texrow.newline(); - } - bool moving_arg = false; - bool need_closing = false; - bool is_rtl = isRightToLeftPar(bparams); +// Convert the paragraph to a string. +// Used for building the table of contents +string const Paragraph::asString(Buffer const * buffer, bool label) +{ + BufferParams const & bparams = buffer->params; + string s; + if (label && !params().labelString().empty()) + s += params().labelString() + ' '; + string::size_type const len = s.size(); - if (is_rtl != parent_is_rtl) { - if (is_rtl) - os << "\\R{"; - else - os << "\\L{"; - need_closing = true; - } - - bool footer_in_body = true; - switch (footnotekind) { - case LyXParagraph::FOOTNOTE: - if (style.intitle) { - os << "\\thanks{\n"; - footer_in_body = false; - moving_arg = true; - } else { - if (foot_count == -1) { - // we're at depth 0 so we can use: - os << "\\footnote{%\n"; - footer_in_body = false; - } else { - os << "\\footnotemark{}%\n"; - if (foot_count) { - // we only need this when there are - // multiple footnotes - os << "\\stepcounter{footnote}"; - } - os << "\\footnotetext{%\n"; - foot_texrow.start(this, 0); - foot_texrow.newline(); - ++foot_count; - } - } - break; - case LyXParagraph::MARGIN: - os << "\\marginpar{\n"; - break; - case LyXParagraph::FIG: - if (params.pextraType() == PEXTRA_FLOATFLT - && (!params.pextraWidth().empty() - || !params.pextraWidthp().empty())) { - if (!params.pextraWidth().empty()) - os << "\\begin{floatingfigure}{" - << params.pextraWidth() << "}\n"; - else - os << "\\begin{floatingfigure}{" - << lyx::atoi(params.pextraWidthp()) / 100.0 - << "\\textwidth}\n"; - } else { - os << "\\begin{figure}"; - if (!bparams.float_placement.empty()) { - os << '[' << bparams.float_placement << "]\n"; - } else { - os << '\n'; - } - } - break; - case LyXParagraph::TAB: - os << "\\begin{table}"; - if (!bparams.float_placement.empty()) { - os << '[' << bparams.float_placement << "]\n"; - } else { - os << '\n'; - } - break; - case LyXParagraph::WIDE_FIG: - os << "\\begin{figure*}"; - if (!bparams.float_placement.empty()) { - os << '[' << bparams.float_placement << "]\n"; - } else { - os << '\n'; - } - break; - case LyXParagraph::WIDE_TAB: - os << "\\begin{table*}"; - if (!bparams.float_placement.empty()) { - os << '[' << bparams.float_placement << "]\n"; - } else { - os << '\n'; + for (pos_type i = 0; i < size(); ++i) { + value_type c = getChar(i); + if (IsPrintable(c)) + s += c; + else if (c == META_INSET && + getInset(i)->lyxCode() == Inset::MATH_CODE) { + ostringstream ost; + getInset(i)->ascii(buffer, ost); + s += subst(ost.str().c_str(),'\n',' '); } - break; - case LyXParagraph::ALGORITHM: - os << "\\begin{algorithm}\n"; - break; } - texrow.newline(); - - if (footnotekind != LyXParagraph::FOOTNOTE - || !footer_in_body) { - // Process text for all floats except footnotes in body - do { - LyXLayout const & style = - textclasslist - .Style(bparams.textclass, par->layout); - if (par->IsDummy()) - lyxerr << "ERROR (LyXParagraph::TeXFootnote)" - << endl; - if (style.isEnvironment() - || par->params.pextraType() == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */ - // Allows the use of minipages within float - // environments. Shouldn't be circular because - // we don't support footnotes inside - // floats (yet). ARRae - par = par->TeXEnvironment(buf, bparams, os, - texrow, - foot, foot_texrow, - foot_count); - } else { - par = par->TeXOnePar(buf, bparams, - os, texrow, moving_arg, - foot, foot_texrow, - foot_count); - } - - if (par && !par->IsDummy() && par->params.depth() > params.depth()) { - par = par->TeXDeeper(buf, bparams, os, texrow, - foot, foot_texrow, - foot_count); - } - } while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE); - } else { - // process footnotes > depth 0 or in environments separately - // NOTE: Currently don't support footnotes within footnotes - // even though that is possible using the \footnotemark - std::ostringstream dummy; - TexRow dummy_texrow; - int dummy_count = 0; - do { - LyXLayout const & style = - textclasslist - .Style(bparams.textclass, par->layout); - if (par->IsDummy()) - lyxerr << "ERROR (LyXParagraph::TeXFootnote)" - << endl; - if (style.isEnvironment() - || par->params.pextraType() == PEXTRA_MINIPAGE) { /* && !minipage_open ?? */ - // Allows the use of minipages within float - // environments. Shouldn't be circular because - // we don't support footnotes inside - // floats (yet). ARRae - par = par->TeXEnvironment(buf, bparams, - foot, foot_texrow, - dummy, dummy_texrow, - dummy_count); - } else { - par = par->TeXOnePar(buf, bparams, - foot, foot_texrow, - moving_arg, - dummy, dummy_texrow, - dummy_count); - } - if (par && !par->IsDummy() && par->params.depth() > params.depth()) { - par = par->TeXDeeper(buf, bparams, - foot, foot_texrow, - dummy, dummy_texrow, - dummy_count); - } - } while (par - && par->footnoteflag != LyXParagraph::NO_FOOTNOTE); - if (dummy_count) { - lyxerr << "ERROR (LyXParagraph::TeXFootnote): " - "Footnote in a Footnote -- not supported" - << endl; - } - } + if (isRightToLeftPar(bparams)) + reverse(s.begin() + len,s.end()); - switch (footnotekind) { - case LyXParagraph::FOOTNOTE: - if (footer_in_body) { - // This helps tell which of the multiple - // footnotetexts an error was in. - foot << "}%\n"; - foot_texrow.newline(); - } else { - os << '}'; - } - break; - case LyXParagraph::MARGIN: - os << '}'; - break; - case LyXParagraph::FIG: - if (params.pextraType() == PEXTRA_FLOATFLT - && (!params.pextraWidth().empty() - || !params.pextraWidthp().empty())) - os << "\\end{floatingfigure}"; - else - os << "\\end{figure}"; - break; - case LyXParagraph::TAB: - os << "\\end{table}"; - break; - case LyXParagraph::WIDE_FIG: - os << "\\end{figure*}"; - break; - case LyXParagraph::WIDE_TAB: - os << "\\end{table*}"; - break; - case LyXParagraph::ALGORITHM: - os << "\\end{algorithm}"; - break; - } + return s; +} - if (need_closing) - os << "}"; - if (footnotekind != LyXParagraph::FOOTNOTE - && footnotekind != LyXParagraph::MARGIN) { - // we need to ensure that real floats like tables and figures - // have their \end{} on a line of their own otherwise we can - // get incorrect results when using the endfloat.sty package. - os << "\n"; - texrow.newline(); +string const Paragraph::asString(Buffer const * buffer, + pos_type beg, pos_type end, bool label) +{ + ostringstream ost; + + if (beg == 0 && label && !params().labelString().empty()) + ost << params().labelString() << ' '; + + for (pos_type i = beg; i < end; ++i) { + value_type const c = getUChar(buffer->params, i); + if (IsPrintable(c)) + ost << c; + else if (c == META_NEWLINE) + ost << '\n'; + else if (c == META_HFILL) + ost << '\t'; + else if (c == META_INSET) { + getInset(i)->ascii(buffer, ost); + } } - lyxerr[Debug::LATEX] << "TeXFootnote...done " << par->next_ << endl; - return par; + return ost.str().c_str(); } -bool LyXParagraph::IsDummy() const +void Paragraph::setInsetOwner(Inset * i) { - return (footnoteflag == LyXParagraph::NO_FOOTNOTE && previous_ - && previous_->footnoteflag != LyXParagraph::NO_FOOTNOTE); + pimpl_->inset_owner = i; + for (InsetList::const_iterator cit = insetlist.begin(); + cit != insetlist.end(); ++cit) { + if (cit->inset) + cit->inset->setOwner(i); + } } -#endif -#ifndef NO_PEXTRA -void LyXParagraph::SetPExtraType(BufferParams const & bparams, - int type, string const & width, - string const & widthp) + +void Paragraph::deleteInsetsLyXText(BufferView * bv) { - params.pextraType(type); - params.pextraWidth(width); - params.pextraWidthp(widthp); - - if (textclasslist.Style(bparams.textclass, - layout).isEnvironment()) { - LyXParagraph * par = this; - LyXParagraph * ppar = par; - - while (par && (par->layout == layout) - && (par->params.depth() == params.depth())) { - ppar = par; - par = par->previous(); -#ifndef NEW_INSETS - if (par) - par = par->FirstPhysicalPar(); -#endif - while (par && par->params.depth() > params.depth()) { - par = par->previous(); -#ifndef NEW_INSETS - if (par) - par = par->FirstPhysicalPar(); -#endif + // then the insets + for (InsetList::const_iterator cit = insetlist.begin(); + cit != insetlist.end(); ++cit) { + if (cit->inset) { + if (cit->inset->isTextInset()) { + static_cast + (cit->inset)->deleteLyXText(bv, true); } } - par = ppar; - while (par && (par->layout == layout) - && (par->params.depth() == params.depth())) { - par->params.pextraType(type); - par->params.pextraWidth(width); - par->params.pextraWidthp(widthp); -#ifndef NEW_INSETS - par = par->NextAfterFootnote(); -#else - par = par->next(); -#endif - if (par && (par->params.depth() > params.depth())) - par->SetPExtraType(bparams, - type, width, widthp); -#ifndef NEW_INSETS - while (par && ((par->params.depth() > params.depth()) || par->IsDummy())) - par = par->NextAfterFootnote(); -#else - while (par && par->params.depth() > params.depth()) - par = par->next(); -#endif - } } } -void LyXParagraph::UnsetPExtraType(BufferParams const & bparams) +void Paragraph::resizeInsetsLyXText(BufferView * bv) { - if (params.pextraType() == PEXTRA_NONE) - return; - - params.pextraType(PEXTRA_NONE); - params.pextraWidth(string()); - params.pextraWidthp(string()); - - if (textclasslist.Style(bparams.textclass, - layout).isEnvironment()) { - LyXParagraph * par = this; - LyXParagraph * ppar = par; - - while (par && (par->layout == layout) - && (par->params.depth() == params.depth())) { - ppar = par; - par = par->previous(); -#ifndef NEW_INSETS - if (par) - par = par->FirstPhysicalPar(); -#endif - while (par && par->params.depth() > params.depth()) { - par = par->previous(); -#ifndef NEW_INSETS - if (par) - par = par->FirstPhysicalPar(); -#endif + // then the insets + for (InsetList::const_iterator cit = insetlist.begin(); + cit != insetlist.end(); ++cit) + { + if (cit->inset) { + if (cit->inset->isTextInset()) { + static_cast + (cit->inset)->resizeLyXText(bv, true); } } - par = ppar; - while (par && (par->layout == layout) - && (par->params.depth() == params.depth())) { - par->params.pextraType(PEXTRA_NONE); - par->params.pextraWidth(string()); - par->params.pextraWidthp(string()); -#ifndef NEW_INSETS - par = par->NextAfterFootnote(); -#else - par = par->next(); -#endif - if (par && (par->params.depth() > params.depth())) - par->UnsetPExtraType(bparams); -#ifndef NEW_INSETS - while (par && ((par->params.depth() > params.depth()) || par->IsDummy())) - par = par->NextAfterFootnote(); -#else - while (par && par->params.depth() > params.depth()) - par = par->next(); -#endif - } } } -#endif -bool LyXParagraph::IsHfill(size_type pos) const +void Paragraph::setContentsFromPar(Paragraph * par) { - return IsHfillChar(GetChar(pos)); + pimpl_->setContentsFromPar(par); } -bool LyXParagraph::IsInset(size_type pos) const +lyx::pos_type Paragraph::size() const { - return IsInsetChar(GetChar(pos)); + return pimpl_->size(); } -#ifndef NEW_INSETS -bool LyXParagraph::IsFloat(size_type pos) const +Paragraph::value_type Paragraph::getChar(pos_type pos) const { - return IsFloatChar(GetChar(pos)); + return pimpl_->getChar(pos); } -#endif -bool LyXParagraph::IsNewline(size_type pos) const +int Paragraph::id() const { - return pos >= 0 && IsNewlineChar(GetChar(pos)); + return pimpl_->id_; } -bool LyXParagraph::IsSeparator(size_type pos) const +void Paragraph::id(int id_arg) { - return IsSeparatorChar(GetChar(pos)); + pimpl_->id_ = id_arg; } -bool LyXParagraph::IsLineSeparator(size_type pos) const +layout_type Paragraph::getLayout() const { - return IsLineSeparatorChar(GetChar(pos)); + return layout; } -bool LyXParagraph::IsKomma(size_type pos) const +bool Paragraph::isFirstInSequence() const { - return IsKommaChar(GetChar(pos)); + Paragraph const * dhook = depthHook(getDepth()); + return (dhook == this + || dhook->getLayout() != getLayout() + || dhook->getDepth() != getDepth()); } -/// Used by the spellchecker -bool LyXParagraph::IsLetter(LyXParagraph::size_type pos) const -{ - value_type const c = GetChar(pos); - if (IsLetterChar(c)) - return true; - // '\0' is not a letter, allthough every string contains "" (below) - if (c == '\0') - return false; - // We want to pass the ' and escape chars to ispell - string const extra = lyxrc.isp_esc_chars + '\''; - char ch[2] = { c, 0 }; - return contains(extra, ch); -} - - -bool LyXParagraph::IsWord(size_type pos ) const +Inset * Paragraph::inInset() const { - return IsWordChar(GetChar(pos)) ; + return pimpl_->inset_owner; } -Language const * -LyXParagraph::getParLanguage(BufferParams const & bparams) const +void Paragraph::clearContents() { -#ifndef NEW_INSETS - if (IsDummy()) - return FirstPhysicalPar()->getParLanguage(bparams); - else -#endif - if (size() > 0) - return GetFirstFontSettings().language(); - else if (previous_) - return previous_->getParLanguage(bparams); - else - return bparams.language; + pimpl_->clear(); } -bool LyXParagraph::isRightToLeftPar(BufferParams const & bparams) const +void Paragraph::setCounter(int i, int v) { - return lyxrc.rtl_support - && getParLanguage(bparams)->RightToLeft(); + pimpl_->counter_[i] = v; } -void LyXParagraph::ChangeLanguage(BufferParams const & bparams, - Language const * from, Language const * to) +int Paragraph::getCounter(int i) const { - for (size_type i = 0; i < size(); ++i) { - LyXFont font = GetFontSettings(bparams, i); - if (font.language() == from) { - font.setLanguage(to); - SetFont(i, font); - } - } + return pimpl_->counter_[i]; } -bool LyXParagraph::isMultiLingual(BufferParams const & bparams) +void Paragraph::incCounter(int i) { - Language const * doc_language = bparams.language; - for (FontList::const_iterator cit = fontlist.begin(); - cit != fontlist.end(); ++cit) - if ((*cit).font().language() != doc_language) - return true; - return false; + pimpl_->counter_[i]++; } -// Convert the paragraph to a string. -// Used for building the table of contents -string const LyXParagraph::String(Buffer const * buffer, bool label) +void Paragraph::setChar(pos_type pos, value_type c) { - BufferParams const & bparams = buffer->params; - string s; -#ifndef NEW_INSETS - if (label && !IsDummy() && !params.labelString().empty()) -#else - if (label && !params.labelString().empty()) -#endif - s += params.labelString() + ' '; - string::size_type const len = s.size(); - - for (LyXParagraph::size_type i = 0; i < size(); ++i) { - value_type c = GetChar(i); - if (IsPrintable(c)) - s += c; - else if (c == META_INSET && - GetInset(i)->LyxCode() == Inset::MATH_CODE) { - std::ostringstream ost; - GetInset(i)->Ascii(buffer, ost); - s += subst(ost.str().c_str(),'\n',' '); - } - } - -#ifndef NEW_INSETS - if (next_ && next_->footnoteflag != LyXParagraph::NO_FOOTNOTE - && footnoteflag == LyXParagraph::NO_FOOTNOTE) - s += NextAfterFootnote()->String(buffer, false); - - if (!IsDummy()) { -#endif - if (isRightToLeftPar(bparams)) - reverse(s.begin() + len,s.end()); -#ifndef NEW_INSETS - } -#endif - return s; + pimpl_->setChar(pos, c); } -string const LyXParagraph::String(Buffer const * buffer, - LyXParagraph::size_type beg, - LyXParagraph::size_type end) -{ - string s; +Paragraph::inset_iterator::inset_iterator(Paragraph::InsetList::iterator const & iter) + : it(iter) +{} -#ifndef NEW_INSETS - if (beg == 0 && !IsDummy() && !params.labelString().empty()) -#else - if (beg == 0 && !params.labelString().empty()) -#endif - s += params.labelString() + ' '; - for (LyXParagraph::size_type i = beg; i < end; ++i) { - value_type c = GetUChar(buffer->params, i); - if (IsPrintable(c)) - s += c; - else if (c == META_INSET) { - std::ostringstream ost; - GetInset(i)->Ascii(buffer, ost); - s += ost.str().c_str(); - } - } - - return s; +Paragraph::inset_iterator Paragraph::inset_iterator_begin() +{ + return inset_iterator(insetlist.begin()); } -void LyXParagraph::SetInsetOwner(Inset * i) +Paragraph::inset_iterator Paragraph::inset_iterator_end() { - inset_owner = i; - for (InsetList::const_iterator cit = insetlist.begin(); - cit != insetlist.end(); ++cit) { - if ((*cit).inset) - (*cit).inset->setOwner(i); - } + return inset_iterator(insetlist.end()); } -void LyXParagraph::deleteInsetsLyXText(BufferView * bv) +ParagraphParameters & Paragraph::params() { - // then the insets - for (InsetList::const_iterator cit = insetlist.begin(); - cit != insetlist.end(); ++cit) { - if ((*cit).inset) { - if ((*cit).inset->IsTextInset()) { - static_cast - ((*cit).inset)->deleteLyXText(bv); - } - } - } + return pimpl_->params; } -void LyXParagraph::resizeInsetsLyXText(BufferView * bv) +ParagraphParameters const & Paragraph::params() const { - // then the insets - for (InsetList::const_iterator cit = insetlist.begin(); - cit != insetlist.end(); ++cit) { - if ((*cit).inset) { - if ((*cit).inset->IsTextInset()) { - static_cast - ((*cit).inset)->resizeLyXText(bv); - } - } - } + return pimpl_->params; } -void LyXParagraph::fitToSize() +Paragraph * Paragraph::getParFromID(int id) const { - TextContainer tmp(text.begin(), text.end()); - text.swap(tmp); + return pimpl_->getParFromID(id); } -void LyXParagraph::setContentsFromPar(LyXParagraph * par) +bool Paragraph::isFreeSpacing() const { - text = par->text; + // for now we just need this, later should we need this in some + // other way we can always add a function to Inset::() too. + if (pimpl_->inset_owner && pimpl_->inset_owner->owner()) + return (pimpl_->inset_owner->owner()->lyxCode() == Inset::ERT_CODE); + return false; }