X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=a17825476c65a166f6a23ddba048acc2e5826316;hb=bf6b9d1e189a13789308944d4d60f3ec994627b4;hp=2cc1a95b67abbe0d44b0ebc03bc5aa83cef11372;hpb=fa492d6bf09db7f1c278687e0000ad1c4833af3d;p=lyx.git diff --git a/src/paragraph.C b/src/paragraph.C index 2cc1a95b67..a17825476c 100644 --- a/src/paragraph.C +++ b/src/paragraph.C @@ -14,15 +14,16 @@ #pragma implementation "lyxparagraph.h" #endif +#include #include -using std::fstream; -using std::ios; +#include #include "lyxparagraph.h" #include "support/textutils.h" #include "lyxrc.h" #include "layout.h" #include "tex-strings.h" +#include "buffer.h" #include "bufferparams.h" #include "support/FileInfo.h" #include "support/LAssert.h" @@ -30,21 +31,27 @@ using std::ios; #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" +using std::ostream; +using std::endl; +using std::fstream; +using std::ios; +using std::lower_bound; +using std::upper_bound; +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 LyXRC * lyxrc; - -// ale970405 -extern string bibitemWidthest(Painter &); +extern string bibitemWidest(Buffer const *); // this is a minibuffer static char minibuffer_char; @@ -52,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; @@ -60,21 +69,19 @@ 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; itemdepth = 0; next = 0; previous = 0; +#ifndef NEW_INSETS footnoteflag = LyXParagraph::NO_FOOTNOTE; footnotekind = LyXParagraph::FOOTNOTE; // should not be needed - +#endif align = LYX_ALIGN_BLOCK; - /* table stuff -- begin*/ - table = 0; - /* table stuff -- end*/ + inset_owner = 0; id_ = paragraph_id++; bibkey = 0; // ale970302 Clear(); @@ -85,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; @@ -98,12 +105,11 @@ LyXParagraph::LyXParagraph(LyXParagraph * par) previous = par; previous->next = this; // end +#ifndef NEW_INSETS footnoteflag = LyXParagraph::NO_FOOTNOTE; footnotekind = LyXParagraph::FOOTNOTE; - - /* table stuff -- begin*/ - table = 0; - /* table stuff -- end*/ +#endif + inset_owner = 0; id_ = paragraph_id++; bibkey = 0; // ale970302 @@ -112,18 +118,19 @@ LyXParagraph::LyXParagraph(LyXParagraph * par) } -void LyXParagraph::writeFile(ostream & os, BufferParams const & params, +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; @@ -135,7 +142,7 @@ void LyXParagraph::writeFile(ostream & os, BufferParams const & params, os << "\n\\end_float "; } } - +#endif // The beginning or end of a deeper (i.e. nested) area? if (dth != depth) { if (depth > dth) { @@ -163,7 +170,10 @@ void LyXParagraph::writeFile(ostream & os, BufferParams const & params, if (added_space_bottom.kind() != VSpace::NONE) os << "\\added_space_bottom " << added_space_bottom.asLyXCommand() << " "; - + + // Maybe the paragraph has special spacing + spacing.writeFile(os, true); + // The labelwidth string used in lists. if (!labelwidthstring.empty()) os << "\\labelwidthstring " @@ -191,6 +201,7 @@ void LyXParagraph::writeFile(ostream & os, BufferParams const & params, // 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; @@ -220,25 +231,21 @@ void LyXParagraph::writeFile(ostream & os, BufferParams const & params, } os << '\n'; } +#ifndef NEW_INSETS } else { // Dummy layout. This means that a footnote ended. os << "\n\\end_float "; footflag = LyXParagraph::NO_FOOTNOTE; } - - // It might be a table. - if (table){ - os << "\\LyXTable\n"; - table->Write(os); - } +#endif // bibitem ale970302 if (bibkey) - bibkey->Write(os); + bibkey->Write(buf, os); - font1 = LyXFont(LyXFont::ALL_INHERIT); + LyXFont font1(LyXFont::ALL_INHERIT, params.language); - column = 0; + int column = 0; for (size_type i = 0; i < size(); ++i) { if (!i) { os << "\n"; @@ -246,14 +253,14 @@ void LyXParagraph::writeFile(ostream & os, BufferParams const & params, } // Write font changes - font2 = GetFontSettings(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: { @@ -263,10 +270,10 @@ void LyXParagraph::writeFile(ostream & os, BufferParams const & params, // international char, let it write // code directly so it's shorter in // the file - inset->Write(os); + inset->Write(buf, os); } else { os << "\n\\begin_inset "; - inset->Write(os); + inset->Write(buf, os); os << "\n\\end_inset \n\n"; column = 0; } @@ -280,12 +287,6 @@ void LyXParagraph::writeFile(ostream & os, BufferParams const & params, os << "\n\\hfill \n"; column = 0; break; -#if 0 - case META_PROTECTED_SEPARATOR: - os << "\n\\protected_separator \n"; - column = 0; - break; -#endif case '\\': os << "\n\\backslash \n"; column = 0; @@ -314,28 +315,36 @@ void LyXParagraph::writeFile(ostream & os, BufferParams const & params, break; } } - + // now write the next paragraph if (next) - next->writeFile(os, params, footflag, dth); + next->writeFile(buf, os, params, footflag, dth); } void LyXParagraph::validate(LaTeXFeatures & features) const { + BufferParams const & params = features.bufferParams(); + +#ifndef NEW_INSETS // this will be useful later LyXLayout const & layout = - textclasslist.Style(current_view->buffer()->params.textclass, + textclasslist.Style(params.textclass, GetLayout()); +#endif // check the params. if (line_top || line_bottom) features.lyxline = true; + if (!spacing.isDefault()) + features.setspace = true; // then the layouts features.layout[GetLayout()] = true; // then the fonts + Language const * doc_language = params.language; + for (FontList::const_iterator cit = fontlist.begin(); cit != fontlist.end(); ++cit) { if ((*cit).font.noun() == LyXFont::ON) { @@ -344,7 +353,7 @@ void LyXParagraph::validate(LaTeXFeatures & features) const << endl; features.noun = true; lyxerr[Debug::LATEX] << "Noun enabled. Font: " - << (*cit).font.stateText() + << (*cit).font.stateText(0) << endl; } switch ((*cit).font.color()) { @@ -355,9 +364,16 @@ void LyXParagraph::validate(LaTeXFeatures & features) const default: features.color = true; lyxerr[Debug::LATEX] << "Color enabled. Font: " - << (*cit).font.stateText() + << (*cit).font.stateText(0) << endl; } + + Language const * language = (*cit).font.language(); + if (language->babel() != doc_language->babel()) { + features.UsedLanguages.insert(language); + lyxerr[Debug::LATEX] << "Found language " + << language->babel() << endl; + } } // then the insets @@ -367,34 +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; - if ((current_view->buffer()->params.paragraph_separation == BufferParams::PARSEP_INDENT) && - (pextra_type == LyXParagraph::PEXTRA_MINIPAGE)) +#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(LyXParagraph::size_type pos) const +void LyXParagraph::CopyIntoMinibuffer(Buffer const & buffer, + LyXParagraph::size_type pos) const { + BufferParams bparams = buffer.params; + minibuffer_char = GetChar(pos); - minibuffer_font = GetFontSettings(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 = ' '; @@ -404,10 +423,11 @@ void LyXParagraph::CopyIntoMinibuffer(LyXParagraph::size_type pos) const } -void LyXParagraph::CutIntoMinibuffer(LyXParagraph::size_type pos) +void LyXParagraph::CutIntoMinibuffer(BufferParams const & bparams, + LyXParagraph::size_type pos) { minibuffer_char = GetChar(pos); - minibuffer_font = GetFontSettings(pos); + minibuffer_font = GetFontSettings(bparams, pos); minibuffer_inset = 0; if (minibuffer_char == LyXParagraph::META_INSET) { if (GetInset(pos)) { @@ -416,14 +436,13 @@ void LyXParagraph::CutIntoMinibuffer(LyXParagraph::size_type pos) // the inset, not just a clone. Otherwise // the inset would be deleted when calling Erase(pos) // find the entry - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - if ((*it).pos == pos) { - (*it).inset = 0; - break; - } - - } + 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 { minibuffer_inset = 0; minibuffer_char = ' '; @@ -436,12 +455,16 @@ void LyXParagraph::CutIntoMinibuffer(LyXParagraph::size_type pos) } -void LyXParagraph::InsertFromMinibuffer(LyXParagraph::size_type pos) +bool LyXParagraph::InsertFromMinibuffer(LyXParagraph::size_type pos) { - InsertChar(pos, minibuffer_char); - SetFont(pos, minibuffer_font); + if ((minibuffer_char == LyXParagraph::META_INSET) && + !InsertInsetAllowed(minibuffer_inset)) + return false; if (minibuffer_char == LyXParagraph::META_INSET) - InsertInset(pos, minibuffer_inset); + InsertInset(pos, minibuffer_inset, minibuffer_font); + else + InsertChar(pos, minibuffer_char, minibuffer_font); + return true; } // end of minibuffer @@ -458,20 +481,21 @@ void LyXParagraph::Clear() added_space_top = VSpace(VSpace::NONE); added_space_bottom = VSpace(VSpace::NONE); - + spacing.set(Spacing::Default); + align = LYX_ALIGN_LAYOUT; depth = 0; noindent = false; pextra_type = PEXTRA_NONE; - pextra_width.clear(); - pextra_widthp.clear(); + pextra_width.erase(); + pextra_widthp.erase(); pextra_alignment = MINIPAGE_ALIGN_TOP; pextra_hfill = false; pextra_start_minipage = false; - labelstring.clear(); - labelwidthstring.clear(); + labelstring.erase(); + labelwidthstring.erase(); layout = 0; bibkey = 0; @@ -492,17 +516,17 @@ LyXParagraph::~LyXParagraph() delete (*it).inset; } - /* table stuff -- begin*/ - delete table; - /* table stuff -- end*/ - // ale970302 delete bibkey; + // + //lyxerr << "LyXParagraph::paragraph_id = " + // << LyXParagraph::paragraph_id << endl; } 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()) { @@ -513,58 +537,88 @@ void LyXParagraph::Erase(LyXParagraph::size_type pos) "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 - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - if ((*it).pos == pos) { - delete (*it).inset; - insetlist.erase(it); - break; - } + 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. - for (FontList::iterator it = fontlist.begin(); - it != fontlist.end(); ++it) { - if (pos >= (*it).pos && pos <= (*it).pos_end) { - if ((*it).pos == (*it).pos_end) { - // If it is a multi-character font - // entry, we just make it smaller - // (see update below), otherwise we - // should delete it. - fontlist.erase(it); - break; - } + 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. - for (FontList::iterator it = fontlist.begin(); - it != fontlist.end(); ++it) { - if ((*it).pos > pos) - (*it).pos--; - if ((*it).pos_end >= pos) - (*it).pos_end--; - } + FontList::iterator fend = fontlist.end(); + for (; it != fend; ++it) + --(*it).pos; // Update the inset table. - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - if ((*it).pos > pos) - (*it).pos--; - } + 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 const f(LyXFont::ALL_INHERIT); + InsertChar(pos, c, f); +} + + +void LyXParagraph::InsertChar(LyXParagraph::size_type pos, + 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()) { @@ -577,80 +631,121 @@ void LyXParagraph::InsertChar(LyXParagraph::size_type pos, char c) "position does not exist." << endl; return; } +#else + Assert(pos <= size()); +#endif text.insert(text.begin() + pos, c); + // Update the font table. - for (FontList::iterator it = fontlist.begin(); - it != fontlist.end(); ++it) { - if ((*it).pos >= pos) - (*it).pos++; - if ((*it).pos_end >= pos) - (*it).pos_end++; - } + FontTable search_font(pos, LyXFont()); + for (FontList::iterator it = lower_bound(fontlist.begin(), + fontlist.end(), + search_font, matchFT()); + it != fontlist.end(); ++it) + ++(*it).pos; // Update the inset table. - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - if ((*it).pos >= pos) - (*it).pos++; - } + 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); } void LyXParagraph::InsertInset(LyXParagraph::size_type pos, Inset * inset) { + LyXFont const f(LyXFont::ALL_INHERIT); + InsertInset(pos, inset, f); +} + + +void LyXParagraph::InsertInset(LyXParagraph::size_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); - else + ->InsertInset(pos - text.size() - 1, + inset, font); + else lyxerr << "ERROR (LyXParagraph::InsertInset): " "position does not exist: " << pos << endl; return; } - if (text[pos] != LyXParagraph::META_INSET) { +#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 no LyXParagraph::META_INSET" << endl; - return; - } + "there is an inset in position: " << pos << endl; + else + insetlist.insert(it, InsetTable(pos, inset)); + if (inset_owner) + inset->setOwner(inset_owner); +} - if (inset) { - // Add a new entry in the inset table. - InsetList::iterator it = - insetlist.insert(insetlist.begin(), InsetTable()); - (*it).inset = inset; - (*it).pos = pos; - } + +bool LyXParagraph::InsertInsetAllowed(Inset * inset) +{ + //lyxerr << "LyXParagraph::InsertInsetAllowed" << endl; + + if (inset_owner) + return inset_owner->InsertInsetAllowed(inset); + return true; } Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos) { +#ifndef NEW_INSETS if (pos >= size()) { if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->GetInset(pos - text.size() - 1); - else { + else lyxerr << "ERROR (LyXParagraph::GetInset): " "position does not exist: " << pos << endl; - } + return 0; } +#else + Assert(pos < size()); +#endif // Find the inset. - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - if ((*it).pos == pos) { - return (*it).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; + lyxerr << "ERROR (LyXParagraph::GetInset): " "Inset does not exist: " << pos << endl; - text[pos] = ' '; // WHY!!! does this set the pos to ' '???? + //::raise(SIGSTOP); + + // text[pos] = ' '; // WHY!!! does this set the pos to ' '???? // Did this commenting out introduce a bug? So far I have not // see any, please enlighten me. (Lgb) // My guess is that since the inset does not exist, we might @@ -661,27 +756,33 @@ Inset * LyXParagraph::GetInset(LyXParagraph::size_type pos) Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const { +#ifndef NEW_INSETS if (pos >= size()) { if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->GetInset(pos - text.size() - 1); - else { + else lyxerr << "ERROR (LyXParagraph::GetInset): " "position does not exist: " << pos << endl; - } + return 0; } +#else + Assert(pos < size()); +#endif // Find the inset. - for (InsetList::const_iterator cit = insetlist.begin(); - cit != insetlist.end(); ++cit) { - if ((*cit).pos == pos) { - return (*cit).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; + lyxerr << "ERROR (LyXParagraph::GetInset): " "Inset does not exist: " << pos << endl; + //::raise(SIGSTOP); //text[pos] = ' '; // WHY!!! does this set the pos to ' '???? // Did this commenting out introduce a bug? So far I have not // see any, please enlighten me. (Lgb) @@ -693,23 +794,34 @@ Inset const * LyXParagraph::GetInset(LyXParagraph::size_type pos) const // Gets uninstantiated font setting at position. // Optimized after profiling. (Asger) -LyXFont LyXParagraph::GetFontSettings(LyXParagraph::size_type pos) const +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()) { - for (FontList::const_iterator cit = fontlist.begin(); - cit != fontlist.end(); ++cit) { - if (pos >= (*cit).pos && pos <= (*cit).pos_end) - return (*cit).font; - } +#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(pos - text.size() - 1); - else { + ->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? @@ -719,10 +831,33 @@ LyXFont LyXParagraph::GetFontSettings(LyXParagraph::size_type pos) const "position does not exist. " << pos << " (" << static_cast(pos) << ")" << endl; - } - } else if (pos) { - return GetFontSettings(pos - 1); + } else if (pos > 0) { + return GetFontSettings(bparams, pos - 1); + } +#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); +} + + +// Gets uninstantiated font setting at position 0 +LyXFont const LyXParagraph::GetFirstFontSettings() const +{ + if (size() > 0) { + if (!fontlist.empty()) + return fontlist[0].font; } + +#ifndef NEW_INSETS + else if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) + return NextAfterFootnote()->GetFirstFontSettings(); +#endif return LyXFont(LyXFont::ALL_INHERIT); } @@ -734,23 +869,24 @@ LyXFont LyXParagraph::GetFontSettings(LyXParagraph::size_type pos) 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(LyXParagraph::size_type pos) const +LyXFont const LyXParagraph::getFont(BufferParams const & bparams, + LyXParagraph::size_type pos) const { LyXFont tmpfont; LyXLayout const & layout = - textclasslist.Style(current_view->buffer()->params.textclass, + textclasslist.Style(bparams.textclass, GetLayout()); LyXParagraph::size_type main_body = 0; if (layout.labeltype == LABEL_MANUAL) main_body = BeginningOfMainBody(); - if (pos >= 0){ + if (pos >= 0) { LyXFont layoutfont; if (pos < main_body) layoutfont = layout.labelfont; else layoutfont = layout.font; - tmpfont = GetFontSettings(pos); + tmpfont = GetFontSettings(bparams, pos); tmpfont.realize(layoutfont); } else { // process layoutfont for pos == -1 and labelfont for pos < -1 @@ -758,8 +894,7 @@ LyXFont LyXParagraph::getFont(LyXParagraph::size_type pos) const tmpfont = layout.font; else tmpfont = layout.labelfont; - if (getParDirection() == LYX_DIR_RIGHT_TO_LEFT) - tmpfont.setDirection(LyXFont::RTL_DIR); + tmpfont.setLanguage(getParLanguage(bparams)); } // check for environment font information @@ -769,14 +904,14 @@ LyXFont LyXParagraph::getFont(LyXParagraph::size_type pos) const par = par->DepthHook(par_depth - 1); if (par) { tmpfont.realize(textclasslist. - Style(current_view->buffer()->params.textclass, + Style(bparams.textclass, par->GetLayout()).font); par_depth = par->GetDepth(); } } tmpfont.realize(textclasslist - .TextClass(current_view->buffer()->params.textclass) + .TextClass(bparams.textclass) .defaultfont()); return tmpfont; } @@ -788,38 +923,61 @@ LyXParagraph::HighestFontInRange(LyXParagraph::size_type startpos, LyXParagraph::size_type endpos) const { LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY; - for (FontList::const_iterator cit = fontlist.begin(); - cit != fontlist.end(); ++cit) { - if (startpos <= (*cit).pos_end && endpos >= (*cit).pos) { - LyXFont::FONT_SIZE size = (*cit).font.size(); - if (size > maxsize && size <= LyXFont::SIZE_HUGER) - maxsize = size; - } + 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()) + ++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(); + if (size > maxsize && size <= LyXFont::SIZE_HUGER) + maxsize = size; } return maxsize; } -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()) { if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) return NextAfterFootnote() ->GetChar(pos - text.size() - 1); - else { - lyxerr << "ERROR (LyXParagraph::GetChar): " + else + { + lyxerr << "ERROR (LyXParagraph::GetChar const): " "position does not exist." << pos << " (" << static_cast(pos) << ")\n"; - // Assert(false); // This triggers sometimes... - // Why? + Assert(false); } return '\0'; } else { @@ -847,62 +1005,55 @@ char LyXParagraph::GetChar(LyXParagraph::size_type pos) } return '\0'; // to shut up gcc } +#endif } -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()) { - 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 + 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; } + 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 @@ -945,18 +1096,24 @@ 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 if (next && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return text.size() + NextAfterFootnote()->Last() + 1; // the 1 is the symbol // for the footnote else +#endif return text.size(); } +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::ParFromPos(LyXParagraph::size_type pos) { // > because last is the next unused position, and you can @@ -966,15 +1123,17 @@ LyXParagraph * LyXParagraph::ParFromPos(LyXParagraph::size_type pos) && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->ParFromPos(pos - text.size() - 1); - else + 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 @@ -984,7 +1143,7 @@ int LyXParagraph::PositionInParFromPos(LyXParagraph::size_type pos) const && next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) return NextAfterFootnote() ->PositionInParFromPos(pos - text.size() - 1); - else + else lyxerr << "ERROR (LyXParagraph::PositionInParFromPos): " "position does not exist." << endl; @@ -993,11 +1152,13 @@ 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()) { @@ -1005,13 +1166,15 @@ void LyXParagraph::SetFont(LyXParagraph::size_type pos, next->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { NextAfterFootnote()->SetFont(pos - text.size() - 1, font); - } else { + } else lyxerr << "ERROR (LyXParagraph::SetFont): " "position does not exist." << endl; - } + return; } - LyXFont patternfont(LyXFont::ALL_INHERIT); +#else + Assert(pos <= size()); +#endif // First, reduce font against layout/label font // Update: The SetCharFont() routine in text2.C already @@ -1019,106 +1182,52 @@ void LyXParagraph::SetFont(LyXParagraph::size_type pos, // No need to simplify this because it will disappear // in a new kernel. (Asger) // Next search font table - FontList::iterator tmp = fontlist.begin(); - for (; tmp != fontlist.end(); ++tmp) { - if (pos >= (*tmp).pos && pos <= (*tmp).pos_end) { - break; - } - } - if (tmp == fontlist.end()) { // !found - // if we did not find a font entry, but if the font at hand - // is the same as default, we just forget it - if (font == patternfont) return; - // ok, we did not find a font entry. But maybe there is exactly - // the needed font ientry one position left - FontList::iterator tmp2 = fontlist.begin(); - for (; tmp2 != fontlist.end(); ++tmp2) { - if (pos - 1 >= (*tmp2).pos - && pos - 1 <= (*tmp2).pos_end) - break; - } - if (tmp2 != fontlist.end()) { - // ok there is one, maybe it is exactly - // the needed font - if ((*tmp2).font == font) { - // put the position under the font - (*tmp2).pos_end++; - return; - } - } - // Add a new entry in the - // fontlist for the position - FontTable ft; - ft.pos = pos; - ft.pos_end = pos; - ft.font = font; // or patternfont - // It seems that using font instead of patternfont here - // fixes all the problems. This also surfaces a "bug" in - // the old code. - fontlist.insert(fontlist.begin(), ft); - } else if ((*tmp).pos != (*tmp).pos_end) { // we found a font entry. maybe we have to split it and create a new one. - -// more than one character - if (pos == (*tmp).pos) { - // maybe we should enlarge the left fonttable - FontList::iterator tmp2 = fontlist.begin(); - for (; tmp2 != fontlist.end(); ++tmp2) { - if (pos - 1 >= (*tmp2).pos - && pos - 1 <= (*tmp2).pos_end) - break; - } - // Is there is one, and is it exactly - // the needed font? - if (tmp2 != fontlist.end() && - (*tmp2).font == font) { - // Put the position under the font - (*tmp2).pos_end++; - (*tmp).pos++; - return; - } + 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(); - // Add a new entry in the - // fontlist for the position - FontTable ft; - ft.pos = pos + 1; - ft.pos_end = (*tmp).pos_end; - ft.font = (*tmp).font; - (*tmp).pos_end = pos; - (*tmp).font = font; - fontlist.insert(fontlist.begin(), ft); - } else if (pos == (*tmp).pos_end) { - // Add a new entry in the - // fontlist for the position - FontTable ft; - ft.pos = (*tmp).pos; - ft.pos_end = (*tmp).pos_end - 1; - ft.font = (*tmp).font; - (*tmp).pos = (*tmp).pos_end; - (*tmp).font = font; - fontlist.insert(fontlist.begin(), ft); - } else { - // Add a new entry in the - // fontlist for the position - FontTable ft; - ft.pos = (*tmp).pos; - ft.pos_end = pos - 1; - ft.font = (*tmp).font; - - FontTable ft2; - ft2.pos = pos + 1; - ft2.pos_end = (*tmp).pos_end; - ft2.font = (*tmp).font; - - (*tmp).pos = pos; - (*tmp).pos_end = pos; - (*tmp).font = font; - - fontlist.insert(fontlist.begin(), ft); - fontlist.insert(fontlist.begin(), ft2); - } - } else { - (*tmp).font = font; + if (!notfound && fontlist[i].font == font) + return; + + bool begin = pos == 0 || notfound || + (i > 0 && fontlist[i-1].pos == pos - 1); + // Is position pos is a beginning of a font block? + 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) { + // 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) { + // Merge the singleton block with the previous block + 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; + 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, + 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)); } } @@ -1126,6 +1235,7 @@ void LyXParagraph::SetFont(LyXParagraph::size_type pos, // 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 @@ -1138,10 +1248,12 @@ LyXParagraph * LyXParagraph::Next() else return next; // This should never happen! } else +#endif return next; } +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::NextAfterFootnote() { if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) { @@ -1156,8 +1268,10 @@ LyXParagraph * LyXParagraph::NextAfterFootnote() } else return next; } +#endif +#ifndef NEW_INSETS LyXParagraph const * LyXParagraph::NextAfterFootnote() const { if (next && next->footnoteflag != LyXParagraph::NO_FOOTNOTE) { @@ -1172,13 +1286,15 @@ LyXParagraph const * LyXParagraph::NextAfterFootnote() const } else return next; } +#endif +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::PreviousBeforeFootnote() { LyXParagraph * tmp; if (previous && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE) { - tmp = next; + tmp = previous; while (tmp && tmp->footnoteflag != LyXParagraph::NO_FOOTNOTE) tmp = tmp->previous; if (tmp && tmp->footnoteflag != LyXParagraph::CLOSED_FOOTNOTE) @@ -1189,8 +1305,10 @@ LyXParagraph * LyXParagraph::PreviousBeforeFootnote() } else return previous; } +#endif +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::LastPhysicalPar() { if (footnoteflag != LyXParagraph::NO_FOOTNOTE) @@ -1202,10 +1320,27 @@ LyXParagraph * LyXParagraph::LastPhysicalPar() 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()) @@ -1222,8 +1357,10 @@ LyXParagraph * LyXParagraph::FirstPhysicalPar() } else return tmppar; } +#endif +#ifndef NEW_INSETS LyXParagraph const * LyXParagraph::FirstPhysicalPar() const { if (!IsDummy()) @@ -1240,15 +1377,17 @@ LyXParagraph const * LyXParagraph::FirstPhysicalPar() const } else return tmppar; } +#endif // This function is able to hide closed footnotes. LyXParagraph * LyXParagraph::Previous() { +#ifndef NEW_INSETS LyXParagraph * tmp = previous; if (!tmp) return tmp; - + if (tmp->previous && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { tmp = tmp->previous; @@ -1261,6 +1400,7 @@ LyXParagraph * LyXParagraph::Previous() else return previous; } else +#endif return previous; } @@ -1268,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; - if (tmp->previous && tmp->previous->footnoteflag == LyXParagraph::CLOSED_FOOTNOTE) { tmp = tmp->previous; @@ -1284,34 +1424,54 @@ LyXParagraph const * LyXParagraph::Previous() const else return previous; } else +#endif return previous; } -void LyXParagraph::BreakParagraph(LyXParagraph::size_type pos, +void LyXParagraph::BreakParagraph(BufferParams const & bparams, + LyXParagraph::size_type pos, int flag) { - size_type i, 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; tmp->footnotekind = footnotekind; - +#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(firstpar->layout); + 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(firstpar->layout); + tmp->SetOnlyLayout(bparams, firstpar->layout); tmp->align = firstpar->align; tmp->SetLabelWidthString(firstpar->labelwidthstring); @@ -1324,29 +1484,60 @@ void LyXParagraph::BreakParagraph(LyXParagraph::size_type pos, 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; - // The constructor has already reserved 500 elements - //if (pos_end > pos) - // tmp->text.reserve(pos_end - pos); - for (i = pos; i <= pos_end; ++i) { - par->CutIntoMinibuffer(i - pos_first); - tmp->InsertFromMinibuffer(i - pos); + + 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; @@ -1356,20 +1547,37 @@ void LyXParagraph::BreakParagraph(LyXParagraph::size_type pos, firstpar->Clear(); // layout stays the same with latex-environments if (flag) { - firstpar->SetOnlyLayout(tmp->layout); + firstpar->SetOnlyLayout(bparams, tmp->layout); firstpar->SetLabelWidthString(tmp->labelwidthstring); 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) { +#ifndef NEW_INSETS par = par->FirstPhysicalPar(); footnoteflag = par->footnoteflag; footnotekind = par->footnotekind; - +#endif layout = par->layout; align = par-> align; SetLabelWidthString(par->labelwidthstring); @@ -1382,6 +1590,8 @@ void LyXParagraph::MakeSameLayout(LyXParagraph const * par) pagebreak_top = par->pagebreak_top; added_space_top = par->added_space_top; + spacing = par->spacing; + pextra_type = par->pextra_type; pextra_width = par->pextra_width; pextra_widthp = par->pextra_widthp; @@ -1394,6 +1604,7 @@ void LyXParagraph::MakeSameLayout(LyXParagraph const * par) } +#ifndef NEW_INSETS LyXParagraph * LyXParagraph::FirstSelfrowPar() { LyXParagraph * tmppar = this; @@ -1409,6 +1620,28 @@ LyXParagraph * LyXParagraph::FirstSelfrowPar() else return tmppar; } +#endif + + +int LyXParagraph::StripLeadingSpaces(LyXTextClassList::size_type tclass) +{ + if (textclasslist.Style(tclass, GetLayout()).free_spacing) + return 0; + + int i = 0; +#ifndef NEW_INSETS + if (!IsDummy()) { +#endif + while (Last() + && (IsNewline(0) || IsLineSeparator(0))){ + Erase(0); + ++i; + } +#ifndef NEW_INSETS + } +#endif + return i; +} LyXParagraph * LyXParagraph::Clone() const @@ -1421,37 +1654,39 @@ LyXParagraph * LyXParagraph::Clone() const // this is because of the dummy layout of the paragraphs that // follow footnotes result->layout = layout; - - /* table stuff -- begin*/ - if (table) - result->table = table->Clone(); - else - result->table = 0; - /* table stuff -- end*/ + + 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 - - for (size_type i = 0; i < size(); ++i) { - CopyIntoMinibuffer(i); - result->InsertFromMinibuffer(i); - } - result->text.resize(result->text.size()); + + 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; } bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const { +#ifndef NEW_INSETS par = par->FirstPhysicalPar(); +#endif return ( +#ifndef NEW_INSETS par->footnoteflag == footnoteflag && par->footnotekind == footnotekind && - +#endif par->layout == layout && par->align == align && @@ -1464,22 +1699,23 @@ bool LyXParagraph::HasSameLayout(LyXParagraph const * par) const par->pagebreak_top == pagebreak_top && par->added_space_top == added_space_top && + par->spacing == spacing && + par->pextra_type == pextra_type && par->pextra_width == pextra_width && par->pextra_widthp == pextra_widthp && par->pextra_alignment == pextra_alignment && par->pextra_hfill == pextra_hfill && par->pextra_start_minipage == pextra_start_minipage && - - par->table == table && // what means: NO TABLE AT ALL - par->noindent == noindent && par->depth == depth); } -void LyXParagraph::BreakParagraphConservative(LyXParagraph::size_type pos) +void LyXParagraph::BreakParagraphConservative(BufferParams const & bparams, + LyXParagraph::size_type pos) { +#ifndef NEW_INSETS // create a new paragraph LyXParagraph * par = ParFromPos(pos); @@ -1496,56 +1732,93 @@ void LyXParagraph::BreakParagraphConservative(LyXParagraph::size_type pos) while (ParFromPos(pos_first) != par) ++pos_first; size_type pos_end = pos_first + par->text.size() - 1; - // make sure there is enough memory for the now larger - // paragraph. This is not neccessary, because - // InsertFromMinibuffer will enlarge the memory (it uses - // InsertChar of course). But doing it by hand - // is MUCH faster! (only one time, not thousend times!!) - // Not needed since the constructor aleady have - // reserved 500 elements in text. - //if (pos_end > pos) - // tmp->text.reserve(pos_end - pos); - - for (size_type i = pos; i <= pos_end; ++i) { - par->CutIntoMinibuffer(i - pos_first); - tmp->InsertFromMinibuffer(i - pos); - } - tmp->text.resize(tmp->text.size()); + + 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->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. -void LyXParagraph::PasteParagraph() +// 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(); // ok, now copy the paragraph - for (size_type i = 0; i <= pos_end; ++i) { - the_next->CutIntoMinibuffer(i); - InsertFromMinibuffer(pos_insert + i); + size_type i, j; + for (i = 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; delete the_next; + ppar->next = npar; } +#ifndef NEW_INSETS void LyXParagraph::OpenFootnote(LyXParagraph::size_type pos) { LyXParagraph * par = ParFromPos(pos); @@ -1566,43 +1839,108 @@ void LyXParagraph::CloseFootnote(LyXParagraph::size_type pos) par = par->next; } } +#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 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) + return endlabeltype; + + int next_depth = last->next->GetDepth(); + if (par_depth > next_depth || + (par_depth == next_depth && layout != last->next->GetLayout() )) + return endlabeltype; + break; + } + if (par_depth == 0) + break; + par = par->DepthHook(par_depth - 1); + if (par) + par_depth = par->GetDepth(); + } + return END_LABEL_NO_LABEL; +} 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::GetLabestring() 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!"); } @@ -1610,102 +1948,140 @@ 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(LyXTextClass::size_type new_layout) +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; - /* table stuff -- begin*/ - if (table) - par->layout = 0; - /* table stuff -- end*/ + 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(ppar->pextra_type, - p1.c_str(), p2.c_str()); + ppar->SetPExtraType(bparams, ppar->pextra_type, + p1, p2); } if ((par->pextra_type == PEXTRA_NONE) && npar && (npar->pextra_type != PEXTRA_NONE)) { - string - p1 = npar->pextra_width, - p2 = npar->pextra_widthp; - npar->SetPExtraType(npar->pextra_type, - p1.c_str(), p2.c_str()); + string const p1 = npar->pextra_width; + string const p2 = npar->pextra_widthp; + npar->SetPExtraType(bparams, npar->pextra_type, + p1, p2); } } } -void LyXParagraph::SetLayout(LyXTextClass::size_type new_layout) +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->labelwidthstring.clear(); + par->labelwidthstring.erase(); par->align = LYX_ALIGN_LAYOUT; par->added_space_top = VSpace(VSpace::NONE); par->added_space_bottom = VSpace(VSpace::NONE); - /* table stuff -- begin*/ - if (table) - par->layout = 0; - /* table stuff -- end*/ + par->spacing.set(Spacing::Default); + 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(ppar->pextra_type, - p1.c_str(), p2.c_str()); + string const p1 = ppar->pextra_width; + string const p2 = ppar->pextra_widthp; + ppar->SetPExtraType(bparams, ppar->pextra_type, + p1, p2); } if ((par->pextra_type == PEXTRA_NONE) && npar && (npar->pextra_type != PEXTRA_NONE)) { - string - p1 = npar->pextra_width, - p2 = npar->pextra_widthp; - npar->SetPExtraType(npar->pextra_type, - p1.c_str(), p2.c_str()); + string const p1 = npar->pextra_width; + string const p2 = npar->pextra_widthp; + npar->SetPExtraType(bparams, npar->pextra_type, + p1, p2); } } } @@ -1720,9 +2096,10 @@ void LyXParagraph::SetLayout(LyXTextClass::size_type new_layout) 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 @@ -1731,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 "==" @@ -1745,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; } @@ -1762,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()) @@ -1772,7 +2159,11 @@ LyXParagraph * LyXParagraph::DepthHook(int deth) "no hook." << endl; newpar = this; } +#ifndef NEW_INSETS return newpar->FirstPhysicalPar(); +#else + return newpar; +#endif } @@ -1783,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()) @@ -1793,44 +2191,39 @@ LyXParagraph const * LyXParagraph::DepthHook(int deth) const "no hook." << endl; newpar = this; } +#ifndef NEW_INSETS return newpar->FirstPhysicalPar(); +#else + return newpar; +#endif } int LyXParagraph::AutoDeleteInsets() { - vector tmpvec; - int i = 0; - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - if ((*it).inset && (*it).inset->AutoDelete()) { - tmpvec.push_back((*it).pos); - ++i; - } - } - for (vector::const_iterator cit = tmpvec.begin(); - cit != tmpvec.end(); ++cit) { - Erase((*cit)); + 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 i; + return count; } -Inset * LyXParagraph::ReturnNextInsetPointer(LyXParagraph::size_type & pos) +LyXParagraph::inset_iterator +LyXParagraph::InsetIterator(LyXParagraph::size_type pos) { - InsetList::iterator it2 = insetlist.end(); - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - if ((*it).pos >= pos) { - if (it2 == insetlist.end() || (*it).pos < (*it2).pos) - it2 = it; - } - } - if (it2 != insetlist.end()) { - pos = (*it2).pos; - return (*it2).inset; - } - return 0; + InsetTable search_inset(pos, 0); + InsetList::iterator it = lower_bound(insetlist.begin(), + insetlist.end(), + search_inset, matchIT()); + return inset_iterator(it); } @@ -1844,48 +2237,57 @@ int LyXParagraph::GetPositionOfInset(Inset * inset) const 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; } -void LyXParagraph::readSimpleWholeFile(istream & is) -{ - is.seekg(0); - char c = 0; - while(!is.eof()) { - is.get(c); - InsertChar(text.size(), c); - }; -} - - -LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, - ostream & foot, TexRow & foot_texrow, - int & foot_count) +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 + ) { lyxerr[Debug::LATEX] << "TeXOnePar... " << this << endl; - LyXParagraph * par = next; LyXLayout const & style = - textclasslist.Style(current_view->buffer()->params.textclass, + textclasslist.Style(bparams.textclass, 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"; texrow.newline(); } + if (!spacing.isDefault() + && (!Previous() || !Previous()->HasSameLayout(this))) { + os << spacing.writeEnvirBegin() << "\n"; + texrow.newline(); + } + if (tex_code_break_column && style.isCommand()){ os << '\n'; texrow.newline(); @@ -1896,12 +2298,12 @@ LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, further_blank_line = true; } if (added_space_top.kind() != VSpace::NONE) { - os << added_space_top.asLatexCommand(current_view->buffer()->params); + os << added_space_top.asLatexCommand(bparams); further_blank_line = true; } if (line_top) { - os << "\\lyxline{\\" << getFont(0).latexSize() << '}' + os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}' << "\\vspace{-1\\parskip}"; further_blank_line = true; } @@ -1911,18 +2313,26 @@ LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, texrow.newline(); } - LyXDirection direction = getParDirection(); - LyXDirection global_direction = - current_view->buffer()->params.getDocumentDirection(); - if (direction != global_direction) { - if (direction == LYX_DIR_LEFT_TO_RIGHT) - os << "\\unsethebrew\n"; - else - os << "\\sethebrew\n"; + 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(); } - + if (bparams.inputenc == "auto" && + language->encoding() != previous_language->encoding()) { + os << "\\inputencoding{" + << language->encoding()->LatexName() + << "}" << endl; + texrow.newline(); + } + switch (style.latextype) { case LATEX_COMMAND: os << '\\' @@ -1931,7 +2341,7 @@ LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, break; case LATEX_ITEM_ENVIRONMENT: if (bibkey) { - bibkey->Latex(os, false, false); + bibkey->Latex(buf, os, false, false); } else os << "\\item "; break; @@ -1942,48 +2352,88 @@ LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, break; } - bool need_par = SimpleTeXOnePar(os, texrow); + bool need_par = SimpleTeXOnePar(buf, bparams, os, texrow, moving_arg); + LyXParagraph * par = next; +#ifndef NEW_INSETS // Spit out footnotes - while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE - && par->footnoteflag != footnoteflag) { - par = par->TeXFootnote(os, texrow, - foot, foot_texrow, foot_count, - direction); - par->SimpleTeXOnePar(os, texrow); - par = par->next; + 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) // calculates the space between the baselines according // to this font. (Matthias) - LyXFont font = getFont(Last() - 1); - if (need_par) { - if (style.resfont.size() != font.size()) { - os << '\\' - << font.latexSize() - << ' '; - } + // + // 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); + 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(current_view->buffer()->params.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 (direction != global_direction) - if (direction == LYX_DIR_LEFT_TO_RIGHT) - os << "\\sethebrew"; - else - os << "\\unsethebrew"; + 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: @@ -2002,16 +2452,12 @@ LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, || par->pextra_type != pextra_type)) break; default: - if (!(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. + // 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(); } @@ -2019,12 +2465,12 @@ LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, further_blank_line = false; if (line_bottom) { - os << "\\lyxline{\\" << getFont(Last() - 1).latexSize() << '}'; + os << "\\lyxline{\\" << getFont(bparams, Last() - 1).latexSize() << '}'; further_blank_line = true; } if (added_space_bottom.kind() != VSpace::NONE) { - os << added_space_bottom.asLatexCommand(current_view->buffer()->params); + os << added_space_bottom.asLatexCommand(bparams); further_blank_line = true; } @@ -2038,8 +2484,19 @@ LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, texrow.newline(); } - if (!(footnoteflag != LyXParagraph::NO_FOOTNOTE && par && - par->footnoteflag == LyXParagraph::NO_FOOTNOTE)) { + if (!spacing.isDefault() + && (!par || !par->HasSameLayout(this))) { + os << 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 + ) { os << '\n'; texrow.newline(); } @@ -2050,17 +2507,17 @@ LyXParagraph * LyXParagraph::TeXOnePar(ostream & os, TexRow & texrow, // This one spits out the text of the paragraph -bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) +bool LyXParagraph::SimpleTeXOnePar(Buffer const * buf, + BufferParams const & bparams, + ostream & os, TexRow & texrow, + bool moving_arg) { lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl; - if (table) - return SimpleTeXOneTablePar(os, texrow); - bool return_value = false; LyXLayout const & style = - textclasslist.Style(current_view->buffer()->params.textclass, + textclasslist.Style(bparams.textclass, GetLayout()); LyXFont basefont, last_font; @@ -2073,16 +2530,19 @@ bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) if (main_body > 0) { os << '['; - basefont = getFont(-2); // Get label font + basefont = getFont(bparams, -2); // Get label font } else { - basefont = getFont(-1); // Get layout font + basefont = getFont(bparams, -1); // Get layout font } int column = 0; if (main_body >= 0 && !text.size() - && !IsDummy()) { +#ifndef NEW_INSETS + && !IsDummy() +#endif + ) { if (style.isCommand()) { os << '{'; ++column; @@ -2092,6 +2552,8 @@ bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) return_value = true; } } + + moving_arg |= style.needprotect; // Which font is currently active? LyXFont running_font(basefont); @@ -2103,13 +2565,17 @@ bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) 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); open_font = false; } - basefont = getFont(-1); // Now use the layout font + basefont = getFont(bparams, -1); // Now use the layout font running_font = basefont; os << ']'; ++column; @@ -2117,9 +2583,11 @@ bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) 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; } @@ -2131,35 +2599,61 @@ bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) case LYX_ALIGN_NONE: case LYX_ALIGN_BLOCK: case LYX_ALIGN_LAYOUT: - case LYX_ALIGN_SPECIAL: break; + case LYX_ALIGN_SPECIAL: + break; case LYX_ALIGN_LEFT: - os << "\\raggedright "; - column+= 13; + if (moving_arg) + os << "\\protect"; + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\raggedright "; + column+= 13; + } else { + os << "\\raggedleft "; + column+= 12; + } break; case LYX_ALIGN_RIGHT: - os << "\\raggedleft "; - column+= 12; + if (moving_arg) + os << "\\protect"; + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\raggedleft "; + column+= 12; + } else { + os << "\\raggedright "; + column+= 13; + } 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(i); - last_font = running_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; // 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(i+1).equalExceptLatex(running_font) - && !getFont(i+1).equalExceptLatex(font)) { - font = getFont(i + 1); + && !getFont(bparams, i + 1).equalExceptLatex(running_font) + && !getFont(bparams, i + 1).equalExceptLatex(font)) { + font = getFont(bparams, i + 1); } // We end font definition before blanks if (!font.equalExceptLatex(running_font) && open_font) { @@ -2171,7 +2665,7 @@ bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) } // Blanks are printed before start of fontswitch - if (c == ' '){ + if (c == ' ') { // Do not print the separation of the optional argument if (i != main_body - 1) { SimpleTeXBlanks(os, texrow, i, @@ -2199,186 +2693,22 @@ bool LyXParagraph::SimpleTeXOnePar(ostream & os, TexRow & texrow) column += running_font.latexWriteEndChanges(os, basefont, basefont); open_font = false; } - basefont = getFont(-1); + 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(os, texrow, - 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); - } - - // 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(ostream & os, TexRow & texrow) -{ - lyxerr[Debug::LATEX] << "SimpleTeXOneTablePar... " << this << endl; - - bool return_value = false; - - LyXLayout const & style = - textclasslist.Style(current_view->buffer()->params.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(-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); - - 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; - - // Fully instantiated font - LyXFont font = getFont(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(i + 1) != running_font - && getFont(i + 1) != font) { - font = getFont(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(-1); - running_font = basefont; - ++current_cell_number; - if (table->CellHasContRow(current_cell_number) >= 0) { - TeXContTableRows(os, i + 1, - current_cell_number, - column, texrow); - } - // 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(os, texrow, + SimpleTeXSpecialChars(buf, bparams, + os, texrow, moving_arg, font, running_font, basefont, open_font, style, i, column, c); } @@ -2386,123 +2716,28 @@ bool LyXParagraph::SimpleTeXOneTablePar(ostream & os, TexRow & texrow) // If we have an open font definition, we have to close it if (open_font) { - running_font.latexWriteEndChanges(os, basefont, basefont); + 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, + p->getFont(bparams, 0)); + else + running_font.latexWriteEndChanges(os, basefont, basefont); } - ++current_cell_number; - 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(ostream & os, - LyXParagraph::size_type i, - int current_cell_number, - int & column, TexRow & texrow) -{ - lyxerr[Debug::LATEX] << "TeXContTableRows... " << this << endl; - if (!table) - return false; - - char c; - - bool return_value = false; - LyXLayout const & style = - textclasslist.Style(current_view->buffer()->params.textclass, - GetLayout()); - LyXFont basefont = getFont(-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; - 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(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(i + 1) != running_font - && getFont(i + 1) != font) { - font = getFont(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; - } - } - SimpleTeXSpecialChars(os, texrow, 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); - open_font = false; - } - basefont = getFont(-1); - running_font = basefont; - cell = table->CellHasContRow(current_cell_number); + // 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; } @@ -2512,13 +2747,8 @@ bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string) bool retval = false; switch (c) { case LyXParagraph::META_HFILL: - sgml_string.clear(); - break; -#if 0 - case LyXParagraph::META_PROTECTED_SEPARATOR: - sgml_string = ' '; + sgml_string.erase(); break; -#endif case LyXParagraph::META_NEWLINE: sgml_string = '\n'; break; @@ -2566,7 +2796,7 @@ bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string) sgml_string = ' '; break; case '\0': // Ignore :-) - sgml_string.clear(); + sgml_string.erase(); break; default: sgml_string = c; @@ -2576,329 +2806,6 @@ bool LyXParagraph::linuxDocConvertChar(char c, string & sgml_string) } -void LyXParagraph::SimpleDocBookOneTablePar(ostream & os, string & extra, - int & desc_on, int depth) -{ - 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(current_view->buffer()->params.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(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(-1); - ++current_cell_number; - if (table->CellHasContRow(current_cell_number) >= 0) { - DocBookContTableRows(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 - ostringstream ost; - inset->DocBook(ost); - string tmp_out = ost.str().c_str(); -#else - ostrstream ost; - inset->DocBook(ost); - ost << '\0'; - char * ctmp = ost.str(); - string tmp_out(ctmp); - delete [] ctmp; -#endif - // - // This code needs some explanation: - // Two insets are treated specially - // label if it is the first element in a - // command paragraph - // desc_on == 3 - // graphics inside tables or figure floats - // can't go on - // title (the equivalente in latex for this - // case is caption - // and title should come first - // desc_on == 4 - // - if(desc_on != 3 || i != 0) { - if(tmp_out[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(ostream & os, string & extra, - int & desc_on, - LyXParagraph::size_type i, - int current_cell_number, int &column) - -{ - if (!table) return; - - 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(current_view->buffer()->params.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(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 - ostringstream ost; - inset->DocBook(ost); - string tmp_out = ost.str().c_str(); -#else - ostrstream ost; - inset->DocBook(ost); - ost << '\0'; - char * ctmp = ost.str(); - string tmp_out(ctmp); - delete [] ctmp; -#endif - // - // This code needs some explanation: - // Two insets are treated specially - // label if it is the first element in a - // command paragraph - // desc_on == 3 - // graphics inside tables or figure floats - // can't go on title (the equivalente in - // latex for this case is caption and title - // should come first - // desc_on == 4 - // - if(desc_on != 3 || i != 0) { - if(tmp_out[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(-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, @@ -2941,14 +2848,18 @@ void LyXParagraph::SimpleTeXBlanks(ostream & os, TexRow & texrow, } -void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, +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, char const c) + int & column, + LyXParagraph::value_type const c) { // Two major modes: LaTeX or plain // Handle here those cases common to both modes @@ -2958,22 +2869,21 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, 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) - && running_font.getFontDirection() - == LYX_DIR_RIGHT_TO_LEFT) { + && running_font.isRightToLeft()) { os << "\\L{"; close = true; } - int tmp = inset->Latex(os, style.isCommand(), + int tmp = inset->Latex(buf, os, moving_arg, style.free_spacing); if (close) os << "}"; - + if (tmp) { column = 0; } else { @@ -2993,7 +2903,7 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, basefont); open_font = false; } - basefont = getFont(-1); + basefont = getFont(bparams, -1); running_font = basefont; break; @@ -3010,11 +2920,6 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, // but I'll leave it as a switch statement // so its simpler to extend. (ARRae) switch (c) { -#if 0 - case LyXParagraph::META_PROTECTED_SEPARATOR: - os << ' '; - break; -#endif default: // make sure that we will not print // error generating chars to the tex @@ -3029,11 +2934,6 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, } else { // Plain mode (i.e. not LaTeX) switch (c) { -#if 0 - case LyXParagraph::META_PROTECTED_SEPARATOR: - os << '~'; - break; -#endif case '\\': os << "\\textbackslash{}"; column += 15; @@ -3042,7 +2942,10 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, case '°': case '±': case '²': case '³': case '×': case '÷': case '¹': case 'ª': case 'º': case '¬': case 'µ': - if (current_view->buffer()->params.inputenc == "latin1") { + if (bparams.inputenc == "latin1" || + (bparams.inputenc == "auto" && + font.language()->encoding()->LatexName() + == "latin1")) { os << "\\ensuremath{" << c << '}'; @@ -3054,13 +2957,18 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, case '|': case '<': case '>': // In T1 encoding, these characters exist - if (lyxrc->fontenc == "T1") { + if (lyxrc.fontenc == "T1") { os << c; //... but we should avoid ligatures if ((c == '>' || c == '<') && i <= size() - 2 - && GetChar(i + 1) == c){ - os << "\\textcompwordmark{}"; + && GetChar(i + 1) == c) { + //os << "\\textcompwordmark{}"; + // Jean-Marc, have a look at + // this. I think this works + // equally well: + os << "\\,{}"; + // Lgb column += 19; } break; @@ -3072,7 +2980,7 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, } // Otherwise, we use what LaTeX // provides us. - switch(c) { + switch (c) { case '<': os << "\\textless{}"; column += 10; @@ -3105,7 +3013,7 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, break; case '£': - if (current_view->buffer()->params.inputenc == "default") { + if (bparams.inputenc == "default") { os << "\\pounds{}"; column += 8; } else { @@ -3202,145 +3110,48 @@ void LyXParagraph::SimpleTeXSpecialChars(ostream & os, TexRow & texrow, } -#if 0 -bool LyXParagraph::RoffContTableRows(ostream & os, - LyXParagraph::size_type i, - int actcell) -{ - if (!table) - return false; - - LyXFont font1(LyXFont::ALL_INHERIT); - LyXFont font2; - Inset * inset; - char c; - - string fname2 = TmpFileName(string(), "RAT2"); - int lastpos = i; - int cell = table->CellHasContRow(actcell); - ++actcell; - while(cell >= 0) { - // first find the right position - i = lastpos; - for (; i < size() && actcell < cell; ++i) { - c = GetChar(i); - if (c == LyXParagraph::META_NEWLINE) - ++actcell; - } - lastpos = i; - c = GetChar(i); - if ((c != ' ') && (c != LyXParagraph::META_NEWLINE)) - os << " "; - for (; i < size() - && (c = GetChar(i)) != LyXParagraph::META_NEWLINE; - ++i) { - font2 = GetFontSettings(i); - if (font1.latex() != font2.latex()) { - if (font2.latex() != LyXFont::OFF) - continue; - } - c = GetChar(i); - switch (c) { - case LyXParagraph::META_INSET: - if ((inset = GetInset(i))) { -#if 1 -#ifdef HAVE_SSTREAM - stringstream ss(ios::in | ios::out); - inset->Latex(ss, -1); - ss.seekp(0); - ss.get(c); - while (!ss) { - if (c == '\\') - os << "\\\\"; - else - os << c; - ss.get(c); - } -#else - strstream ss; - inset->Latex(ss, -1); - ss.seekp(0); - ss.get(c); - while (!ss) { - if (c == '\\') - os << "\\\\"; - else - os << c; - ss.get(c); - } - delete [] ss.str(); -#endif -#else - fstream fs(fname2.c_str(), - ios::in|ios::out); - if (!fs) { - WriteAlert(_("LYX_ERROR:"), - _("Cannot open temporary file:"), - fname2); - return false; - } - inset->Latex(fs, -1); - fs.seekp(0); - fs.get(c); - while (!fs) { - if (c == '\\') - os << "\\\\"; - else - os << c; - fs.get(c); - } - fs.close(); -#endif - } - break; - case LyXParagraph::META_NEWLINE: - break; - case LyXParagraph::META_HFILL: - break; -#if 0 - case LyXParagraph::META_PROTECTED_SEPARATOR: - break; -#endif - case '\\': - os << "\\\\"; - break; - default: - if (c != '\0') - os << c; - else - lyxerr.debug() << "RoffAsciiTable: " - "NULL char in structure." - << endl; - break; - } - } - cell = table->CellHasContRow(actcell); - } - return true; -} +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 - - -LyXParagraph * LyXParagraph::TeXDeeper(ostream & os, TexRow & texrow, - ostream & foot, TexRow & foot_texrow, - int & foot_count) + ) { lyxerr[Debug::LATEX] << "TeXDeeper... " << this << endl; LyXParagraph * par = this; - while (par && par->depth == depth) { + while (par && + (par->depth == depth) +#ifndef NEW_INSETS + && (par->footnoteflag == footnoteflag) +#endif + ) { +#ifndef NEW_INSETS if (par->IsDummy()) lyxerr << "ERROR (LyXParagraph::TeXDeeper)" << endl; - if (textclasslist.Style(current_view->buffer()->params.textclass, +#endif + if (textclasslist.Style(bparams.textclass, par->layout).isEnvironment() || par->pextra_type != PEXTRA_NONE) { - par = par->TeXEnvironment(os, texrow, - foot, foot_texrow, - foot_count); + par = par->TeXEnvironment(buf, bparams, + os, texrow +#ifndef NEW_INSETS + ,foot, foot_texrow, + foot_count +#endif + ); } else { - par = par->TeXOnePar(os, texrow, + par = par->TeXOnePar(buf, bparams, + os, texrow, false +#ifndef NEW_INSETS + , foot, foot_texrow, - foot_count); + foot_count +#endif + ); } } lyxerr[Debug::LATEX] << "TeXDeeper...done " << par << endl; @@ -3349,24 +3160,33 @@ LyXParagraph * LyXParagraph::TeXDeeper(ostream & os, TexRow & texrow, } -LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, - ostream & foot, +LyXParagraph * LyXParagraph::TeXEnvironment(Buffer const * buf, + BufferParams const & bparams, + 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 = current_view->buffer()->params.paragraph_separation; + 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(current_view->buffer()->params.textclass, + textclasslist.Style(bparams.textclass, layout); if (pextra_type == PEXTRA_INDENT) { @@ -3407,7 +3227,7 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, texrow.newline(); } os << "\\begin{minipage}"; - switch(pextra_alignment) { + switch (pextra_alignment) { case MINIPAGE_ALIGN_TOP: os << "[t]"; break; @@ -3469,7 +3289,7 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, } else if (style.labeltype == LABEL_BIBLIO) { // ale970405 os << "\\begin{" << style.latexname() << "}{" - << bibitemWidthest(current_view->painter()) + << bibitemWidest(buf) << "}\n"; } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) { #ifdef FANCY_FOOTNOTE_CODE @@ -3489,8 +3309,13 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, } LyXParagraph * par = this; do { - par = par->TeXOnePar(os, texrow, - foot, foot_texrow, foot_count); + par = par->TeXOnePar(buf, bparams, + os, texrow, false +#ifndef NEW_INSETS + , + foot, foot_texrow, foot_count +#endif + ); if (minipage_open && par && !style.isEnvironment() && (par->pextra_type == PEXTRA_MINIPAGE) && @@ -3504,9 +3329,8 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, minipage_open = false; } if (par && par->depth > depth) { - if (textclasslist.Style(current_view->buffer()->params.textclass, + if (textclasslist.Style(bparams.textclass, par->layout).isParagraph() - && !par->table // Thinko! // How to handle this? (Lgb) //&& !suffixIs(os, "\n\n") @@ -3524,8 +3348,11 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, os << '\n'; texrow.newline(); } - par = par->TeXDeeper(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) { @@ -3539,7 +3366,7 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, texrow.newline(); } os << "\\begin{minipage}"; - switch(par->pextra_alignment) { + switch (par->pextra_alignment) { case MINIPAGE_ALIGN_TOP: os << "[t]"; break; @@ -3581,10 +3408,15 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, } while (par && par->layout == layout && par->depth == depth - && par->pextra_type == pextra_type); + && par->pextra_type == pextra_type +#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) { @@ -3600,6 +3432,7 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, foot_count = 0; } } +#endif } if (minipage_open && (minipage_open_depth == depth) && (!par || par->pextra_start_minipage || @@ -3631,10 +3464,13 @@ LyXParagraph * LyXParagraph::TeXEnvironment(ostream & os, TexRow & texrow, } -LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, +#ifndef NEW_INSETS +LyXParagraph * LyXParagraph::TeXFootnote(Buffer const * buf, + BufferParams const & bparams, + ostream & os, TexRow & texrow, ostream & foot, TexRow & foot_texrow, int & foot_count, - LyXDirection par_direction) + bool parent_is_rtl) { lyxerr[Debug::LATEX] << "TeXFootnote... " << this << endl; if (footnoteflag == LyXParagraph::NO_FOOTNOTE) @@ -3643,7 +3479,7 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, LyXParagraph * par = this; LyXLayout const & style = - textclasslist.Style(current_view->buffer()->params.textclass, + textclasslist.Style(bparams.textclass, previous->GetLayout()); if (style.needprotect && footnotekind != LyXParagraph::FOOTNOTE){ @@ -3671,14 +3507,26 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, os << '\n'; texrow.newline(); } + + bool moving_arg = false; + bool need_closing = false; + bool is_rtl = isRightToLeftPar(bparams); + + if (is_rtl != parent_is_rtl) { + if (is_rtl) + os << "\\R{"; + else + os << "\\L{"; + need_closing = true; + } - BufferParams * params = ¤t_view->buffer()->params; 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: @@ -3710,12 +3558,12 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, << 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}"; - if (!params->float_placement.empty()) { - os << '[' << params->float_placement << "]\n"; + if (!bparams.float_placement.empty()) { + os << '[' << bparams.float_placement << "]\n"; } else { os << '\n'; } @@ -3723,24 +3571,24 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, break; case LyXParagraph::TAB: os << "\\begin{table}"; - if (!params->float_placement.empty()) { - os << '[' << params->float_placement << "]\n"; + if (!bparams.float_placement.empty()) { + os << '[' << bparams.float_placement << "]\n"; } else { os << '\n'; } break; case LyXParagraph::WIDE_FIG: os << "\\begin{figure*}"; - if (!params->float_placement.empty()) { - os << '[' << params->float_placement << "]\n"; + if (!bparams.float_placement.empty()) { + os << '[' << bparams.float_placement << "]\n"; } else { os << '\n'; } break; case LyXParagraph::WIDE_TAB: os << "\\begin{table*}"; - if (!params->float_placement.empty()) { - os << '[' << params->float_placement << "]\n"; + if (!bparams.float_placement.empty()) { + os << '[' << bparams.float_placement << "]\n"; } else { os << '\n'; } @@ -3751,25 +3599,13 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, } texrow.newline(); - - LyXDirection direction = getParDirection(); - if (direction != par_direction) { - if (direction == LYX_DIR_LEFT_TO_RIGHT) - os << "\\unsethebrew\n"; - else - os << "\\sethebrew\n"; - texrow.newline(); - } - - if (footnotekind != LyXParagraph::FOOTNOTE + if (footnotekind != LyXParagraph::FOOTNOTE || !footer_in_body) { // Process text for all floats except footnotes in body do { LyXLayout const & style = textclasslist - .Style(current_view->buffer()->params - .textclass, - par->layout); + .Style(bparams.textclass, par->layout); if (par->IsDummy()) lyxerr << "ERROR (LyXParagraph::TeXFootnote)" << endl; @@ -3779,17 +3615,19 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, // environments. Shouldn't be circular because // we don't support footnotes inside // floats (yet). ARRae - par = par->TeXEnvironment(os, texrow, + par = par->TeXEnvironment(buf, bparams, os, + texrow, foot, foot_texrow, foot_count); } else { - par = par->TeXOnePar(os, texrow, + par = par->TeXOnePar(buf, bparams, + os, texrow, moving_arg, foot, foot_texrow, foot_count); } if (par && !par->IsDummy() && par->depth > depth) { - par = par->TeXDeeper(os, texrow, + par = par->TeXDeeper(buf, bparams, os, texrow, foot, foot_texrow, foot_count); } @@ -3798,19 +3636,13 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, // 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 - ostringstream dummy; -#else - ostrstream dummy; -#endif + std::ostringstream dummy; TexRow dummy_texrow; int dummy_count = 0; do { LyXLayout const & style = textclasslist - .Style(current_view->buffer()->params - .textclass, - par->layout); + .Style(bparams.textclass, par->layout); if (par->IsDummy()) lyxerr << "ERROR (LyXParagraph::TeXFootnote)" << endl; @@ -3820,17 +3652,21 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, // environments. Shouldn't be circular because // we don't support footnotes inside // floats (yet). ARRae - par = par->TeXEnvironment(foot, foot_texrow, + par = par->TeXEnvironment(buf, bparams, + foot, foot_texrow, dummy, dummy_texrow, dummy_count); } else { - par = par->TeXOnePar(foot, foot_texrow, + par = par->TeXOnePar(buf, bparams, + foot, foot_texrow, + moving_arg, dummy, dummy_texrow, dummy_count); } if (par && !par->IsDummy() && par->depth > depth) { - par = par->TeXDeeper(foot, foot_texrow, + par = par->TeXDeeper(buf, bparams, + foot, foot_texrow, dummy, dummy_texrow, dummy_count); } @@ -3841,9 +3677,6 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, "Footnote in a Footnote -- not supported" << endl; } -#ifndef HAVE_OSTREAM - delete [] dummy.str(); -#endif } switch (footnotekind) { @@ -3882,6 +3715,9 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, break; } + if (need_closing) + os << "}"; + if (footnotekind != LyXParagraph::FOOTNOTE && footnotekind != LyXParagraph::MARGIN) { // we need to ensure that real floats like tables and figures @@ -3896,29 +3732,40 @@ LyXParagraph * LyXParagraph::TeXFootnote(ostream & os, TexRow & texrow, } -void LyXParagraph::SetPExtraType(int type, char const * width, - char const * widthp) +bool LyXParagraph::IsDummy() const +{ + return (footnoteflag == LyXParagraph::NO_FOOTNOTE && previous + && previous->footnoteflag != LyXParagraph::NO_FOOTNOTE); +} +#endif + +void LyXParagraph::SetPExtraType(BufferParams const & bparams, + int type, string const & width, + string const & widthp) { pextra_type = type; pextra_width = width; pextra_widthp = widthp; - if (textclasslist.Style(current_view->buffer()->params.textclass, + 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; @@ -3927,54 +3774,76 @@ void LyXParagraph::SetPExtraType(int type, char const * width, 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(type, width, widthp); + 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 } } } -void LyXParagraph::UnsetPExtraType() +void LyXParagraph::UnsetPExtraType(BufferParams const & bparams) { if (pextra_type == PEXTRA_NONE) return; pextra_type = PEXTRA_NONE; - pextra_width.clear(); - pextra_widthp.clear(); + pextra_width.erase(); + pextra_widthp.erase(); - if (textclasslist.Style(current_view->buffer()->params.textclass, + 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; while (par && (par->layout == layout) && (par->depth == depth)) { par->pextra_type = PEXTRA_NONE; - par->pextra_width.clear(); - par->pextra_widthp.clear(); + 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(); + 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 } } } @@ -3992,18 +3861,17 @@ 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 { - bool tmp = false; - if (pos >= 0) - tmp = IsNewlineChar(GetChar(pos)); - return tmp; + return pos >= 0 && IsNewlineChar(GetChar(pos)); } @@ -4028,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); } @@ -4049,32 +3915,173 @@ bool LyXParagraph::IsWord(size_type pos ) const } -LyXDirection LyXParagraph::getParDirection() const +Language const * +LyXParagraph::getParLanguage(BufferParams const & bparams) const { - if (!lyxrc->rtl_support || table) - return LYX_DIR_LEFT_TO_RIGHT; - +#ifndef NEW_INSETS + if (IsDummy()) + return FirstPhysicalPar()->getParLanguage(bparams); + else +#endif if (size() > 0) - return (getFont(0).direction() == LyXFont::RTL_DIR) - ? LYX_DIR_RIGHT_TO_LEFT : LYX_DIR_LEFT_TO_RIGHT; + return GetFirstFontSettings().language(); + else if (previous) + return previous->getParLanguage(bparams); else - return current_view->buffer()->params.getDocumentDirection(); + return bparams.language; +} + + +bool LyXParagraph::isRightToLeftPar(BufferParams const & bparams) const +{ + return lyxrc.rtl_support + && getParLanguage(bparams)->RightToLeft(); } -LyXDirection -LyXParagraph::getLetterDirection(LyXParagraph::size_type pos) const +void LyXParagraph::ChangeLanguage(BufferParams const & bparams, + Language const * from, Language const * to) { - if (!lyxrc->rtl_support) - return LYX_DIR_LEFT_TO_RIGHT; + for (size_type i = 0; i < size(); ++i) { + LyXFont font = GetFontSettings(bparams, i); + if (font.language() == from) { + font.setLanguage(to); + SetFont(i, font); + } + } +} - LyXDirection direction = getFont(pos).getFontDirection(); - if (IsLineSeparator(pos) && 0 < pos && pos < Last() - 1 - && !IsLineSeparator(pos + 1) - && !(table && IsNewline(pos + 1)) - && (getFont(pos - 1).getFontDirection() != direction - || getFont(pos + 1).getFontDirection() != direction)) - return getParDirection(); - else - return direction; + +bool LyXParagraph::isMultiLingual(BufferParams const & bparams) +{ + 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 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 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; +} + + +string const LyXParagraph::String(Buffer const * buffer, + LyXParagraph::size_type beg, + LyXParagraph::size_type end) +{ + string s; + +#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) { + 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; +} + + +void LyXParagraph::SetInsetOwner(Inset * i) +{ + inset_owner = i; + for (InsetList::const_iterator cit = insetlist.begin(); + cit != insetlist.end(); ++cit) { + if ((*cit).inset) + (*cit).inset->setOwner(i); + } +} + + +void LyXParagraph::deleteInsetsLyXText(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)->deleteLyXText(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; }