X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fparagraph.C;h=a17825476c65a166f6a23ddba048acc2e5826316;hb=bf6b9d1e189a13789308944d4d60f3ec994627b4;hp=449acc3adc6d2d8ea73bd9ba5d1140bb08ba365d;hpb=946895278050e4a464c9591e99232a72f5f4dec9;p=lyx.git diff --git a/src/paragraph.C b/src/paragraph.C index 449acc3adc..a17825476c 100644 --- a/src/paragraph.C +++ b/src/paragraph.C @@ -23,6 +23,7 @@ #include "lyxrc.h" #include "layout.h" #include "tex-strings.h" +#include "buffer.h" #include "bufferparams.h" #include "support/FileInfo.h" #include "support/LAssert.h" @@ -36,6 +37,7 @@ #include "texrow.h" #include "support/lyxmanip.h" #include "BufferView.h" +#include "encoding.h" using std::ostream; using std::endl; @@ -48,8 +50,8 @@ using std::reverse; 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 // parameters? (JMarc) -extern BufferView * current_view; -extern string bibitemWidest(Painter &); + +extern string bibitemWidest(Buffer const *); // this is a minibuffer static char minibuffer_char; @@ -57,6 +59,8 @@ static LyXFont minibuffer_font; static Inset * minibuffer_inset; +extern BufferView * current_view; + // Initialization of the counter for the paragraph id's, // declared in lyxparagraph.h unsigned int LyXParagraph::paragraph_id = 0; @@ -65,7 +69,6 @@ unsigned int LyXParagraph::paragraph_id = 0; LyXParagraph::LyXParagraph() { text.reserve(500); // is this number too big? - for (int i = 0; i < 10; ++i) setCounter(i , 0); appendix = false; enumdepth = 0; @@ -78,11 +81,6 @@ LyXParagraph::LyXParagraph() #endif align = LYX_ALIGN_BLOCK; -#ifndef NEW_TABULAR - /* table stuff -- begin*/ - table = 0; - /* table stuff -- end*/ -#endif inset_owner = 0; id_ = paragraph_id++; bibkey = 0; // ale970302 @@ -94,8 +92,8 @@ LyXParagraph::LyXParagraph() LyXParagraph::LyXParagraph(LyXParagraph * par) { text.reserve(500); - par->text.resize(par->text.size()); - + par->fitToSize(); + for (int i = 0; i < 10; ++i) setCounter(i, 0); appendix = false; enumdepth = 0; @@ -110,11 +108,6 @@ LyXParagraph::LyXParagraph(LyXParagraph * par) #ifndef NEW_INSETS footnoteflag = LyXParagraph::NO_FOOTNOTE; footnotekind = LyXParagraph::FOOTNOTE; -#endif -#ifndef NEW_TABULAR - /* table stuff -- begin*/ - table = 0; - /* table stuff -- end*/ #endif inset_owner = 0; id_ = paragraph_id++; @@ -129,15 +122,15 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, BufferParams const & params, char footflag, char dth) const { - LyXFont font1, font2; - int column = 0; - int h = 0; - char c = 0; - - if (footnoteflag != LyXParagraph::NO_FOOTNOTE - || !previous - || previous->footnoteflag == LyXParagraph::NO_FOOTNOTE) { +#ifndef NEW_INSETS + if ( + footnoteflag != LyXParagraph::NO_FOOTNOTE || + !previous + || previous->footnoteflag == LyXParagraph::NO_FOOTNOTE + ) { +#endif +#ifndef NEW_INSETS // The beginning or the end of a footnote environment? if (footflag != footnoteflag) { footflag = footnoteflag; @@ -149,7 +142,7 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, os << "\n\\end_float "; } } - +#endif // The beginning or end of a deeper (i.e. nested) area? if (dth != depth) { if (depth > dth) { @@ -208,6 +201,7 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, // Alignment? if (align != LYX_ALIGN_LAYOUT) { + int h = 0; switch (align) { case LYX_ALIGN_LEFT: h = 1; break; case LYX_ALIGN_RIGHT: h = 2; break; @@ -237,25 +231,21 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, } os << '\n'; } +#ifndef NEW_INSETS } else { // Dummy layout. This means that a footnote ended. os << "\n\\end_float "; footflag = LyXParagraph::NO_FOOTNOTE; } -#ifndef NEW_TABULAR - // It might be a table. - if (table){ - os << "\\LyXTable\n"; - table->Write(os); - } #endif + // bibitem ale970302 if (bibkey) bibkey->Write(buf, os); - font1 = LyXFont(LyXFont::ALL_INHERIT,params.language_info); + LyXFont font1(LyXFont::ALL_INHERIT, params.language); - column = 0; + int column = 0; for (size_type i = 0; i < size(); ++i) { if (!i) { os << "\n"; @@ -263,14 +253,14 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, } // Write font changes - font2 = GetFontSettings(params, i); + LyXFont font2 = GetFontSettings(params, i); if (font2 != font1) { font2.lyxWriteChanges(font1, os); column = 0; font1 = font2; } - c = GetChar(i); + value_type const c = GetChar(i); switch (c) { case META_INSET: { @@ -325,7 +315,7 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, break; } } - + // now write the next paragraph if (next) next->writeFile(buf, os, params, footflag, dth); @@ -335,11 +325,13 @@ void LyXParagraph::writeFile(Buffer const * buf, ostream & os, void LyXParagraph::validate(LaTeXFeatures & features) const { BufferParams const & params = features.bufferParams(); - + +#ifndef NEW_INSETS // this will be useful later LyXLayout const & layout = textclasslist.Style(params.textclass, GetLayout()); +#endif // check the params. if (line_top || line_bottom) @@ -351,7 +343,7 @@ void LyXParagraph::validate(LaTeXFeatures & features) const features.layout[GetLayout()] = true; // then the fonts - Language const * doc_language = params.language_info; + Language const * doc_language = params.language; for (FontList::const_iterator cit = fontlist.begin(); cit != fontlist.end(); ++cit) { @@ -377,10 +369,10 @@ void LyXParagraph::validate(LaTeXFeatures & features) const } Language const * language = (*cit).font.language(); - if (language != doc_language) { + if (language->babel() != doc_language->babel()) { features.UsedLanguages.insert(language); lyxerr[Debug::LATEX] << "Found language " - << language->lang() << endl; + << language->babel() << endl; } } @@ -391,35 +383,37 @@ void LyXParagraph::validate(LaTeXFeatures & features) const (*cit).inset->Validate(features); } - if (table && table->IsLongTable()) - features.longtable = true; if (pextra_type == PEXTRA_INDENT) features.LyXParagraphIndent = true; if (pextra_type == PEXTRA_FLOATFLT) features.floatflt = true; +#ifndef NEW_INSETS if (layout.needprotect && next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) features.NeedLyXFootnoteCode = true; +#endif if (params.paragraph_separation == BufferParams::PARSEP_INDENT && pextra_type == LyXParagraph::PEXTRA_MINIPAGE) features.NeedLyXMinipageIndent = true; - if (table && table->NeedRotating()) - features.rotating = true; +#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(BufferParams const & bparams, +void LyXParagraph::CopyIntoMinibuffer(Buffer const & buffer, LyXParagraph::size_type pos) const { + BufferParams bparams = buffer.params; + 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(); + minibuffer_inset = GetInset(pos)->Clone(buffer); } else { minibuffer_inset = 0; minibuffer_char = ' '; @@ -442,9 +436,11 @@ void LyXParagraph::CutIntoMinibuffer(BufferParams const & bparams, // the inset, not just a clone. Otherwise // the inset would be deleted when calling Erase(pos) // find the entry - InsetList::iterator it = lower_bound(insetlist.begin(), - insetlist.end(), - pos, matchIT()); + InsetTable search_elem(pos, 0); + InsetList::iterator it = + lower_bound(insetlist.begin(), + insetlist.end(), + search_elem, matchIT()); if (it != insetlist.end() && (*it).pos == pos) (*it).inset = 0; } else { @@ -519,11 +515,6 @@ LyXParagraph::~LyXParagraph() it != insetlist.end(); ++it) { delete (*it).inset; } -#ifndef NEW_TABULAR - /* table stuff -- begin*/ - delete table; - /* table stuff -- end*/ -#endif // ale970302 delete bibkey; @@ -535,106 +526,129 @@ LyXParagraph::~LyXParagraph() void LyXParagraph::Erase(LyXParagraph::size_type pos) { +#ifndef NEW_INSETS // > because last is the next unused position, and you can // use it if you want if (pos > size()) { -#ifndef NEW_INSETS if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) NextAfterFootnote()->Erase(pos - text.size() - 1); else -#endif 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 - InsetList::iterator it = lower_bound(insetlist.begin(), - insetlist.end(), - pos, matchIT()); + 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. - FontList::iterator it = lower_bound(fontlist.begin(), - fontlist.end(), - pos, matchFT()); + 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))) { + (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 i = it - fontlist.begin(); + 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; + fontlist[i - 1].font == fontlist[i].font) { + fontlist.erase(fontlist.begin() + i - 1); + it = fontlist.begin() + i - 1; } } // Update all other entries. - for (; it != fontlist.end(); ++it) + FontList::iterator fend = fontlist.end(); + for (; it != fend; ++it) --(*it).pos; // Update the inset table. - for (InsetList::iterator it = upper_bound(insetlist.begin(), - insetlist.end(), - pos, matchIT()); - it != insetlist.end(); ++it) + 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 } -void LyXParagraph::InsertChar(LyXParagraph::size_type pos, char c) +void LyXParagraph::InsertChar(LyXParagraph::size_type pos, + LyXParagraph::value_type c) { - LyXFont f(LyXFont::ALL_INHERIT); + LyXFont const f(LyXFont::ALL_INHERIT); InsertChar(pos, c, f); } void LyXParagraph::InsertChar(LyXParagraph::size_type pos, - char c, LyXFont const & font) + LyXParagraph::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()) { -#ifndef NEW_INSETS if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) NextAfterFootnote()->InsertChar(pos - text.size() - 1, c); else -#endif 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(), - pos, matchFT()); + search_font, matchFT()); it != fontlist.end(); ++it) ++(*it).pos; // Update the inset table. + InsetTable search_inset(pos, 0); for (InsetList::iterator it = lower_bound(insetlist.begin(), insetlist.end(), - pos, matchIT()); + search_inset, matchIT()); it != insetlist.end(); ++it) ++(*it).pos; @@ -645,7 +659,7 @@ void LyXParagraph::InsertChar(LyXParagraph::size_type pos, void LyXParagraph::InsertInset(LyXParagraph::size_type pos, Inset * inset) { - LyXFont f(LyXFont::ALL_INHERIT); + LyXFont const f(LyXFont::ALL_INHERIT); InsertInset(pos, inset, f); } @@ -655,29 +669,32 @@ void LyXParagraph::InsertInset(LyXParagraph::size_type pos, { Assert(inset); +#ifndef NEW_INSETS // > because last is the next unused position, and you can // use it if you want if (pos > size()) { -#ifndef NEW_INSETS if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) NextAfterFootnote() ->InsertInset(pos - text.size() - 1, inset, font); else -#endif 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(), - pos, matchIT()); + search_inset, matchIT()); if (it != insetlist.end() && (*it).pos == pos) lyxerr << "ERROR (LyXParagraph::InsertInset): " "there is an inset in position: " << pos << endl; @@ -690,7 +707,7 @@ void LyXParagraph::InsertInset(LyXParagraph::size_type pos, bool LyXParagraph::InsertInsetAllowed(Inset * inset) { - lyxerr << "LyXParagraph::InsertInsetAllowed" << endl; + //lyxerr << "LyXParagraph::InsertInsetAllowed" << endl; if (inset_owner) return inset_owner->InsertInsetAllowed(inset); @@ -700,24 +717,27 @@ bool LyXParagraph::InsertInsetAllowed(Inset * inset) Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos) { - if (pos >= size()) { #ifndef NEW_INSETS + if (pos >= size()) { if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->GetInset(pos - text.size() - 1); else -#endif lyxerr << "ERROR (LyXParagraph::GetInset): " "position does not exist: " << pos << endl; return 0; } +#else + Assert(pos < size()); +#endif // Find the inset. + InsetTable search_inset(pos, 0); InsetList::iterator it = lower_bound(insetlist.begin(), insetlist.end(), - pos, matchIT()); + search_inset, matchIT()); if (it != insetlist.end() && (*it).pos == pos) return (*it).inset; @@ -736,24 +756,27 @@ Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos) Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const { - if (pos >= size()) { #ifndef NEW_INSETS + if (pos >= size()) { if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->GetInset(pos - text.size() - 1); else -#endif lyxerr << "ERROR (LyXParagraph::GetInset): " "position does not exist: " << pos << endl; 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(), - pos, matchIT()); + search_inset, matchIT()); if (cit != insetlist.end() && (*cit).pos == pos) return (*cit).inset; @@ -771,27 +794,34 @@ Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const // Gets uninstantiated font setting at position. // Optimized after profiling. (Asger) -LyXFont LyXParagraph::GetFontSettings(BufferParams const & bparams, +LyXFont const LyXParagraph::GetFontSettings(BufferParams const & bparams, LyXParagraph::size_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(), - pos, matchFT()); + 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()) { -#ifndef NEW_INSETS if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->GetFontSettings(bparams, pos - text.size() - 1); else -#endif // 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? @@ -803,14 +833,21 @@ LyXFont LyXParagraph::GetFontSettings(BufferParams const & bparams, << ")" << endl; } else if (pos > 0) { return GetFontSettings(bparams, pos - 1); - } else // pos = size() = 0 - return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams)); + } +#else + if (pos == size() && size()) + return GetFontSettings(bparams, pos - 1); +#endif + //else + // pos = size() = 0 + return LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams)); - return LyXFont(LyXFont::ALL_INHERIT); + //return LyXFont(LyXFont::ALL_INHERIT); } + // Gets uninstantiated font setting at position 0 -LyXFont LyXParagraph::GetFirstFontSettings() const +LyXFont const LyXParagraph::GetFirstFontSettings() const { if (size() > 0) { if (!fontlist.empty()) @@ -832,7 +869,7 @@ LyXFont 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 LyXParagraph::getFont(BufferParams const & bparams, +LyXFont const LyXParagraph::getFont(BufferParams const & bparams, LyXParagraph::size_type pos) const { LyXFont tmpfont; @@ -888,16 +925,19 @@ LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos, 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(), - endpos, matchFT()); + end_search, matchFT()); if (end_it != fontlist.end()) ++end_it; - for (FontList::const_iterator cit = lower_bound(fontlist.begin(), - fontlist.end(), - startpos, matchFT()); + 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(); if (size > maxsize && size <= LyXFont::SIZE_HUGER) @@ -907,36 +947,40 @@ LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos, } -char LyXParagraph::GetChar(LyXParagraph::size_type pos) +LyXParagraph::value_type +LyXParagraph::GetChar(LyXParagraph::size_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()) { -#ifndef NEW_INSETS if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) return NextAfterFootnote() ->GetChar(pos - text.size() - 1); else -#endif { - lyxerr << "ERROR (LyXParagraph::GetChar): " + lyxerr << "ERROR (LyXParagraph::GetChar const): " "position does not exist." << pos << " (" << static_cast(pos) << ")\n"; - // Assert(false); // This triggers sometimes... - // Why? + Assert(false); } - return '\0'; - } - -#ifndef NEW_INSETS - else { + } else { // We should have a footnote environment. if (!next || next->footnoteflag == LyXParagraph::NO_FOOTNOTE) { // Notice that LyX does request the @@ -965,65 +1009,51 @@ char LyXParagraph::GetChar(LyXParagraph::size_type pos) } -char LyXParagraph::GetChar(LyXParagraph::size_type pos) const +LyXParagraph::value_type +LyXParagraph::GetUChar(BufferParams const & bparams, + LyXParagraph::size_type pos) const { - Assert(pos >= 0); + value_type c = GetChar(pos); + if (!lyxrc.rtl_support) + return c; - if (pos < size()) { - return text[pos]; - } - // > because last is the next unused position, and you can - // use it if you want - else if (pos > size()) { -#ifndef NEW_INSETS - if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) - return NextAfterFootnote() - ->GetChar(pos - text.size() - 1); - else -#endif - { - lyxerr << "ERROR (LyXParagraph::GetChar const): " - "position does not exist." - << pos << " (" << static_cast(pos) - << ")\n"; - Assert(false); - } - return '\0'; - } -#ifndef NEW_INSETS - 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 + value_type uc = c; + switch (c) { + case '(': + uc = ')'; + break; + case ')': + uc = '('; + break; + case '[': + uc = ']'; + break; + case ']': + uc = '['; + break; + case '{': + uc = '}'; + break; + case '}': + uc = '{'; + break; + case '<': + uc = '>'; + break; + case '>': + uc = '<'; + break; } -#endif + 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 LyXParagraph::GetWord(LyXParagraph::size_type & lastpos) const +string const LyXParagraph::GetWord(LyXParagraph::size_type & lastpos) const { - Assert(lastpos>=0); + Assert(lastpos >= 0); // the current word is defined as starting at the first character // from the immediate left of lastpospos which meets the definition @@ -1066,7 +1096,10 @@ string LyXParagraph::GetWord(LyXParagraph::size_type & lastpos) const } - + +#ifdef NEW_INSETS +#warning Remember to get rid of this one. (Lgb) +#endif LyXParagraph::size_type LyXParagraph::Last() const { #ifndef NEW_INSETS @@ -1080,38 +1113,37 @@ LyXParagraph::size_type LyXParagraph::Last() const } +#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()) { -#ifndef NEW_INSETS if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->ParFromPos(pos - text.size() - 1); else -#endif 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()) { -#ifndef NEW_INSETS if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->PositionInParFromPos(pos - text.size() - 1); else -#endif lyxerr << "ERROR (LyXParagraph::PositionInParFromPos): " "position does not exist." << endl; @@ -1120,26 +1152,29 @@ int LyXParagraph::PositionInParFromPos(LyXParagraph::size_type pos) const else return pos; } +#endif void LyXParagraph::SetFont(LyXParagraph::size_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()) { -#ifndef NEW_INSETS if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { NextAfterFootnote()->SetFont(pos - text.size() - 1, font); } else -#endif lyxerr << "ERROR (LyXParagraph::SetFont): " "position does not exist." << endl; return; } +#else + Assert(pos <= size()); +#endif // First, reduce font against layout/label font // Update: The SetCharFont() routine in text2.C already @@ -1148,9 +1183,10 @@ 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(), - pos, matchFT()); + search_font, matchFT()); unsigned int i = it - fontlist.begin(); bool notfound = it == fontlist.end(); @@ -1163,34 +1199,35 @@ void LyXParagraph::SetFont(LyXParagraph::size_type pos, bool end = !notfound && 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 < fontlist.size() && + 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) + if (i > 0 && fontlist[i - 1].font == font) fontlist.erase(fontlist.begin() + i-1); - } else if (i > 0 && fontlist[i-1].font == font) { + } else if (i > 0 && fontlist[i - 1].font == font) { // Merge the singleton block with the previous block - fontlist[i-1].pos = pos; + fontlist[i - 1].pos = pos; fontlist.erase(fontlist.begin() + i); } else fontlist[i].font = font; } else if (begin) { - if (i > 0 && fontlist[i-1].font == font) - fontlist[i-1].pos = pos; + if (i > 0 && fontlist[i - 1].font == font) + fontlist[i - 1].pos = pos; else fontlist.insert(fontlist.begin() + i, 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, + if (!(i + 1 < fontlist.size() && + fontlist[i + 1].font == font)) + fontlist.insert(fontlist.begin() + i + 1, 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)); + fontlist.insert(fontlist.begin() + i + 1, + FontTable(pos, font)); } } @@ -1216,9 +1253,9 @@ LyXParagraph * LyXParagraph::Next() } +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::NextAfterFootnote() { -#ifndef NEW_INSETS if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) { LyXParagraph * tmp = next; while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) @@ -1229,14 +1266,14 @@ LyXParagraph * LyXParagraph::NextAfterFootnote() else return next; // This should never happen! } else -#endif return next; } +#endif +#ifndef NEW_INSETS LyXParagraph const * LyXParagraph::NextAfterFootnote() const { -#ifndef NEW_INSETS if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) { LyXParagraph * tmp = next; while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) @@ -1247,14 +1284,14 @@ LyXParagraph const * LyXParagraph::NextAfterFootnote() const else return next; // This should never happen! } else -#endif return next; } +#endif +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::PreviousBeforeFootnote() { -#ifndef NEW_INSETS LyXParagraph * tmp; if (previous && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE) { tmp = previous; @@ -1266,14 +1303,14 @@ LyXParagraph * LyXParagraph::PreviousBeforeFootnote() else return previous; // This should never happen! } else -#endif return previous; } +#endif +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::LastPhysicalPar() { -#ifndef NEW_INSETS if (footnoteflag != LyXParagraph::NO_FOOTNOTE) return this; @@ -1283,14 +1320,13 @@ LyXParagraph * LyXParagraph::LastPhysicalPar() tmp = tmp->NextAfterFootnote(); return tmp; -#else - return this; -#endif } +#endif + +#ifndef NEW_INSETS LyXParagraph const * LyXParagraph::LastPhysicalPar() const { -#ifndef NEW_INSETS if (footnoteflag != LyXParagraph::NO_FOOTNOTE) return this; @@ -1300,14 +1336,13 @@ LyXParagraph const * LyXParagraph::LastPhysicalPar() const tmp = tmp->NextAfterFootnote(); return tmp; -#else - return this; -#endif } +#endif + +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::FirstPhysicalPar() { -#ifndef NEW_INSETS if (!IsDummy()) return this; LyXParagraph * tmppar = this; @@ -1321,15 +1356,13 @@ LyXParagraph * LyXParagraph::FirstPhysicalPar() return this; } else return tmppar; -#else - return this; -#endif } +#endif +#ifndef NEW_INSETS LyXParagraph const * LyXParagraph::FirstPhysicalPar() const { -#ifndef NEW_INSETS if (!IsDummy()) return this; LyXParagraph const * tmppar = this; @@ -1343,20 +1376,18 @@ LyXParagraph const * LyXParagraph::FirstPhysicalPar() const return this; } else return tmppar; -#else - return this; -#endif } +#endif // This function is able to hide closed footnotes. LyXParagraph * LyXParagraph::Previous() { +#ifndef NEW_INSETS LyXParagraph * tmp = previous; if (!tmp) return tmp; -#ifndef NEW_INSETS if (tmp->previous && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { tmp = tmp->previous; @@ -1377,10 +1408,10 @@ LyXParagraph * LyXParagraph::Previous() // This function is able to hide closed footnotes. LyXParagraph const * LyXParagraph::Previous() const { +#ifndef NEW_INSETS LyXParagraph * tmp = previous; if (!tmp) return tmp; -#ifndef NEW_INSETS if (tmp->previous && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { tmp = tmp->previous; @@ -1402,12 +1433,21 @@ void LyXParagraph::BreakParagraph(BufferParams const & bparams, LyXParagraph::size_type pos, int flag) { - size_type i, j, pos_end, pos_first; + 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; @@ -1415,13 +1455,21 @@ void LyXParagraph::BreakParagraph(BufferParams const & bparams, #endif // 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->labelwidthstring); } - +#else + // layout stays the same with latex-environments + if (flag) { + tmp->SetOnlyLayout(bparams, layout); + tmp->SetLabelWidthString(labelwidthstring); + } +#endif +#ifndef NEW_INSETS if (Last() > pos || !Last() || flag == 2) { tmp->SetOnlyLayout(bparams, firstpar->layout); tmp->align = firstpar->align; @@ -1436,27 +1484,60 @@ void LyXParagraph::BreakParagraph(BufferParams const & bparams, tmp->depth = firstpar->depth; tmp->noindent = firstpar->noindent; - +#else + if (Last() > pos || !Last() || flag == 2) { + tmp->SetOnlyLayout(bparams, layout); + tmp->align = align; + tmp->SetLabelWidthString(labelwidthstring); + + tmp->line_bottom = line_bottom; + line_bottom = false; + tmp->pagebreak_bottom = pagebreak_bottom; + pagebreak_bottom = false; + tmp->added_space_bottom = added_space_bottom; + added_space_bottom = VSpace(VSpace::NONE); + + tmp->depth = depth; + tmp->noindent = noindent; +#endif // 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->text.resize(tmp->text.size()); + + tmp->fitToSize(); + for (i = pos_end; i >= pos; --i) par->Erase(i - pos_first); - par->text.resize(par->text.size()); + 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)) + ++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->line_top = firstpar->line_top; @@ -1471,13 +1552,29 @@ void LyXParagraph::BreakParagraph(BufferParams const & bparams, firstpar->depth = tmp->depth; } } +#else + // just an idea of me + if (!pos) { + tmp->line_top = line_top; + tmp->pagebreak_top = pagebreak_top; + tmp->added_space_top = added_space_top; + tmp->bibkey = bibkey; + Clear(); + // layout stays the same with latex-environments + if (flag) { + SetOnlyLayout(bparams, tmp->layout); + SetLabelWidthString(tmp->labelwidthstring); + depth = tmp->depth; + } + } +#endif } void LyXParagraph::MakeSameLayout(LyXParagraph const * par) { - par = par->FirstPhysicalPar(); #ifndef NEW_INSETS + par = par->FirstPhysicalPar(); footnoteflag = par->footnoteflag; footnotekind = par->footnotekind; #endif @@ -1532,13 +1629,17 @@ int LyXParagraph::StripLeadingSpaces(LyXTextClassList::size_type tclass) return 0; int i = 0; - if (!IsDummy() && !table){ +#ifndef NEW_INSETS + if (!IsDummy()) { +#endif while (Last() && (IsNewline(0) || IsLineSeparator(0))){ Erase(0); ++i; } +#ifndef NEW_INSETS } +#endif return i; } @@ -1554,19 +1655,14 @@ LyXParagraph * LyXParagraph::Clone() const // follow footnotes result->layout = layout; -#ifndef NEW_TABULAR - /* table stuff -- begin*/ - if (table) - result->table = table->Clone(); - else - result->table = 0; - /* table stuff -- end*/ -#endif result->inset_owner = inset_owner; // ale970302 - result->bibkey = (bibkey) ? new InsetBibKey(bibkey): 0; - + 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 @@ -1575,14 +1671,16 @@ LyXParagraph * LyXParagraph::Clone() const result->insetlist = insetlist; for (InsetList::iterator it = result->insetlist.begin(); it != result->insetlist.end(); ++it) - (*it).inset = (*it).inset->Clone(); + (*it).inset = (*it).inset->Clone(*current_view->buffer()); return result; } bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const { +#ifndef NEW_INSETS par = par->FirstPhysicalPar(); +#endif return ( #ifndef NEW_INSETS @@ -1609,10 +1707,6 @@ bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const par->pextra_alignment == pextra_alignment && par->pextra_hfill == pextra_hfill && par->pextra_start_minipage == pextra_start_minipage && -#ifndef NEW_TABULAR - par->table == table && // what means: NO TABLE AT ALL -#endif - par->noindent == noindent && par->depth == depth); } @@ -1621,6 +1715,7 @@ bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const void LyXParagraph::BreakParagraphConservative(BufferParams const & bparams, LyXParagraph::size_type pos) { +#ifndef NEW_INSETS // create a new paragraph LyXParagraph * par = ParFromPos(pos); @@ -1644,27 +1739,65 @@ void LyXParagraph::BreakParagraphConservative(BufferParams const & bparams, if (tmp->InsertFromMinibuffer(j - pos)) ++j; } - tmp->text.resize(tmp->text.size()); + + tmp->fitToSize(); + for (size_type i = pos_end; i >= pos; --i) par->Erase(i - pos_first); - par->text.resize(par->text.size()); + par->fitToSize(); } +#else + // create a new paragraph + LyXParagraph * tmp = new LyXParagraph(this); + tmp->MakeSameLayout(this); + + // 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_end = text.size() - 1; + + size_type i, j; + for (i = 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(); + } +#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) { // copy the next paragraph to this one LyXParagraph * the_next = Next(); - +#ifndef NEW_INSETS LyXParagraph * firstpar = FirstPhysicalPar(); +#endif // first the DTP-stuff +#ifndef NEW_INSETS firstpar->line_bottom = the_next->line_bottom; firstpar->added_space_bottom = the_next->added_space_bottom; firstpar->pagebreak_bottom = the_next->pagebreak_bottom; +#else + line_bottom = the_next->line_bottom; + added_space_bottom = the_next->added_space_bottom; + pagebreak_bottom = the_next->pagebreak_bottom; +#endif size_type pos_end = the_next->text.size() - 1; size_type pos_insert = Last(); @@ -1708,21 +1841,26 @@ void LyXParagraph::CloseFootnote(LyXParagraph::size_type pos) } #endif + int LyXParagraph::GetEndLabel(BufferParams const & bparams) const { LyXParagraph const * par = this; int par_depth = GetDepth(); while (par) { LyXTextClass::LayoutList::size_type layout = par->GetLayout(); - int endlabeltype = + int const endlabeltype = textclasslist.Style(bparams.textclass, layout).endlabeltype; if (endlabeltype != END_LABEL_NO_LABEL) { LyXParagraph const * last = this; - if( footnoteflag == NO_FOOTNOTE) +#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) return endlabeltype; @@ -1745,39 +1883,64 @@ int LyXParagraph::GetEndLabel(BufferParams const & bparams) const LyXTextClass::size_type LyXParagraph::GetLayout() const { +#ifndef NEW_INSETS return FirstPhysicalPar()->layout; +#else + return layout; +#endif } char LyXParagraph::GetDepth() const { +#ifndef NEW_INSETS return FirstPhysicalPar()->depth; +#else + return depth; +#endif } char LyXParagraph::GetAlign() const { +#ifndef NEW_INSETS return FirstPhysicalPar()->align; +#else + return align; +#endif } -string LyXParagraph::GetLabelstring() const +string const & LyXParagraph::GetLabelstring() const { +#ifndef NEW_INSETS return FirstPhysicalPar()->labelstring; +#else + return labelstring; +#endif } int LyXParagraph::GetFirstCounter(int i) const { +#ifndef NEW_INSETS return FirstPhysicalPar()->counter_[i]; +#else + return counter_[i]; +#endif } // the next two functions are for the manual labels -string LyXParagraph::GetLabelWidthString() const +string const LyXParagraph::GetLabelWidthString() const { +#ifndef NEW_INSETS if (!FirstPhysicalPar()->labelwidthstring.empty()) return FirstPhysicalPar()->labelwidthstring; +#else + if (!labelwidthstring.empty()) + return labelwidthstring; +#endif else return _("Senseless with this layout!"); } @@ -1785,55 +1948,73 @@ string LyXParagraph::GetLabelWidthString() const void LyXParagraph::SetLabelWidthString(string const & s) { +#ifndef NEW_INSETS LyXParagraph * par = FirstPhysicalPar(); par->labelwidthstring = s; +#else + labelwidthstring = s; +#endif } void LyXParagraph::SetOnlyLayout(BufferParams const & bparams, LyXTextClass::size_type new_layout) { +#ifndef NEW_INSETS LyXParagraph * par = FirstPhysicalPar(); +#else + LyXParagraph * par = this; +#endif LyXParagraph * ppar = 0; LyXParagraph * npar = 0; par->layout = new_layout; -#ifndef NEW_TABULAR - /* table stuff -- begin*/ - if (table) - par->layout = 0; - /* table stuff -- end*/ -#endif + if (par->pextra_type == PEXTRA_NONE) { if (par->Previous()) { +#ifndef NEW_INSETS ppar = par->Previous()->FirstPhysicalPar(); +#else + ppar = par->Previous(); +#endif while(ppar && ppar->Previous() && (ppar->depth > par->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->depth > par->depth)) +#ifndef NEW_INSETS npar = npar->Next()->NextAfterFootnote(); +#else + npar = npar->Next(); +#endif } if (ppar && (ppar->pextra_type != PEXTRA_NONE)) { string p1 = ppar->pextra_width, p2 = ppar->pextra_widthp; ppar->SetPExtraType(bparams, ppar->pextra_type, - p1.c_str(), p2.c_str()); + p1, p2); } if ((par->pextra_type == PEXTRA_NONE) && npar && (npar->pextra_type != PEXTRA_NONE)) { - string - p1 = npar->pextra_width, - p2 = npar->pextra_widthp; + string const p1 = npar->pextra_width; + string const p2 = npar->pextra_widthp; npar->SetPExtraType(bparams, npar->pextra_type, - p1.c_str(), p2.c_str()); + p1, p2); } } } @@ -1843,7 +2024,11 @@ 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; @@ -1854,41 +2039,49 @@ void LyXParagraph::SetLayout(BufferParams const & bparams, par->added_space_bottom = VSpace(VSpace::NONE); par->spacing.set(Spacing::Default); -#ifndef NEW_TABULAR - /* table stuff -- begin*/ - if (table) - par->layout = 0; - /* table stuff -- end*/ -#endif if (par->pextra_type == PEXTRA_NONE) { if (par->Previous()) { +#ifndef NEW_INSETS ppar = par->Previous()->FirstPhysicalPar(); +#else + ppar = par->Previous(); +#endif while(ppar && ppar->Previous() && (ppar->depth > par->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->depth > par->depth)) +#ifndef NEW_INSETS npar = npar->Next()->NextAfterFootnote(); +#else + npar = npar->Next(); +#endif } if (ppar && (ppar->pextra_type != PEXTRA_NONE)) { - string - p1 = ppar->pextra_width, - p2 = ppar->pextra_widthp; + string const p1 = ppar->pextra_width; + string const p2 = ppar->pextra_widthp; ppar->SetPExtraType(bparams, ppar->pextra_type, - p1.c_str(), p2.c_str()); + p1, p2); } if ((par->pextra_type == PEXTRA_NONE) && npar && (npar->pextra_type != PEXTRA_NONE)) { - string - p1 = npar->pextra_width, - p2 = npar->pextra_widthp; + string const p1 = npar->pextra_width; + string const p2 = npar->pextra_widthp; npar->SetPExtraType(bparams, npar->pextra_type, - p1.c_str(), p2.c_str()); + p1, p2); } } } @@ -1903,9 +2096,10 @@ void LyXParagraph::SetLayout(BufferParams const & bparams, int LyXParagraph::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 @@ -1914,7 +2108,8 @@ int LyXParagraph::BeginningOfMainBody() const && GetChar(i) != LyXParagraph::META_NEWLINE ) { ++i; - char previous_char = 0, temp = 0; + char previous_char = 0; + char temp = 0; if (i < size() && (previous_char = GetChar(i)) != LyXParagraph::META_NEWLINE) { // Yes, this ^ is supposed to be "= " not "==" @@ -1928,12 +2123,14 @@ int LyXParagraph::BeginningOfMainBody() const } } +#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; } @@ -1945,9 +2142,16 @@ LyXParagraph * LyXParagraph::DepthHook(int deth) return 0; do { +#ifndef NEW_INSETS newpar = newpar->FirstPhysicalPar()->Previous(); +#else + newpar = newpar->Previous(); +#endif } while (newpar && newpar->GetDepth() > deth - && newpar->footnoteflag == footnoteflag); +#ifndef NEW_INSETS + && newpar->footnoteflag == footnoteflag +#endif + ); if (!newpar) { if (Previous() || GetDepth()) @@ -1955,7 +2159,11 @@ LyXParagraph * LyXParagraph::DepthHook(int deth) "no hook." << endl; newpar = this; } +#ifndef NEW_INSETS return newpar->FirstPhysicalPar(); +#else + return newpar; +#endif } @@ -1966,9 +2174,16 @@ LyXParagraph const * LyXParagraph::DepthHook(int deth) const return 0; do { +#ifndef NEW_INSETS newpar = newpar->FirstPhysicalPar()->Previous(); +#else + newpar = newpar->Previous(); +#endif } while (newpar && newpar->GetDepth() > deth - && newpar->footnoteflag == footnoteflag); +#ifndef NEW_INSETS + && newpar->footnoteflag == footnoteflag +#endif + ); if (!newpar) { if (Previous() || GetDepth()) @@ -1976,7 +2191,11 @@ LyXParagraph const * LyXParagraph::DepthHook(int deth) const "no hook." << endl; newpar = this; } +#ifndef NEW_INSETS return newpar->FirstPhysicalPar(); +#else + return newpar; +#endif } @@ -1997,11 +2216,13 @@ int LyXParagraph::AutoDeleteInsets() } -LyXParagraph::inset_iterator LyXParagraph::InsetIterator(LyXParagraph::size_type pos) +LyXParagraph::inset_iterator +LyXParagraph::InsetIterator(LyXParagraph::size_type pos) { + InsetTable search_inset(pos, 0); InsetList::iterator it = lower_bound(insetlist.begin(), insetlist.end(), - pos, matchIT()); + search_inset, matchIT()); return inset_iterator(it); } @@ -2010,29 +2231,25 @@ LyXParagraph::inset_iterator LyXParagraph::InsetIterator(LyXParagraph::size_type int LyXParagraph::GetPositionOfInset(Inset * inset) const { // Find the entry. - // We could use lower_bound here too, we just need to add - // the approp. operator() to matchIT (and change the name - // of that struct). Code would then be: - // InsetList::const_iterator cit = lower_bound(insetlist.begin(), - // insetlist.end(), - // inset, matchIT()); - // if ((*cit).inset == inset) { - // return (*cit).pos; - // } for (InsetList::const_iterator cit = insetlist.begin(); cit != insetlist.end(); ++cit) { 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 further = + int const further = NextAfterFootnote()->GetPositionOfInset(inset); if (further != -1) return text.size() + 1 + further; } +#endif return -1; } @@ -2040,10 +2257,14 @@ int LyXParagraph::GetPositionOfInset(Inset * inset) const LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, BufferParams const & bparams, ostream & os, TexRow & texrow, - bool moving_arg, + bool moving_arg +#ifndef NEW_INSETS + , ostream & foot, TexRow & foot_texrow, - int & foot_count) + int & foot_count +#endif + ) { lyxerr[Debug::LATEX] << "TeXOnePar... " << this << endl; LyXLayout const & style = @@ -2051,8 +2272,10 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, layout); bool further_blank_line = false; +#ifndef NEW_INSETS if (IsDummy()) lyxerr << "ERROR (LyXParagraph::TeXOnePar) is dummy." << endl; +#endif if (start_of_appendix) { os << "\\appendix\n"; @@ -2091,14 +2314,24 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, } Language const * language = getParLanguage(bparams); - Language const * doc_language = bparams.language_info; - if (language != doc_language && - (!previous || previous->getParLanguage(bparams) != language)) { + 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->lang()) + language->babel()) << endl; texrow.newline(); } + + if (bparams.inputenc == "auto" && + language->encoding() != previous_language->encoding()) { + os << "\\inputencoding{" + << language->encoding()->LatexName() + << "}" << endl; + texrow.newline(); + } switch (style.latextype) { case LATEX_COMMAND: @@ -2121,9 +2354,9 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, bool need_par = SimpleTeXOnePar(buf, bparams, os, texrow, moving_arg); + LyXParagraph * par = next; #ifndef NEW_INSETS // Spit out footnotes - LyXParagraph * par = next; if (lyxrc.rtl_support) { if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE && next->footnoteflag != footnoteflag) { @@ -2132,7 +2365,7 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, ? GetFontSettings(bparams, size()-1).isRightToLeft() : language->RightToLeft(); - if ( (p = NextAfterFootnote()) != 0 && + if ((p = NextAfterFootnote()) != 0 && p->size() > 0 && p->GetFontSettings(bparams, 0).isRightToLeft() != is_rtl) is_rtl = getParLanguage(bparams)->RightToLeft(); @@ -2175,33 +2408,31 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, // This is necessary because LaTeX (and LyX on the screen) // calculates the space between the baselines according // to this font. (Matthias) + // + // Is this really needed ? (Dekel) + // We do not need to use to change the font for the last paragraph + // or for a command. LyXFont font = getFont(bparams, Last() - 1); - if (need_par) { - if (style.resfont.size() != font.size()) { - os << '\\' - << font.latexSize() - << ' '; - } + bool is_command = textclasslist.Style(bparams.textclass, + GetLayout()).isCommand(); + if (style.resfont.size() != font.size() && next && !is_command) { + if (!need_par) + os << "{"; + os << "\\" << font.latexSize() << " \\par}"; + } else if (need_par) { os << "\\par}"; - } else if (textclasslist.Style(bparams.textclass, - GetLayout()).isCommand()) { - if (style.resfont.size() != font.size()) { - os << '\\' - << font.latexSize() - << ' '; - } - os << '}'; - } else if (style.resfont.size() != font.size()){ - os << "{\\" << font.latexSize() << " \\par}"; - } + } else if (is_command) + os << "}"; - if (language != doc_language && + if (language->babel() != doc_language->babel() && (!par +#ifndef NEW_INSETS || (footnoteflag != NO_FOOTNOTE && par->footnoteflag != footnoteflag) - || par->getParLanguage(bparams) != language)) { +#endif + || par->getParLanguage(bparams)->babel() != language->babel())) { os << endl << subst(lyxrc.language_command_end, "$$lang", - doc_language->lang()); + doc_language->babel()); } switch (style.latextype) { @@ -2222,16 +2453,11 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, break; default: // we don't need it for the last paragraph!!! - if (next && !(footnoteflag != LyXParagraph::NO_FOOTNOTE - && footnotekind != LyXParagraph::FOOTNOTE - && footnotekind != LyXParagraph::MARGIN - && (table - || (par - && par->table)))) { - // don't insert this if we would be adding it - // before or after a table in a float. This - // little trick is needed in order to allow - // use of tables in \subfigures or \subtables. + // 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(); } @@ -2265,8 +2491,12 @@ LyXParagraph * LyXParagraph::TeXOnePar(Buffer const * buf, } // we don't need it for the last paragraph!!! - if (next && !(footnoteflag != LyXParagraph::NO_FOOTNOTE && par && - par->footnoteflag == LyXParagraph::NO_FOOTNOTE)) { + if (next +#ifndef NEW_INSETS + && !(footnoteflag != LyXParagraph::NO_FOOTNOTE && par && + par->footnoteflag == LyXParagraph::NO_FOOTNOTE) +#endif + ) { os << '\n'; texrow.newline(); } @@ -2284,11 +2514,6 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, { lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl; -#ifndef NEW_TABULAR - if (table) - return SimpleTeXOneTablePar(buf, bparams, os, texrow); -#endif - bool return_value = false; LyXLayout const & style = @@ -2314,7 +2539,10 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, if (main_body >= 0 && !text.size() - && !IsDummy()) { +#ifndef NEW_INSETS + && !IsDummy() +#endif + ) { if (style.isCommand()) { os << '{'; ++column; @@ -2337,7 +2565,11 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, for (size_type i = 0; i < size(); ++i) { ++column; // First char in paragraph or after label? - if (i == main_body && !IsDummy()) { + if (i == main_body +#ifndef NEW_INSETS + && !IsDummy() +#endif + ) { if (main_body > 0) { if (open_font) { column += running_font.latexWriteEndChanges(os, basefont, basefont); @@ -2351,9 +2583,11 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, if (style.isCommand()) { os << '{'; ++column; - } else if (align != LYX_ALIGN_LAYOUT) { - os << "{\\par"; - column += 4; + } else if (align != LYX_ALIGN_LAYOUT && next) { + // We do not need \par here (Dekel) + // os << "{\\par"; + os << "{"; + ++column; return_value = true; } @@ -2368,7 +2602,9 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, case LYX_ALIGN_SPECIAL: break; case LYX_ALIGN_LEFT: - if (getParLanguage(bparams)->lang() != "hebrew") { + if (moving_arg) + os << "\\protect"; + if (getParLanguage(bparams)->babel() != "hebrew") { os << "\\raggedright "; column+= 13; } else { @@ -2377,7 +2613,9 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, } break; case LYX_ALIGN_RIGHT: - if (getParLanguage(bparams)->lang() != "hebrew") { + if (moving_arg) + os << "\\protect"; + if (getParLanguage(bparams)->babel() != "hebrew") { os << "\\raggedleft "; column+= 12; } else { @@ -2386,22 +2624,27 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, } break; case LYX_ALIGN_CENTER: + if (moving_arg) + os << "\\protect"; os << "\\centering "; column+= 11; break; } } - int 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 && + if (i == 0 + && previous && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE && (p = PreviousBeforeFootnote()) != 0) - last_font = p->getFont(bparams, p->size()-1); + last_font = p->getFont(bparams, p->size() - 1); else +#endif last_font = running_font; // Spaces at end of font change are simulated to be @@ -2445,344 +2688,56 @@ bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, if (!style.newline_allowed || font.latex() == LyXFont::ON) { os << '\n'; - } else { - if (open_font) { - column += running_font.latexWriteEndChanges(os, basefont, basefont); - open_font = false; - } - basefont = getFont(bparams, -1); - running_font = basefont; - if (font.family() == - LyXFont::TYPEWRITER_FAMILY) { - os << "~"; - } - if (moving_arg) - os << "\\protect "; - os << "\\\\\n"; - } - texrow.newline(); - 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); - } - } - - // If we have an open font definition, we have to close it - if (open_font) { - LyXParagraph * p = 0; - if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE - && (p = NextAfterFootnote()) != 0) - 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. - if (main_body > 0 && main_body == size()) { - os << "]~"; - return_value = false; - } - - lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl; - return return_value; -} - - -// This one spits out the text of a table paragraph -bool LyXParagraph::SimpleTeXOneTablePar(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow) -{ - lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar... " << this << endl; - - bool return_value = false; - - LyXLayout const & style = - textclasslist.Style(bparams.textclass, GetLayout()); - - int column = 0; - if (!IsDummy()) { // it is dummy if it is in a float!!! - if (style.isCommand()) { - os << '{'; - ++column; - } else if (align != LYX_ALIGN_LAYOUT) { - os << '{'; - ++column; - return_value = true; - } - if (noindent) { - os << "\\noindent "; - column += 10; - } - switch (align) { - case LYX_ALIGN_NONE: - case LYX_ALIGN_BLOCK: - case LYX_ALIGN_LAYOUT: - case LYX_ALIGN_SPECIAL: break; - case LYX_ALIGN_LEFT: - os << "\\raggedright "; - column+= 13; - break; - case LYX_ALIGN_RIGHT: - os << "\\raggedleft "; - column+= 12; - break; - case LYX_ALIGN_CENTER: - os << "\\centering "; - column+= 11; - break; - } - } - - LyXFont basefont = getFont(bparams, -1); // Get layout font - // Which font is currently active? - LyXFont running_font = basefont; - LyXFont last_font; - // Do we have an open font change? - bool open_font = false; - int current_cell_number = -1; - int tmp = table->TexEndOfCell(os, current_cell_number); - for (; tmp > 0 ; --tmp) - texrow.newline(); - - texrow.start(this, 0); - - bool is_rtl = getParLanguage(bparams)->RightToLeft(); - bool first_in_cell = true; - - for (size_type i = 0; i < size(); ++i) { - char c = GetChar(i); - if (table->IsContRow(current_cell_number + 1)) { - if (c == LyXParagraph::META_NEWLINE) - ++current_cell_number; - continue; - } - ++column; - - if (first_in_cell && is_rtl) { - os << "\\R{"; - column += 3; - first_in_cell = false; - } - - // Fully instantiated font - LyXFont font = getFont(bparams, i); - 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) != running_font - && getFont(bparams, i + 1) != font) { - font = getFont(bparams, i + 1); - } - - // We end font definition before blanks - if (font != running_font && open_font) { - column += running_font.latexWriteEndChanges(os, - basefont, - font); - running_font = basefont; - open_font = false; - } - // Blanks are printed before start of fontswitch - if (c == ' '){ - SimpleTeXBlanks(os, texrow, i, column, font, style); - } - // Do we need to change font? - if (font != running_font) { - column += font.latexWriteStartChanges(os, basefont, - last_font); - running_font = font; - open_font = true; - } - // Do we need to turn on LaTeX mode? - if (font.latex() != running_font.latex()) { - if (font.latex() == LyXFont::ON - && style.needprotect) { - os << "\\protect "; - column += 9; - } - } - if (c == LyXParagraph::META_NEWLINE) { - // special case for inside a table - // different from default case in - // SimpleTeXSpecialChars() - if (open_font) { - column += running_font - .latexWriteEndChanges(os, basefont, - basefont); - open_font = false; - } - basefont = getFont(bparams, -1); - running_font = basefont; - ++current_cell_number; - if (table->CellHasContRow(current_cell_number) >= 0) { - TeXContTableRows(buf, bparams, os, i + 1, - current_cell_number, - column, texrow); - } - if (is_rtl && !first_in_cell) { - os << "}"; - first_in_cell = true; - } - - // if this cell follow only ContRows till end don't - // put the EndOfCell because it is put after the - // for(...) - if (table->ShouldBeVeryLastCell(current_cell_number)) { - --current_cell_number; - break; - } - int tmp = table->TexEndOfCell(os, - current_cell_number); - if (tmp > 0) { - column = 0; - } else if (tmp < 0) { - tmp = -tmp; - } - for (; tmp--;) { - texrow.newline(); - } - texrow.start(this, i + 1); - } else { - SimpleTeXSpecialChars(buf, bparams, - os, texrow, false, - 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) { - running_font.latexWriteEndChanges(os, basefont, basefont); - } - ++current_cell_number; - if (is_rtl && !first_in_cell) - os << "}"; - tmp = table->TexEndOfCell(os, current_cell_number); - for (; tmp > 0; --tmp) - texrow.newline(); - lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar...done " << this << endl; - return return_value; -} - - -// This one spits out the text off ContRows in tables -bool LyXParagraph::TeXContTableRows(Buffer const * buf, - BufferParams const & bparams, - ostream & os, - LyXParagraph::size_type i, - int current_cell_number, - int & column, TexRow & texrow) -{ - lyxerr[Debug::LATEX] << "TeXContTableRows... " << this << endl; - if (!table) - return false; - - bool return_value = false; - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - GetLayout()); - LyXFont basefont = getFont(bparams, -1); // Get layout font - LyXFont last_font; - // Which font is currently active? - LyXFont running_font = basefont; - // Do we have an open font change? - bool open_font = false; - - size_type lastpos = i; - int cell = table->CellHasContRow(current_cell_number); - ++current_cell_number; - char c; - while(cell >= 0) { - // first find the right position - i = lastpos; - for (; (i < size()) && (current_cell_numberLinebreaks(table->FirstVirtualCell(cell))) { - os << " \\\\\n"; - texrow.newline(); - column = 0; - } else if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) { - os << ' '; - } - - for (; i < size() - && (c = GetChar(i)) != LyXParagraph::META_NEWLINE; - ++i) { - ++column; - - // Fully instantiated font - LyXFont font = getFont(bparams, i); - 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) != running_font - && getFont(bparams, i + 1) != font) { - font = getFont(bparams, i + 1); - } - - // We end font definition before blanks - if (font != running_font && open_font) { - column += running_font.latexWriteEndChanges(os, basefont, font); + } else { + if (open_font) { + column += running_font.latexWriteEndChanges(os, basefont, basefont); + open_font = false; + } + basefont = getFont(bparams, -1); running_font = basefont; - open_font = false; - } - // Blanks are printed before start of fontswitch - if (c == ' '){ - SimpleTeXBlanks(os, texrow, i, - column, font, style); - } - // Do we need to change font? - if (font != running_font) { - column += - font.latexWriteStartChanges(os, - basefont, - last_font); - running_font = font; - open_font = true; - } - // Do we need to turn on LaTeX mode? - if (font.latex() != running_font.latex()) { - if (font.latex() == LyXFont::ON - && style.needprotect) { - os << "\\protect "; - column += 9; + if (font.family() == + LyXFont::TYPEWRITER_FAMILY) { + os << "~"; } + if (moving_arg) + os << "\\protect "; + os << "\\\\\n"; } + texrow.newline(); + texrow.start(this, i + 1); + column = 0; + } else { SimpleTeXSpecialChars(buf, bparams, - os, texrow, false, font, - running_font, basefont, + 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) { + } + + // 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 +#else + && (p = next) +#endif + ) running_font.latexWriteEndChanges(os, basefont, - basefont); - open_font = false; - } - basefont = getFont(bparams, -1); - running_font = basefont; - cell = table->CellHasContRow(current_cell_number); + p->getFont(bparams, 0)); + else + running_font.latexWriteEndChanges(os, basefont, basefont); + } + + // Needed if there is an optional argument but no contents. + if (main_body > 0 && main_body == size()) { + os << "]~"; + return_value = false; } - lyxerr[Debug::LATEX] << "TeXContTableRows...done " << this << endl; + + lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl; return return_value; } @@ -2851,335 +2806,6 @@ bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string) } -void LyXParagraph::SimpleDocBookOneTablePar(Buffer const * buffer, - ostream & os, string & extra, - int & desc_on, int depth) -{ - BufferParams const & bparams = buffer->params; - if (!table) return; - lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar... " << this << endl; - int column = 0; - LyXFont font1, font2; - char c; - Inset * inset; - size_type main_body; - bool emph_flag = false; - - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - GetLayout()); - - if (style.labeltype != LABEL_MANUAL) - main_body = 0; - else - main_body = BeginningOfMainBody(); - - // Gets paragraph main font. - if (main_body > 0) - font1 = style.labelfont; - else - font1 = style.font; - - int char_line_count = depth; - os << newlineAndDepth(depth); - if (footnoteflag == LyXParagraph::NO_FOOTNOTE) { - os << "" - << newlineAndDepth(++depth); - } - int current_cell_number = -1; - int tmp = table->DocBookEndOfCell(os, current_cell_number, depth); - - // Parsing main loop. - for (size_type i = 0; i < size(); ++i) { - c = GetChar(i); - if (table->IsContRow(current_cell_number+1)) { - if (c == LyXParagraph::META_NEWLINE) - ++current_cell_number; - continue; - } - ++column; - - // Fully instantiated font - font2 = getFont(bparams, i); - - // Handle tag. - if (font1.emph() != font2.emph() && i) { - if (font2.emph() == LyXFont::ON) { - os << ""; - emph_flag= true; - } else if (emph_flag) { - os << ""; - emph_flag= false; - } - } - if (c == LyXParagraph::META_NEWLINE) { - // We have only to control for emphasis open here! - if (emph_flag) { - os << ""; - emph_flag= false; - } - font1 = font2 = getFont(bparams, -1); - ++current_cell_number; - if (table->CellHasContRow(current_cell_number) >= 0) { - DocBookContTableRows(buffer, - os, extra, desc_on, i + 1, - current_cell_number, - column); - } - // if this cell follow only ContRows till end don't - // put the EndOfCell because it is put after the - // for(...) - if (table->ShouldBeVeryLastCell(current_cell_number)) { - --current_cell_number; - break; - } - tmp = table->DocBookEndOfCell(os, - current_cell_number, - depth); - - if (tmp > 0) - column = 0; - } else if (c == LyXParagraph::META_INSET) { - inset = GetInset(i); -#ifdef HAVE_SSTREAM - std::ostringstream ost; - inset->DocBook(buffer, ost); - string tmp_out = ost.str().c_str(); -#else - ostrstream ost; - inset->DocBook(buffer, ost); - ost << '\0'; - char * ctmp = ost.str(); - string tmp_out(ctmp); - delete [] ctmp; -#endif - // - // This code needs some explanation: - // Two insets are treated specially - // label if it is the first element in a - // command paragraph - // desc_on == 3 - // graphics inside tables or figure floats - // can't go on - // title (the equivalente in latex for this - // case is caption - // and title should come first - // desc_on == 4 - // - if(desc_on != 3 || i != 0) { - if(tmp_out[0] == '@') { - if(desc_on == 4) - extra += frontStrip(tmp_out, - '@'); - else - os << frontStrip(tmp_out, - '@'); - } else - os << tmp_out; - } - } else if (font2.latex() == LyXFont::ON) { - // "TeX"-Mode on == > SGML-Mode on. - if (c != '\0') - os << c; - ++char_line_count; - } else { - string sgml_string; - if (linuxDocConvertChar(c, sgml_string) - && !style.free_spacing) { - // in freespacing mode, spaces are - // non-breaking characters - // char is ' ' - if (desc_on == 1) { - ++char_line_count; - os << '\n' - << ""; - desc_on = 2; - } else { - os << c; - } - } else { - os << sgml_string; - } - } - font1 = font2; - } - - // Needed if there is an optional argument but no contents. - if (main_body > 0 && main_body == size()) { - font1 = style.font; - } - - if (emph_flag) { - os << ""; - } - - ++current_cell_number; - tmp = table->DocBookEndOfCell(os, current_cell_number, depth); - // Resets description flag correctly. - switch(desc_on){ - case 1: - // not closed... - os << ""; - break; - } - if (footnoteflag == LyXParagraph::NO_FOOTNOTE) - os << ""; - os << '\n'; - lyxerr[Debug::LATEX] << "SimpleDocbookOneTablePar...done " - << this << endl; -} - - -void LyXParagraph::DocBookContTableRows(Buffer const * buffer, - ostream & os, string & extra, - int & desc_on, - LyXParagraph::size_type i, - int current_cell_number, int &column) - -{ - if (!table) return; - - BufferParams const & bparams = buffer->params; - - lyxerr[Debug::LATEX] << "DocBookContTableRows... " << this << endl; - - LyXFont font2; - char c; - Inset * inset; - //string emph = "emphasis"; - bool emph_flag = false; - int char_line_count = 0; - - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - GetLayout()); - - size_type main_body; - if (style.labeltype != LABEL_MANUAL) - main_body = 0; - else - main_body = BeginningOfMainBody(); - - // Gets paragraph main font. - LyXFont font1; - if (main_body > 0) - font1 = style.labelfont; - else - font1 = style.font; - - size_type lastpos = i; - int cell = table->CellHasContRow(current_cell_number); - ++current_cell_number; - while(cell >= 0) { - // first find the right position - i = lastpos; - for (; i < size() && current_cell_number < cell; ++i) { - c = GetChar(i); - if (c == LyXParagraph::META_NEWLINE) - ++current_cell_number; - } - lastpos = i; - c = GetChar(i); - // I don't know how to handle this so I comment it - // for the moment (Jug) -// if (table->Linebreaks(table->FirstVirtualCell(cell))) { -// file += " \\\\\n"; -// column = 0; -// } else - if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) { - os << ' '; - } - - for (; i < size() - && (c = GetChar(i)) != LyXParagraph::META_NEWLINE; - ++i) { - ++column; - - // Fully instantiated font - font2 = getFont(bparams, i); - - // Handle tag. - if (font1.emph() != font2.emph() && i) { - if (font2.emph() == LyXFont::ON) { - os << ""; - emph_flag= true; - } else if (emph_flag) { - os << ""; - emph_flag= false; - } - } - if (c == LyXParagraph::META_INSET) { - inset = GetInset(i); -#ifdef HAVE_SSTREAM - std::ostringstream ost; - inset->DocBook(buffer, ost); - string tmp_out = ost.str().c_str(); -#else - ostrstream ost; - inset->DocBook(buffer, ost); - ost << '\0'; - char * ctmp = ost.str(); - string tmp_out(ctmp); - delete [] ctmp; -#endif - // - // This code needs some explanation: - // Two insets are treated specially - // label if it is the first element in a - // command paragraph - // desc_on == 3 - // graphics inside tables or figure floats - // can't go on title (the equivalente in - // latex for this case is caption and title - // should come first - // desc_on == 4 - // - if(desc_on != 3 || i != 0) { - if(tmp_out[0] == '@') { - if(desc_on == 4) - extra += frontStrip(tmp_out, '@'); - else - os << frontStrip(tmp_out, '@'); - } else - os << tmp_out; - } - } else if (font2.latex() == LyXFont::ON) { - // "TeX"-Mode on == > SGML-Mode on. - if (c!= '\0') - os << c; - ++char_line_count; - } else { - string sgml_string; - if (linuxDocConvertChar(c, sgml_string) - && !style.free_spacing) { - // in freespacing mode, spaces are - // non-breaking characters - // char is ' ' - if (desc_on == 1) { - ++char_line_count; - os << '\n' - << ""; - desc_on = 2; - } else { - os << c; - } - } else { - os << sgml_string; - } - } - } - // we have only to control for emphasis open here! - if (emph_flag) { - os << ""; - emph_flag= false; - } - font1 = font2 = getFont(bparams, -1); - cell = table->CellHasContRow(current_cell_number); - } - lyxerr[Debug::LATEX] << "DocBookContTableRows...done " << this << endl; -} - - void LyXParagraph::SimpleTeXBlanks(ostream & os, TexRow & texrow, LyXParagraph::size_type const i, int & column, LyXFont const & font, @@ -3232,7 +2858,8 @@ void LyXParagraph::SimpleTeXSpecialChars(Buffer const * buf, bool & open_font, LyXLayout const & style, LyXParagraph::size_type & i, - int & column, char const c) + int & column, + LyXParagraph::value_type const c) { // Two major modes: LaTeX or plain // Handle here those cases common to both modes @@ -3242,7 +2869,7 @@ void LyXParagraph::SimpleTeXSpecialChars(Buffer const * buf, Inset * inset = GetInset(i); if (inset) { bool close = false; - int len = os.tellp(); + int const len = os.tellp(); if ((inset->LyxCode() == Inset::GRAPHICS_CODE || inset->LyxCode() == Inset::MATH_CODE || inset->LyxCode() == Inset::URL_CODE) @@ -3315,7 +2942,10 @@ void LyXParagraph::SimpleTeXSpecialChars(Buffer const * buf, case '°': case '±': case '²': case '³': case '×': case '÷': case '¹': case 'ª': case 'º': case '¬': case 'µ': - if (bparams.inputenc == "latin1") { + if (bparams.inputenc == "latin1" || + (bparams.inputenc == "auto" && + font.language()->encoding()->LatexName() + == "latin1")) { os << "\\ensuremath{" << c << '}'; @@ -3350,7 +2980,7 @@ void LyXParagraph::SimpleTeXSpecialChars(Buffer const * buf, } // Otherwise, we use what LaTeX // provides us. - switch(c) { + switch (c) { case '<': os << "\\textless{}"; column += 10; @@ -3482,31 +3112,46 @@ void LyXParagraph::SimpleTeXSpecialChars(Buffer const * buf, LyXParagraph * LyXParagraph::TeXDeeper(Buffer const * buf, BufferParams const & bparams, - ostream & os, TexRow & texrow, - ostream & foot, + ostream & os, TexRow & texrow +#ifndef NEW_INSETS + ,ostream & foot, TexRow & foot_texrow, - int & foot_count) + int & foot_count +#endif + ) { lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl; LyXParagraph * par = this; while (par && - (par->depth == depth) && - (par->footnoteflag == footnoteflag)) { + (par->depth == 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() || par->pextra_type != PEXTRA_NONE) { par = par->TeXEnvironment(buf, bparams, - os, texrow, - foot, foot_texrow, - foot_count); + os, texrow +#ifndef NEW_INSETS + ,foot, foot_texrow, + foot_count +#endif + ); } else { par = par->TeXOnePar(buf, bparams, - os, texrow, false, + os, texrow, false +#ifndef NEW_INSETS + , foot, foot_texrow, - foot_count); + foot_count +#endif + ); } } lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl; @@ -3517,21 +3162,28 @@ LyXParagraph * LyXParagraph::TeXDeeper(Buffer const * buf, LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, BufferParams const & bparams, - ostream & os, TexRow & texrow, - ostream & foot, + ostream & os, TexRow & texrow +#ifndef NEW_INSETS + ,ostream & foot, TexRow & foot_texrow, - int & foot_count) + int & foot_count +#endif + ) { bool eindent_open = false; +#ifndef NEW_INSETS bool foot_this_level = false; +#endif // 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; lyxerr[Debug::LATEX] << "TeXEnvironment... " << this << endl; +#ifndef NEW_INSETS if (IsDummy()) lyxerr << "ERROR (LyXParagraph::TeXEnvironment)" << endl; +#endif LyXLayout const & style = textclasslist.Style(bparams.textclass, @@ -3575,7 +3227,7 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, texrow.newline(); } os << "\\begin{minipage}"; - switch(pextra_alignment) { + switch (pextra_alignment) { case MINIPAGE_ALIGN_TOP: os << "[t]"; break; @@ -3637,7 +3289,7 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, } else if (style.labeltype == LABEL_BIBLIO) { // ale970405 os << "\\begin{" << style.latexname() << "}{" - << bibitemWidest(current_view->painter()) + << bibitemWidest(buf) << "}\n"; } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) { #ifdef FANCY_FOOTNOTE_CODE @@ -3658,8 +3310,12 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, LyXParagraph * par = this; do { par = par->TeXOnePar(buf, bparams, - os, texrow, false, - foot, foot_texrow, foot_count); + os, texrow, false +#ifndef NEW_INSETS + , + foot, foot_texrow, foot_count +#endif + ); if (minipage_open && par && !style.isEnvironment() && (par->pextra_type == PEXTRA_MINIPAGE) && @@ -3675,7 +3331,6 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, if (par && par->depth > depth) { if (textclasslist.Style(bparams.textclass, par->layout).isParagraph() - && !par->table // Thinko! // How to handle this? (Lgb) //&& !suffixIs(os, "\n\n") @@ -3693,8 +3348,11 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, os << '\n'; texrow.newline(); } - par = par->TeXDeeper(buf, bparams, os, texrow, - foot, foot_texrow, foot_count); + par = par->TeXDeeper(buf, bparams, os, texrow +#ifndef NEW_INSETS + ,foot, foot_texrow, foot_count +#endif + ); } if (par && par->layout == layout && par->depth == depth && (par->pextra_type == PEXTRA_MINIPAGE) && !minipage_open) { @@ -3708,7 +3366,7 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, texrow.newline(); } os << "\\begin{minipage}"; - switch(par->pextra_alignment) { + switch (par->pextra_alignment) { case MINIPAGE_ALIGN_TOP: os << "[t]"; break; @@ -3751,10 +3409,14 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, && par->layout == layout && par->depth == depth && par->pextra_type == pextra_type - && par->footnoteflag == footnoteflag); +#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) { @@ -3770,6 +3432,7 @@ LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, foot_count = 0; } } +#endif } if (minipage_open && (minipage_open_depth == depth) && (!par || par->pextra_start_minipage || @@ -3857,7 +3520,6 @@ LyXParagraph * LyXParagraph::TeXFootnote(Buffer const * buf, need_closing = true; } - //BufferParams * params = ¤t_view->buffer()->params; bool footer_in_body = true; switch (footnotekind) { case LyXParagraph::FOOTNOTE: @@ -3896,7 +3558,7 @@ LyXParagraph * LyXParagraph::TeXFootnote(Buffer const * buf, << pextra_width << "}\n"; else os << "\\begin{floatingfigure}{" - << atoi(pextra_widthp.c_str())/100.0 + << lyx::atoi(pextra_widthp) / 100.0 << "\\textwidth}\n"; } else { os << "\\begin{figure}"; @@ -3974,11 +3636,7 @@ LyXParagraph * LyXParagraph::TeXFootnote(Buffer const * buf, // process footnotes > depth 0 or in environments separately // NOTE: Currently don't support footnotes within footnotes // even though that is possible using the \footnotemark -#ifdef HAVE_SSTREAM std::ostringstream dummy; -#else - ostrstream dummy; -#endif TexRow dummy_texrow; int dummy_count = 0; do { @@ -4019,9 +3677,6 @@ LyXParagraph * LyXParagraph::TeXFootnote(Buffer const * buf, "Footnote in a Footnote -- not supported" << endl; } -#ifndef HAVE_OSTREAM - delete [] dummy.str(); -#endif } switch (footnotekind) { @@ -4085,8 +3740,8 @@ bool LyXParagraph::IsDummy() const #endif void LyXParagraph::SetPExtraType(BufferParams const & bparams, - int type, char const * width, - char const * widthp) + int type, string const & width, + string const & widthp) { pextra_type = type; pextra_width = width; @@ -4094,20 +3749,23 @@ void LyXParagraph::SetPExtraType(BufferParams const & bparams, if (textclasslist.Style(bparams.textclass, layout).isEnvironment()) { - LyXParagraph - * par = this, - * ppar = par; + LyXParagraph * par = this; + LyXParagraph * ppar = par; while (par && (par->layout == layout) && (par->depth == depth)) { ppar = par; par = par->Previous(); +#ifndef NEW_INSETS if (par) par = par->FirstPhysicalPar(); +#endif while (par && par->depth > depth) { par = par->Previous(); +#ifndef NEW_INSETS if (par) par = par->FirstPhysicalPar(); +#endif } } par = ppar; @@ -4116,12 +3774,21 @@ void LyXParagraph::SetPExtraType(BufferParams const & bparams, par->pextra_type = type; par->pextra_width = width; par->pextra_widthp = widthp; +#ifndef NEW_INSETS par = par->NextAfterFootnote(); +#else + par = par->Next(); +#endif if (par && (par->depth > depth)) par->SetPExtraType(bparams, type, width, widthp); +#ifndef NEW_INSETS while (par && ((par->depth > depth) || par->IsDummy())) par = par->NextAfterFootnote(); +#else + while (par && ((par->depth > depth))) + par = par->Next(); +#endif } } } @@ -4138,20 +3805,23 @@ void LyXParagraph::UnsetPExtraType(BufferParams const & bparams) if (textclasslist.Style(bparams.textclass, layout).isEnvironment()) { - LyXParagraph - * par = this, - * ppar = par; + LyXParagraph * par = this; + LyXParagraph * ppar = par; while (par && (par->layout == layout) && (par->depth == depth)) { ppar = par; par = par->Previous(); +#ifndef NEW_INSETS if (par) par = par->FirstPhysicalPar(); +#endif while (par && par->depth > depth) { par = par->Previous(); +#ifndef NEW_INSETS if (par) par = par->FirstPhysicalPar(); +#endif } } par = ppar; @@ -4160,11 +3830,20 @@ void LyXParagraph::UnsetPExtraType(BufferParams const & bparams) par->pextra_type = PEXTRA_NONE; par->pextra_width.erase(); par->pextra_widthp.erase(); +#ifndef NEW_INSETS par = par->NextAfterFootnote(); +#else + par = par->Next(); +#endif if (par && (par->depth > depth)) par->UnsetPExtraType(bparams); +#ifndef NEW_INSETS while (par && ((par->depth > depth) || par->IsDummy())) par = par->NextAfterFootnote(); +#else + while (par && ((par->depth > depth))) + par = par->Next(); +#endif } } } @@ -4182,10 +3861,12 @@ bool LyXParagraph::IsInset(size_type pos) const } +#ifndef NEW_INSETS bool LyXParagraph::IsFloat(size_type pos) const { return IsFloatChar(GetChar(pos)); } +#endif bool LyXParagraph::IsNewline(size_type pos) const @@ -4215,17 +3896,15 @@ bool LyXParagraph::IsKomma(size_type pos) const /// Used by the spellchecker bool LyXParagraph::IsLetter(LyXParagraph::size_type pos) const { - unsigned char c = GetChar(pos); + value_type const c = GetChar(pos); if (IsLetterChar(c)) return true; // '\0' is not a letter, allthough every string contains "" (below) - if( c == '\0') + if (c == '\0') return false; // We want to pass the ' and escape chars to ispell - string extra = lyxrc.isp_esc_chars + '\''; - char ch[2]; - ch[0] = c; - ch[1] = 0; + string const extra = lyxrc.isp_esc_chars + '\''; + char ch[2] = { c, 0 }; return contains(extra, ch); } @@ -4239,31 +3918,23 @@ bool LyXParagraph::IsWord(size_type pos ) const Language const * LyXParagraph::getParLanguage(BufferParams const & bparams) const { +#ifndef NEW_INSETS if (IsDummy()) return FirstPhysicalPar()->getParLanguage(bparams); - else if (size() > 0) -#ifndef NEW_TABULAR - if (!table) -#endif - return GetFirstFontSettings().language(); -#ifndef NEW_TABULAR - else { - for (size_type pos = 0; pos < size(); ++pos) - if (IsNewline(pos)) - return GetFontSettings(bparams, pos).language(); - return GetFirstFontSettings().language(); - } + else #endif + if (size() > 0) + return GetFirstFontSettings().language(); else if (previous) return previous->getParLanguage(bparams); else - return bparams.language_info; + return bparams.language; } bool LyXParagraph::isRightToLeftPar(BufferParams const & bparams) const { - return lyxrc.rtl_support && !table + return lyxrc.rtl_support && getParLanguage(bparams)->RightToLeft(); } @@ -4271,7 +3942,7 @@ bool LyXParagraph::isRightToLeftPar(BufferParams const & bparams) const void LyXParagraph::ChangeLanguage(BufferParams const & bparams, Language const * from, Language const * to) { - for(size_type i = 0; i < size(); ++i) { + for (size_type i = 0; i < size(); ++i) { LyXFont font = GetFontSettings(bparams, i); if (font.language() == from) { font.setLanguage(to); @@ -4283,42 +3954,38 @@ void LyXParagraph::ChangeLanguage(BufferParams const & bparams, bool LyXParagraph::isMultiLingual(BufferParams const & bparams) { - Language const * doc_language = - bparams.language_info; - for(size_type i = 0; i < size(); ++i) { - LyXFont font = GetFontSettings(bparams, i); - if (font.language() != doc_language) + 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; } // Convert the paragraph to a string. // Used for building the table of contents -string LyXParagraph::String(Buffer const * buffer, bool label) +string const LyXParagraph::String(Buffer const * buffer, bool label) { BufferParams const & bparams = buffer->params; string s; +#ifndef NEW_INSETS if (label && !IsDummy() && !labelstring.empty()) +#else + if (label && !labelstring.empty()) +#endif s += labelstring + ' '; - string::size_type len = s.size(); + string::size_type const len = s.size(); for (LyXParagraph::size_type i = 0; i < size(); ++i) { - unsigned char c = GetChar(i); + value_type c = GetChar(i); if (IsPrintable(c)) s += c; else if (c == META_INSET && GetInset(i)->LyxCode() == Inset::MATH_CODE) { -#ifdef HAVE_SSTREAM std::ostringstream ost; GetInset(i)->Ascii(buffer, ost); -#else - ostrstream ost; - GetInset(i)->Ascii(buffer, ost); - ost << '\0'; -#endif - s += subst(ost.str(),'\n',' '); + s += subst(ost.str().c_str(),'\n',' '); } } @@ -4327,72 +3994,46 @@ string LyXParagraph::String(Buffer const * buffer, bool label) && footnoteflag == LyXParagraph::NO_FOOTNOTE) s += NextAfterFootnote()->String(buffer, false); - if (!IsDummy()) + if (!IsDummy()) { #endif - { if (isRightToLeftPar(bparams)) reverse(s.begin() + len,s.end()); +#ifndef NEW_INSETS } +#endif return s; } -string LyXParagraph::String(Buffer const * buffer, +string const LyXParagraph::String(Buffer const * buffer, LyXParagraph::size_type beg, LyXParagraph::size_type end) { string s; - int actcell = 0; - int cell = 1; -#ifndef NEW_TABULAR - if (table) - for (LyXParagraph::size_type i = 0; i < beg; ++i) - if (IsNewline(i)) { - if (cell >= table->NumberOfCellsInRow(actcell)) - cell = 1; - else - ++cell; - ++actcell; - } -#endif - + +#ifndef NEW_INSETS if (beg == 0 && !IsDummy() && !labelstring.empty()) +#else + if (beg == 0 && !labelstring.empty()) +#endif s += labelstring + ' '; for (LyXParagraph::size_type i = beg; i < end; ++i) { - unsigned char c = GetChar(i); + value_type c = GetUChar(buffer->params, i); if (IsPrintable(c)) s += c; else if (c == META_INSET) { -#ifdef HAVE_SSTREAM std::ostringstream ost; GetInset(i)->Ascii(buffer, ost); -#else - ostrstream ost; - GetInset(i)->Ascii(buffer, ost); - ost << '\0'; -#endif - s += ost.str(); - } else if (table && IsNewlineChar(c)) { - if (cell >= table->NumberOfCellsInRow(actcell)) { - s += '\n'; - cell = 1; - } else { - s += ' '; - ++cell; - } - ++actcell; + s += ost.str().c_str(); } } - //if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) - // s += NextAfterFootnote()->String(false); - return s; } -void LyXParagraph::SetInsetOwner(Inset *i) +void LyXParagraph::SetInsetOwner(Inset * i) { inset_owner = i; for (InsetList::const_iterator cit = insetlist.begin(); @@ -4416,3 +4057,31 @@ void LyXParagraph::deleteInsetsLyXText(BufferView * bv) } } } + + +void LyXParagraph::resizeInsetsLyXText(BufferView * bv) +{ + // 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); + } + } + } +} + + +void LyXParagraph::fitToSize() +{ + TextContainer tmp(text.begin(), text.end()); + text.swap(tmp); +} + + +void LyXParagraph::setContentsFromPar(LyXParagraph * par) +{ + text = par->text; +}