X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=1ca0c04ef1b5575dbd0a4e2e5d4156d77e6602d1;hb=e3188e8869e8ee1821b4db444b4a82e101ae28f5;hp=6aabdd620bb1b1659e73c495e30bdfdfaf0f0aed;hpb=9359baacf89c4586751e60e45d711eaa3a2c9335;p=lyx.git diff --git a/src/paragraph.C b/src/paragraph.C index 6aabdd620b..1ca0c04ef1 100644 --- a/src/paragraph.C +++ b/src/paragraph.C @@ -1,10 +1,10 @@ /* This file is part of - * ====================================================== - * + * ====================================================== + * * LyX, The Document Processor - * + * * Copyright 1995 Matthias Ettrich - * Copyright 1995-2001 The LyX Team. + * Copyright 1995-2001 The LyX Team. * * ====================================================== */ @@ -14,36 +14,35 @@ #pragma implementation #endif -#include -#include -#include - #include "paragraph.h" #include "paragraph_pimpl.h" -#include "support/textutils.h" #include "lyxrc.h" #include "layout.h" #include "language.h" #include "tex-strings.h" #include "buffer.h" #include "bufferparams.h" -#include "support/FileInfo.h" -#include "support/LAssert.h" #include "debug.h" -#include "LaTeXFeatures.h" -#include "insets/insetinclude.h" -#include "insets/insetbib.h" -#include "insets/insettext.h" -#include "support/filetools.h" -#include "support/lstrings.h" -#include "lyx_gui_misc.h" #include "texrow.h" -#include "support/lyxmanip.h" #include "BufferView.h" #include "encoding.h" #include "ParameterStruct.h" #include "gettext.h" +#include "insets/insetbib.h" +#include "insets/insetoptarg.h" + +#include "support/filetools.h" +#include "support/lstrings.h" +#include "support/lyxmanip.h" +#include "support/FileInfo.h" +#include "support/LAssert.h" +#include "support/textutils.h" + +#include +#include +#include + using std::ostream; using std::endl; using std::fstream; @@ -52,7 +51,8 @@ using std::lower_bound; using std::upper_bound; using std::reverse; -int tex_code_break_column = 72; // needs non-zero initialization. set later. +using lyx::pos_type; + // this is a bad idea, but how can Paragraph find its buffer to get // parameters? (JMarc) @@ -73,24 +73,24 @@ extern BufferView * current_view; Paragraph::Paragraph() - : pimpl_(new Paragraph::Pimpl(this)) + : pimpl_(new Paragraph::Pimpl(this)) { - for (int i = 0; i < 10; ++i) setCounter(i , 0); +#ifndef NO_NEXT next_ = 0; previous_ = 0; +#endif enumdepth = 0; itemdepth = 0; - bibkey = 0; // ale970302 - clear(); + bibkey = 0; // ale970302 + params().clear(); } -// This konstruktor inserts the new paragraph in a list. +#ifndef NO_NEXT +// This constructor inserts the new paragraph in a list. Paragraph::Paragraph(Paragraph * par) - : pimpl_(new Paragraph::Pimpl(this)) + : pimpl_(new Paragraph::Pimpl(this)) { - for (int i = 0; i < 10; ++i) - setCounter(i, 0); enumdepth = 0; itemdepth = 0; @@ -102,41 +102,42 @@ Paragraph::Paragraph(Paragraph * par) previous_->next_ = this; // end - bibkey = 0; // ale970302 - - clear(); + bibkey = 0; // ale970302 + params().clear(); } +#endif Paragraph::Paragraph(Paragraph const & lp, bool same_ids) : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids)) { - for (int i = 0; i < 10; ++i) - setCounter(i , 0); enumdepth = 0; itemdepth = 0; - next_ = 0; +#ifndef NO_NEXT + next_ = 0; previous_ = 0; - +#endif // this is because of the dummy layout of the paragraphs that // follow footnotes - layout = lp.layout; + layout_ = lp.layout(); - // ale970302 + // ale970302 if (lp.bibkey) { bibkey = static_cast (lp.bibkey->clone(*current_view->buffer())); } else { bibkey = 0; } - - // copy everything behind the break-position to the new paragraph + // copy everything behind the break-position to the new paragraph insetlist = lp.insetlist; - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) - { - it->inset = it->inset->clone(*current_view->buffer(), same_ids); + InsetList::iterator it = insetlist.begin(); + InsetList::iterator end = insetlist.end(); + for (; it != end; ++it) { + it.setInset(it.getInset()->clone(*current_view->buffer(), + same_ids)); + // tell the new inset who is the boss now + it.getInset()->parOwner(this); } } @@ -144,17 +145,14 @@ Paragraph::Paragraph(Paragraph const & lp, bool same_ids) // the destructor removes the new paragraph from the list Paragraph::~Paragraph() { +#ifndef NO_NEXT if (previous_) previous_->next_ = next_; if (next_) next_->previous_ = previous_; +#endif - for (InsetList::iterator it = insetlist.begin(); - it != insetlist.end(); ++it) { - delete it->inset; - } - - // ale970302 + // ale970302 delete bibkey; delete pimpl_; @@ -164,9 +162,9 @@ Paragraph::~Paragraph() } -void Paragraph::writeFile(Buffer const * buf, ostream & os, - BufferParams const & bparams, - depth_type dth) const +void Paragraph::write(Buffer const * buf, ostream & os, + BufferParams const & bparams, + depth_type & dth) const { // The beginning or end of a deeper (i.e. nested) area? if (dth != params().depth()) { @@ -182,48 +180,51 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, } } } - + // First write the layout - os << "\n\\layout " - << textclasslist.NameOfLayout(bparams.textclass, layout) - << "\n"; - + os << "\n\\layout " << layout()->name() << '\n'; + // Maybe some vertical spaces. if (params().spaceTop().kind() != VSpace::NONE) os << "\\added_space_top " - << params().spaceTop().asLyXCommand() << " "; + << params().spaceTop().asLyXCommand() << ' '; if (params().spaceBottom().kind() != VSpace::NONE) os << "\\added_space_bottom " - << params().spaceBottom().asLyXCommand() << " "; - + << params().spaceBottom().asLyXCommand() << ' '; + // Maybe the paragraph has special spacing params().spacing().writeFile(os, true); - + // The labelwidth string used in lists. if (!params().labelWidthString().empty()) os << "\\labelwidthstring " << params().labelWidthString() << '\n'; - + // Lines above or below? if (params().lineTop()) os << "\\line_top "; if (params().lineBottom()) os << "\\line_bottom "; - + // Pagebreaks above or below? if (params().pagebreakTop()) os << "\\pagebreak_top "; if (params().pagebreakBottom()) os << "\\pagebreak_bottom "; - + // Start of appendix? if (params().startOfAppendix()) os << "\\start_of_appendix "; - + // Noindent? if (params().noindent()) os << "\\noindent "; - + + // Do we have a manual left indent? + if (!params().leftIndent().zero()) + os << "\\leftindent " << params().leftIndent().asString() + << ' '; + // Alignment? if (params().align() != LYX_ALIGN_LAYOUT) { int h = 0; @@ -233,34 +234,30 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, case LYX_ALIGN_CENTER: h = 3; break; default: h = 0; break; } - os << "\\align " << string_align[h] << " "; + os << "\\align " << string_align[h] << ' '; } - + // bibitem ale970302 if (bibkey) bibkey->write(buf, os); - + LyXFont font1(LyXFont::ALL_INHERIT, bparams.language); - + int column = 0; - for (size_type i = 0; i < size(); ++i) { + for (pos_type i = 0; i < size(); ++i) { if (!i) { - os << "\n"; + os << '\n'; column = 0; } - + // Write font changes LyXFont font2 = getFontSettings(bparams, i); if (font2 != font1) { -#ifndef INHERIT_LANGUAGE font2.lyxWriteChanges(font1, os); -#else - font2.lyxWriteChanges(font1, bparams.language, os); -#endif column = 0; font1 = font2; } - + value_type const c = getChar(i); switch (c) { case META_INSET: @@ -280,11 +277,11 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, } } break; - case META_NEWLINE: + case META_NEWLINE: os << "\n\\newline \n"; column = 0; break; - case META_HFILL: + case META_HFILL: os << "\n\\hfill \n"; column = 0; break; @@ -297,12 +294,12 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, os << ".\n"; column = 0; } else - os << "."; + os << '.'; break; default: if ((column > 70 && c == ' ') || column > 79) { - os << "\n"; + os << '\n'; column = 0; } // this check is to amend a bug. LyX sometimes @@ -316,82 +313,17 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, break; } } - - // now write the next paragraph - if (next_) - next_->writeFile(buf, os, bparams, dth); } void Paragraph::validate(LaTeXFeatures & features) const { - BufferParams const & bparams = features.bufferParams(); - - // check the params. - if (params().lineTop() || params().lineBottom()) - features.lyxline = true; - if (!params().spacing().isDefault()) - features.setspace = true; - - // then the layouts - features.layout[getLayout()] = true; - - // then the fonts - Language const * doc_language = bparams.language; - - for (Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); - cit != pimpl_->fontlist.end(); ++cit) { - if (cit->font().noun() == LyXFont::ON) { - lyxerr[Debug::LATEX] << "font.noun: " - << cit->font().noun() - << endl; - features.noun = true; - lyxerr[Debug::LATEX] << "Noun enabled. Font: " - << cit->font().stateText(0) - << endl; - } - switch (cit->font().color()) { - case LColor::none: - case LColor::inherit: - case LColor::ignore: - // probably we should put here all interface colors used for - // font displaying! For now I just add this ones I know of (Jug) - case LColor::latex: - case LColor::note: - break; - default: - features.color = true; - lyxerr[Debug::LATEX] << "Color enabled. Font: " - << cit->font().stateText(0) - << endl; - } - - Language const * language = cit->font().language(); - if (language->babel() != doc_language->babel() && - language != ignore_language && -#ifdef INHERIT_LANGUAGE - language != inherit_language && -#endif - language != latex_language) - { - features.UsedLanguages.insert(language); - lyxerr[Debug::LATEX] << "Found language " - << language->babel() << endl; - } - } - - // then the insets - for (InsetList::const_iterator cit = insetlist.begin(); - cit != insetlist.end(); ++cit) { - if (cit->inset) - cit->inset->validate(features); - } + pimpl_->validate(features, *layout()); } // First few functions needed for cut and paste and paragraph breaking. -void Paragraph::copyIntoMinibuffer(Buffer const & buffer, - Paragraph::size_type pos) const +void Paragraph::copyIntoMinibuffer(Buffer const & buffer, pos_type pos) const { BufferParams bparams = buffer.params; @@ -410,26 +342,16 @@ void Paragraph::copyIntoMinibuffer(Buffer const & buffer, } -void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, - Paragraph::size_type pos) +void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, pos_type pos) { minibuffer_char = getChar(pos); minibuffer_font = getFontSettings(bparams, pos); minibuffer_inset = 0; if (minibuffer_char == Paragraph::META_INSET) { if (getInset(pos)) { - minibuffer_inset = getInset(pos); - // This is a little hack since I want exactly - // the inset, not just a clone. Otherwise - // the inset would be deleted when calling Erase(pos) - // find the entry - InsetTable search_elem(pos, 0); - InsetList::iterator it = - lower_bound(insetlist.begin(), - insetlist.end(), - search_elem, Pimpl::matchIT()); - if (it != insetlist.end() && it->pos == pos) - it->inset = 0; + // the inset is not in a paragraph anymore + minibuffer_inset = insetlist.release(pos); + minibuffer_inset->parOwner(0); } else { minibuffer_inset = 0; minibuffer_char = ' '; @@ -442,17 +364,19 @@ void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, } -bool Paragraph::insertFromMinibuffer(Paragraph::size_type pos) +bool Paragraph::insertFromMinibuffer(pos_type pos) { - if ((minibuffer_char == Paragraph::META_INSET) && - !insetAllowed(minibuffer_inset->lyxCode())) - return false; - if (minibuffer_char == Paragraph::META_INSET) + if (minibuffer_char == Paragraph::META_INSET) { + if (!insetAllowed(minibuffer_inset->lyxCode())) { + return false; + } insertInset(pos, minibuffer_inset, minibuffer_font); - else { + } else { LyXFont f = minibuffer_font; - if (checkInsertChar(f)) - insertChar(pos, minibuffer_char, f); + if (!checkInsertChar(f)) { + return false; + } + insertChar(pos, minibuffer_char, f); } return true; } @@ -460,17 +384,7 @@ bool Paragraph::insertFromMinibuffer(Paragraph::size_type pos) // end of minibuffer - -void Paragraph::clear() -{ - params().clear(); - - layout = 0; - bibkey = 0; -} - - -void Paragraph::erase(Paragraph::size_type pos) +void Paragraph::erase(pos_type pos) { pimpl_->erase(pos); } @@ -484,32 +398,28 @@ bool Paragraph::checkInsertChar(LyXFont & font) } -void Paragraph::insertChar(Paragraph::size_type pos, - Paragraph::value_type c) +void Paragraph::insertChar(pos_type pos, Paragraph::value_type c) { LyXFont const f(LyXFont::ALL_INHERIT); insertChar(pos, c, f); } -void Paragraph::insertChar(Paragraph::size_type pos, - Paragraph::value_type c, - LyXFont const & font) +void Paragraph::insertChar(pos_type pos, Paragraph::value_type c, + LyXFont const & font) { pimpl_->insertChar(pos, c, font); } -void Paragraph::insertInset(Paragraph::size_type pos, - Inset * inset) +void Paragraph::insertInset(pos_type pos, Inset * inset) { LyXFont const f(LyXFont::ALL_INHERIT); insertInset(pos, inset, f); } -void Paragraph::insertInset(Paragraph::size_type pos, - Inset * inset, LyXFont const & font) +void Paragraph::insertInset(pos_type pos, Inset * inset, LyXFont const & font) { pimpl_->insertInset(pos, inset, font); } @@ -518,83 +428,49 @@ void Paragraph::insertInset(Paragraph::size_type pos, bool Paragraph::insetAllowed(Inset::Code code) { //lyxerr << "Paragraph::InsertInsetAllowed" << endl; - + if (pimpl_->inset_owner) return pimpl_->inset_owner->insetAllowed(code); return true; } -Inset * Paragraph::getInset(Paragraph::size_type pos) +Inset * Paragraph::getInset(pos_type pos) { lyx::Assert(pos < size()); - // Find the inset. - InsetTable search_inset(pos, 0); - InsetList::iterator it = lower_bound(insetlist.begin(), - insetlist.end(), - search_inset, Pimpl::matchIT()); - if (it != insetlist.end() && it->pos == pos) - return it->inset; - - lyxerr << "ERROR (Paragraph::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) - // My guess is that since the inset does not exist, we might - // as well replace it with a space to prevent craches. (Asger) - return 0; + return insetlist.get(pos); } -Inset const * Paragraph::getInset(Paragraph::size_type pos) const +Inset const * Paragraph::getInset(pos_type pos) const { lyx::Assert(pos < size()); - // Find the inset. - InsetTable search_inset(pos, 0); - InsetList::const_iterator cit = lower_bound(insetlist.begin(), - insetlist.end(), - search_inset, Pimpl::matchIT()); - if (cit != insetlist.end() && cit->pos == pos) - return cit->inset; - - lyxerr << "ERROR (Paragraph::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) - // My guess is that since the inset does not exist, we might - // as well replace it with a space to prevent craches. (Asger) - return 0; + return insetlist.get(pos); } // Gets uninstantiated font setting at position. LyXFont const Paragraph::getFontSettings(BufferParams const & bparams, - Paragraph::size_type pos) const + pos_type pos) const { lyx::Assert(pos <= size()); - - Pimpl::FontTable search_font(pos, LyXFont()); - Pimpl::FontList::const_iterator cit = lower_bound(pimpl_->fontlist.begin(), - pimpl_->fontlist.end(), - search_font, Pimpl::matchFT()); + + Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); + Pimpl::FontList::const_iterator end = pimpl_->fontlist.end(); + for (; cit != end; ++cit) { + if (cit->pos() >= pos) + break; + } + LyXFont retfont; - if (cit != pimpl_->fontlist.end()) { + if (cit != end) { retfont = cit->font(); - } else if (pos == size() && size()) { + } else if (pos == size() && !empty()) { retfont = getFontSettings(bparams, pos - 1); } else retfont = LyXFont(LyXFont::ALL_INHERIT, getParLanguage(bparams)); -#ifdef INHERIT_LANGUAGE - if (retfont.language() == inherit_language) - retfont.setLanguage(bparams.language); -#endif return retfont; } @@ -603,11 +479,9 @@ LyXFont const Paragraph::getFontSettings(BufferParams const & bparams, // Gets uninstantiated font setting at position 0 LyXFont const Paragraph::getFirstFontSettings() const { - if (size() > 0) { - if (!pimpl_->fontlist.empty()) - return pimpl_->fontlist[0].font(); - } - + if (!empty() && !pimpl_->fontlist.empty()) + return pimpl_->fontlist[0].font(); + return LyXFont(LyXFont::ALL_INHERIT); } @@ -620,29 +494,24 @@ LyXFont const Paragraph::getFirstFontSettings() const // If position is -1, we get the layout font of the paragraph. // If position is -2, we get the font of the manual label of the paragraph. LyXFont const Paragraph::getFont(BufferParams const & bparams, - Paragraph::size_type pos) const + pos_type pos) const { lyx::Assert(pos >= 0); - - LyXLayout const & layout = - textclasslist.Style(bparams.textclass, - getLayout()); - Paragraph::size_type main_body = 0; - if (layout.labeltype == LABEL_MANUAL) + + LyXLayout_ptr const & lout = layout(); + + pos_type main_body = 0; + if (lout->labeltype == LABEL_MANUAL) main_body = beginningOfMainBody(); LyXFont layoutfont; if (pos < main_body) - layoutfont = layout.labelfont; + layoutfont = lout->labelfont; else - layoutfont = layout.font; - + layoutfont = lout->font; + LyXFont tmpfont = getFontSettings(bparams, pos); -#ifndef INHERIT_LANGUAGE tmpfont.realize(layoutfont); -#else - tmpfont.realize(layoutfont, bparams.language); -#endif return pimpl_->realizeFont(tmpfont, bparams); } @@ -650,10 +519,9 @@ LyXFont const Paragraph::getFont(BufferParams const & bparams, LyXFont const Paragraph::getLabelFont(BufferParams const & bparams) const { - LyXLayout const & layout = - textclasslist.Style(bparams.textclass, getLayout()); - - LyXFont tmpfont = layout.labelfont; + LyXLayout_ptr const & lout = layout(); + + LyXFont tmpfont = lout->labelfont; tmpfont.setLanguage(getParLanguage(bparams)); return pimpl_->realizeFont(tmpfont, bparams); @@ -662,11 +530,9 @@ LyXFont const Paragraph::getLabelFont(BufferParams const & bparams) const LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams) const { - LyXLayout const & layout = - textclasslist.Style(bparams.textclass, - getLayout()); + LyXLayout_ptr const & lout = layout(); - LyXFont tmpfont = layout.font; + LyXFont tmpfont = lout->font; tmpfont.setLanguage(getParLanguage(bparams)); return pimpl_->realizeFont(tmpfont, bparams); @@ -675,28 +541,29 @@ LyXFont const Paragraph::getLayoutFont(BufferParams const & bparams) const /// Returns the height of the highest font in range LyXFont::FONT_SIZE -Paragraph::highestFontInRange(Paragraph::size_type startpos, - Paragraph::size_type endpos, +Paragraph::highestFontInRange(pos_type startpos, pos_type endpos, LyXFont::FONT_SIZE const def_size) const { if (pimpl_->fontlist.empty()) return def_size; - LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY; - Pimpl::FontTable end_search(endpos, LyXFont()); - Pimpl::FontList::const_iterator end_it = - lower_bound(pimpl_->fontlist.begin(), - pimpl_->fontlist.end(), - end_search, Pimpl::matchFT()); - if (end_it != pimpl_->fontlist.end()) + Pimpl::FontList::const_iterator end_it = pimpl_->fontlist.begin(); + Pimpl::FontList::const_iterator end = pimpl_->fontlist.end(); + for (; end_it != end; ++end_it) { + if (end_it->pos() >= endpos) + break; + } + + if (end_it != end) ++end_it; - Pimpl::FontTable start_search(startpos, LyXFont()); - Pimpl::FontList::const_iterator cit = - lower_bound(pimpl_->fontlist.begin(), - pimpl_->fontlist.end(), - start_search, Pimpl::matchFT()); - + Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); + for (; cit != end; ++cit) { + if (cit->pos() >= startpos) + break; + } + + LyXFont::FONT_SIZE maxsize = LyXFont::SIZE_TINY; for (; cit != end_it; ++cit) { LyXFont::FONT_SIZE size = cit->font().size(); if (size == LyXFont::INHERIT_SIZE) @@ -709,8 +576,7 @@ Paragraph::highestFontInRange(Paragraph::size_type startpos, Paragraph::value_type -Paragraph::getUChar(BufferParams const & bparams, - Paragraph::size_type pos) const +Paragraph::getUChar(BufferParams const & bparams, pos_type pos) const { value_type c = getChar(pos); if (!lyxrc.rtl_support) @@ -750,8 +616,7 @@ Paragraph::getUChar(BufferParams const & bparams, } -void Paragraph::setFont(Paragraph::size_type pos, - LyXFont const & font) +void Paragraph::setFont(pos_type pos, LyXFont const & font) { lyx::Assert(pos <= size()); @@ -762,18 +627,21 @@ void Paragraph::setFont(Paragraph::size_type pos, // in a new kernel. (Asger) // Next search font table - Pimpl::FontTable search_font(pos, LyXFont()); - Pimpl::FontList::iterator it = lower_bound(pimpl_->fontlist.begin(), - pimpl_->fontlist.end(), - search_font, Pimpl::matchFT()); - unsigned int i = it - pimpl_->fontlist.begin(); - bool notfound = it == pimpl_->fontlist.end(); + Pimpl::FontList::iterator beg = pimpl_->fontlist.begin(); + Pimpl::FontList::iterator it = beg; + Pimpl::FontList::iterator endit = pimpl_->fontlist.end(); + for (; it != endit; ++it) { + if (it->pos() >= pos) + break; + } + unsigned int i = std::distance(beg, it); + bool notfound = (it == endit); if (!notfound && pimpl_->fontlist[i].font() == font) return; bool begin = pos == 0 || notfound || - (i > 0 && pimpl_->fontlist[i-1].pos() == pos - 1); + (i > 0 && pimpl_->fontlist[i - 1].pos() == pos - 1); // Is position pos is a beginning of a font block? bool end = !notfound && pimpl_->fontlist[i].pos() == pos; // Is position pos is the end of a font block? @@ -783,7 +651,7 @@ void Paragraph::setFont(Paragraph::size_type pos, // Merge the singleton block with the next block pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i); if (i > 0 && pimpl_->fontlist[i - 1].font() == font) - pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i-1); + pimpl_->fontlist.erase(pimpl_->fontlist.begin() + i - 1); } else if (i > 0 && pimpl_->fontlist[i - 1].font() == font) { // Merge the singleton block with the previous block pimpl_->fontlist[i - 1].pos(pos); @@ -803,7 +671,7 @@ void Paragraph::setFont(Paragraph::size_type pos, pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1, Pimpl::FontTable(pos, font)); } else { // The general case. The block is splitted into 3 blocks - pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i, + pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i, Pimpl::FontTable(pos - 1, pimpl_->fontlist[i].font())); pimpl_->fontlist.insert(pimpl_->fontlist.begin() + i + 1, Pimpl::FontTable(pos, font)); @@ -811,7 +679,7 @@ void Paragraph::setFont(Paragraph::size_type pos, } - +#ifndef NO_NEXT void Paragraph::next(Paragraph * p) { next_ = p; @@ -849,89 +717,26 @@ Paragraph const * Paragraph::previous() const { return previous_; } +#endif -void Paragraph::breakParagraph(BufferParams const & bparams, - Paragraph::size_type pos, - int flag) -{ - // create a new paragraph - Paragraph * tmp = new Paragraph(this); - // remember to set the inset_owner - tmp->setInsetOwner(inInset()); - - // this is an idea for a more userfriendly layout handling, I will - // see what the users say - - // layout stays the same with latex-environments - if (flag) { - tmp->setOnlyLayout(layout); - tmp->setLabelWidthString(params().labelWidthString()); - } - - if (size() > pos || !size() || flag == 2) { - tmp->setOnlyLayout(layout); - tmp->params().align(params().align()); - tmp->setLabelWidthString(params().labelWidthString()); - - tmp->params().lineBottom(params().lineBottom()); - params().lineBottom(false); - tmp->params().pagebreakBottom(params().pagebreakBottom()); - params().pagebreakBottom(false); - tmp->params().spaceBottom(params().spaceBottom()); - params().spaceBottom(VSpace(VSpace::NONE)); - - tmp->params().depth(params().depth()); - tmp->params().noindent(params().noindent()); - - // copy everything behind the break-position - // to the new paragraph - size_type pos_end = pimpl_->size() - 1; - size_type i = pos; - size_type j = pos; - for (; i <= pos_end; ++i) { - cutIntoMinibuffer(bparams, i); - if (tmp->insertFromMinibuffer(j - pos)) - ++j; - } - for (i = pos_end; i >= pos; --i) { - erase(i); - } - } - - // just an idea of me - if (!pos) { - tmp->params().lineTop(params().lineTop()); - tmp->params().pagebreakTop(params().pagebreakTop()); - tmp->params().spaceTop(params().spaceTop()); - tmp->bibkey = bibkey; - clear(); - // layout stays the same with latex-environments - if (flag) { - setOnlyLayout(tmp->layout); - setLabelWidthString(tmp->params().labelWidthString()); - params().depth(tmp->params().depth()); - } - } -} - - void Paragraph::makeSameLayout(Paragraph const * par) { - layout = par->layout; + layout(par->layout()); // move to pimpl? params() = par->params(); } -int Paragraph::stripLeadingSpaces(LyXTextClassList::size_type tclass) +int Paragraph::stripLeadingSpaces() { - if (textclasslist.Style(tclass, getLayout()).free_spacing) + if (layout()->free_spacing || + isFreeSpacing()) { return 0; - + } + int i = 0; - while (size() - && (isNewline(0) || isLineSeparator(0))){ + while (!empty() && (isNewline(0) || isLineSeparator(0))) { erase(0); ++i; } @@ -942,81 +747,20 @@ int Paragraph::stripLeadingSpaces(LyXTextClassList::size_type tclass) bool Paragraph::hasSameLayout(Paragraph const * par) const { - return - par->layout == layout && + return + par->layout() == layout() && params().sameLayout(par->params()); } -void Paragraph::breakParagraphConservative(BufferParams const & bparams, - Paragraph::size_type pos) -{ - // create a new paragraph - Paragraph * tmp = new Paragraph(this); - tmp->makeSameLayout(this); - - // When can pos > Last()? - // I guess pos == Last() is possible. - if (size() > pos) { - // copy everything behind the break-position to the new - // paragraph - size_type pos_end = pimpl_->size() - 1; - - //size_type i = pos; - //size_type j = pos; - for (size_type i = pos, j = pos; i <= pos_end; ++i) { - cutIntoMinibuffer(bparams, i); - if (tmp->insertFromMinibuffer(j - pos)) - ++j; - } - - for (size_type k = pos_end; k >= pos; --k) { - erase(k); - } - } -} - - -// Be carefull, this does not make any check at all. -// This method has wrong name, it combined this par with the next par. -// In that sense it is the reverse of break paragraph. (Lgb) -void Paragraph::pasteParagraph(BufferParams const & bparams) -{ - // copy the next paragraph to this one - Paragraph * the_next = next(); - - // first the DTP-stuff - params().lineBottom(the_next->params().lineBottom()); - params().spaceBottom(the_next->params().spaceBottom()); - params().pagebreakBottom(the_next->params().pagebreakBottom()); - - size_type pos_end = the_next->pimpl_->size() - 1; - size_type pos_insert = size(); - - // ok, now copy the paragraph - for (size_type i = 0, j = 0; i <= pos_end; ++i) { - the_next->cutIntoMinibuffer(bparams, i); - if (insertFromMinibuffer(pos_insert + j)) - ++j; - } - - // delete the next paragraph - Paragraph * ppar = the_next->previous_; - Paragraph * npar = the_next->next_; - delete the_next; - ppar->next(npar); -} - - -int Paragraph::getEndLabel(BufferParams const & bparams) const +int Paragraph::getEndLabel() const { Paragraph const * par = this; depth_type par_depth = getDepth(); while (par) { - LyXTextClass::LayoutList::size_type layout = par->getLayout(); - int const endlabeltype = - textclasslist.Style(bparams.textclass, - layout).endlabeltype; + LyXLayout_ptr const & layout = par->layout(); + int const endlabeltype = layout->endlabeltype; + if (endlabeltype != END_LABEL_NO_LABEL) { if (!next_) return endlabeltype; @@ -1024,7 +768,7 @@ int Paragraph::getEndLabel(BufferParams const & bparams) const depth_type const next_depth = next_->getDepth(); if (par_depth > next_depth || (par_depth == next_depth - && layout != next_->getLayout())) + && layout != next_->layout())) return endlabeltype; break; } @@ -1044,6 +788,17 @@ Paragraph::depth_type Paragraph::getDepth() const } +Paragraph::depth_type Paragraph::getMaxDepthAfter() const +{ + bool const isenv = layout()->isEnvironment(); + + if (isenv) + return params().depth() + 1; + else + return params().depth(); + +} + char Paragraph::getAlign() const { return params().align(); @@ -1056,12 +811,6 @@ string const & Paragraph::getLabelstring() const } -int Paragraph::getFirstCounter(int i) const -{ - return pimpl_->counter_[i]; -} - - // the next two functions are for the manual labels string const Paragraph::getLabelWidthString() const { @@ -1078,15 +827,9 @@ void Paragraph::setLabelWidthString(string const & s) } -void Paragraph::setOnlyLayout(LyXTextClass::size_type new_layout) -{ - layout = new_layout; -} - - -void Paragraph::setLayout(LyXTextClass::size_type new_layout) +void Paragraph::applyLayout(LyXLayout_ptr const & new_layout) { - layout = new_layout; + layout(new_layout); params().labelWidthString(string()); params().align(LYX_ALIGN_LAYOUT); params().spaceTop(VSpace(VSpace::NONE)); @@ -1095,11 +838,11 @@ void Paragraph::setLayout(LyXTextClass::size_type new_layout) } -// if the layout of a paragraph contains a manual label, the beginning of the +// if the layout of a paragraph contains a manual label, the beginning of the // main body is the beginning of the second word. This is what the par- // function returns. If the layout does not contain a label, the main // body always starts with position 0. This differentiation is necessary, -// because there cannot be a newline or a blank <= the beginning of the +// because there cannot be a newline or a blank <= the beginning of the // main body in TeX. int Paragraph::beginningOfMainBody() const @@ -1107,12 +850,11 @@ int Paragraph::beginningOfMainBody() const // Unroll the first two cycles of the loop // and remember the previous character to // remove unnecessary GetChar() calls - size_type i = 0; - if (i < size() - && getChar(i) != Paragraph::META_NEWLINE) { + pos_type i = 0; + if (i < size() && getChar(i) != Paragraph::META_NEWLINE) { ++i; char previous_char = 0; - char temp = 0; + char temp = 0; if (i < size() && (previous_char = getChar(i)) != Paragraph::META_NEWLINE) { // Yes, this ^ is supposed to be "= " not "==" @@ -1133,11 +875,11 @@ int Paragraph::beginningOfMainBody() const Paragraph * Paragraph::depthHook(depth_type depth) { Paragraph * newpar = this; - + do { newpar = newpar->previous(); } while (newpar && newpar->getDepth() > depth); - + if (!newpar) { if (previous() || getDepth()) lyxerr << "ERROR (Paragraph::DepthHook): " @@ -1152,11 +894,11 @@ Paragraph * Paragraph::depthHook(depth_type depth) Paragraph const * Paragraph::depthHook(depth_type depth) const { Paragraph const * newpar = this; - + do { newpar = newpar->previous(); } while (newpar && newpar->getDepth() > depth); - + if (!newpar) { if (previous() || getDepth()) lyxerr << "ERROR (Paragraph::DepthHook): " @@ -1167,56 +909,32 @@ Paragraph const * Paragraph::depthHook(depth_type depth) const return newpar; } + Paragraph * Paragraph::outerHook() { - if(!getDepth()) + if (!getDepth()) return 0; return depthHook(depth_type(getDepth() - 1)); } + Paragraph const * Paragraph::outerHook() const { - if(!getDepth()) + if (!getDepth()) return 0; return depthHook(depth_type(getDepth() - 1)); } -int Paragraph::autoDeleteInsets() -{ - int count = 0; - InsetList::size_type index = 0; - while (index < insetlist.size()) { - if (insetlist[index].inset && insetlist[index].inset->autoDelete()) { - erase(insetlist[index].pos); - // Erase() calls to insetlist.erase(&insetlist[index]) - // so index shouldn't be increased. - ++count; - } else - ++index; - } - return count; -} - - -Paragraph::inset_iterator -Paragraph::InsetIterator(Paragraph::size_type pos) -{ - InsetTable search_inset(pos, 0); - InsetList::iterator it = lower_bound(insetlist.begin(), - insetlist.end(), - search_inset, Pimpl::matchIT()); - return inset_iterator(it); -} - // returns -1 if inset not found -int Paragraph::getPositionOfInset(Inset * inset) const +int Paragraph::getPositionOfInset(Inset const * inset) const { // Find the entry. - for (InsetList::const_iterator cit = insetlist.begin(); - cit != insetlist.end(); ++cit) { - if (cit->inset == inset) { - return cit->pos; + InsetList::iterator it = insetlist.begin(); + InsetList::iterator end = insetlist.end(); + for (; it != end; ++it) { + if (it.getInset() == inset) { + return it.getPos(); } } if (inset == bibkey) @@ -1225,83 +943,136 @@ int Paragraph::getPositionOfInset(Inset * inset) const return -1; } +namespace { + +InsetOptArg * optArgInset(Paragraph const & par) +{ + // Find the entry. + InsetList::iterator it = par.insetlist.begin(); + InsetList::iterator end = par.insetlist.end(); + for (; it != end; ++it) { + Inset * ins = it.getInset(); + if (ins->lyxCode() == Inset::OPTARG_CODE) { + return static_cast(ins); + } + } + return 0; +} + +} // end namespace Paragraph * Paragraph::TeXOnePar(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow, - bool moving_arg) + BufferParams const & bparams, + ostream & os, TexRow & texrow, + bool moving_arg) { lyxerr[Debug::LATEX] << "TeXOnePar... " << this << endl; - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - layout); - + Inset const * in = inInset(); bool further_blank_line = false; + LyXLayout_ptr style; - if (params().startOfAppendix()) { - os << "\\appendix\n"; - texrow.newline(); - } + // well we have to check if we are in an inset with unlimited + // lenght (all in one row) if that is true then we don't allow + // any special options in the paragraph and also we don't allow + // any environment other then "Standard" to be valid! + if ((in == 0) || !in->forceDefaultParagraphs(in)) { + style = layout(); - if (!params().spacing().isDefault() - && (!previous() || !previous()->hasSameLayout(this))) { - os << params().spacing().writeEnvirBegin() << "\n"; - texrow.newline(); - } - - if (tex_code_break_column && style.isCommand()){ - os << '\n'; - texrow.newline(); - } + if (params().startOfAppendix()) { + os << "\\appendix\n"; + texrow.newline(); + } - if (params().pagebreakTop()) { - os << "\\newpage"; - further_blank_line = true; - } - if (params().spaceTop().kind() != VSpace::NONE) { - os << params().spaceTop().asLatexCommand(bparams); - further_blank_line = true; - } - - if (params().lineTop()) { - os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}' - << "\\vspace{-1\\parskip}"; - further_blank_line = true; - } + if (!params().spacing().isDefault() + && (!previous() || !previous()->hasSameLayout(this))) { + os << params().spacing().writeEnvirBegin() << '\n'; + texrow.newline(); + } - if (further_blank_line){ - os << '\n'; - texrow.newline(); + if (style->isCommand()) { + os << '\n'; + texrow.newline(); + } + + if (params().pagebreakTop()) { + os << "\\newpage"; + further_blank_line = true; + } + if (params().spaceTop().kind() != VSpace::NONE) { + os << params().spaceTop().asLatexCommand(bparams); + further_blank_line = true; + } + + if (params().lineTop()) { + os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}' + << "\\vspace{-1\\parskip}"; + further_blank_line = true; + } + + if (further_blank_line) { + os << '\n'; + texrow.newline(); + } + } else { + style = bparams.getLyXTextClass().defaultLayout(); } Language const * language = getParLanguage(bparams); Language const * doc_language = bparams.language; - Language const * previous_language = previous_ - ? previous_->getParLanguage(bparams) : doc_language; - if (language->babel() != doc_language->babel() && - language->babel() != previous_language->babel()) { - os << subst(lyxrc.language_command_begin, "$$lang", - language->babel()) - << endl; - texrow.newline(); + Language const * previous_language = previous() + ? previous()->getParLanguage(bparams) : doc_language; + + if (language->babel() != previous_language->babel() + // check if we already put language command in TeXEnvironment() + && !(style->isEnvironment() + && (!previous() || + (previous()->layout() != layout() && + previous()->getDepth() <= getDepth()) + || previous()->getDepth() < getDepth()))) + { + if (!lyxrc.language_command_end.empty() && + previous_language->babel() != doc_language->babel()) + { + os << subst(lyxrc.language_command_end, "$$lang", + previous_language->babel()) + << endl; + texrow.newline(); + } + + if (lyxrc.language_command_end.empty() || + language->babel() != doc_language->babel()) + { + os << subst(lyxrc.language_command_begin, "$$lang", + language->babel()) + << endl; + texrow.newline(); + } } if (bparams.inputenc == "auto" && language->encoding() != previous_language->encoding()) { os << "\\inputencoding{" << language->encoding()->LatexName() - << "}" << endl; + << "}\n"; texrow.newline(); } - switch (style.latextype) { + switch (style->latextype) { case LATEX_COMMAND: os << '\\' - << style.latexname() - << style.latexparam(); + << style->latexname(); + + // Separate handling of optional argument inset. + if (style->optionalargs == 1) { + InsetOptArg * it = optArgInset(*this); + if (it != 0) + it->latexOptional(buf, os, false, false); + } + else + os << style->latexparam(); break; case LATEX_ITEM_ENVIRONMENT: - if (bibkey) { + if (bibkey) { bibkey->latex(buf, os, false, false); } else os << "\\item "; @@ -1314,7 +1085,7 @@ Paragraph * Paragraph::TeXOnePar(Buffer const * buf, } bool need_par = simpleTeXOnePar(buf, bparams, os, texrow, moving_arg); - + // 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) @@ -1325,87 +1096,95 @@ Paragraph * Paragraph::TeXOnePar(Buffer const * buf, // We do not need to use to change the font for the last paragraph // or for a command. LyXFont const font = - (size() == 0 - ? getLayoutFont(bparams) - : getFont(bparams, size() - 1)); + (empty() + ? getLayoutFont(bparams) : getFont(bparams, size() - 1)); - bool is_command = textclasslist.Style(bparams.textclass, - getLayout()).isCommand(); - if (style.resfont.size() != font.size() && next_ && !is_command) { + bool is_command = style->isCommand(); + + if (style->resfont.size() != font.size() && next_ && !is_command) { if (!need_par) - os << "{"; + os << '{'; os << "\\" << font.latexSize() << " \\par}"; } else if (need_par) { os << "\\par}"; } else if (is_command) - os << "}"; + os << '}'; - if (language->babel() != doc_language->babel() && - (!next_ || - next_->getParLanguage(bparams)->babel() != language->babel())) - { - os << endl - << subst(lyxrc.language_command_end, "$$lang", - doc_language->babel()); - } - - switch (style.latextype) { + switch (style->latextype) { case LATEX_ITEM_ENVIRONMENT: case LATEX_LIST_ENVIRONMENT: - if (next_ && (params().depth() < next_->params().depth())) { - os << '\n'; - texrow.newline(); - } + if (next_ && (params().depth() < next_->params().depth())) { + os << '\n'; + texrow.newline(); + } break; case LATEX_ENVIRONMENT: // if its the last paragraph of the current environment // skip it otherwise fall through if (next_ - && (next_->layout != layout + && (next_->layout() != layout() || next_->params().depth() != params().depth())) break; + // fall through possible default: // we don't need it for the last paragraph!!! - // or for tables in floats - // -- effectively creates a \par where there isn't one which - // breaks a \subfigure or \subtable. if (next_) { os << '\n'; texrow.newline(); } } - - further_blank_line = false; - if (params().lineBottom()) { - os << "\\lyxline{\\" << font.latexSize() << '}'; - further_blank_line = true; - } - if (params().spaceBottom().kind() != VSpace::NONE) { - os << params().spaceBottom().asLatexCommand(bparams); - further_blank_line = true; - } - - if (params().pagebreakBottom()) { - os << "\\newpage"; - further_blank_line = true; - } + if ((in == 0) || !in->forceDefaultParagraphs(in)) { + further_blank_line = false; + if (params().lineBottom()) { + os << "\\lyxline{\\" << font.latexSize() << '}'; + further_blank_line = true; + } - if (further_blank_line){ - os << '\n'; - texrow.newline(); - } + if (params().spaceBottom().kind() != VSpace::NONE) { + os << params().spaceBottom().asLatexCommand(bparams); + further_blank_line = true; + } - if (!params().spacing().isDefault() - && (!next_ || !next_->hasSameLayout(this))) { - os << params().spacing().writeEnvirEnd() << "\n"; - texrow.newline(); + if (params().pagebreakBottom()) { + os << "\\newpage"; + further_blank_line = true; + } + + if (further_blank_line) { + os << '\n'; + texrow.newline(); + } + + if (!params().spacing().isDefault() + && (!next_ || !next_->hasSameLayout(this))) { + os << params().spacing().writeEnvirEnd() << '\n'; + texrow.newline(); + } } - + // we don't need it for the last paragraph!!! if (next_) { os << '\n'; texrow.newline(); + } else { + // Since \selectlanguage write the language to the aux file, + // we need to reset the language at the end of footnote or + // float. + + if (language->babel() != doc_language->babel()) { + if (lyxrc.language_command_end.empty()) + os << subst(lyxrc.language_command_begin, + "$$lang", + doc_language->babel()) + << endl; + else + os << subst(lyxrc.language_command_end, + "$$lang", + language->babel()) + << endl; + texrow.newline(); + } } lyxerr[Debug::LATEX] << "TeXOnePar...done " << next_ << endl; @@ -1413,24 +1192,152 @@ Paragraph * Paragraph::TeXOnePar(Buffer const * buf, } +// This could go to ParagraphParameters if we want to +int Paragraph::startTeXParParams(BufferParams const & bparams, + ostream & os, bool moving_arg) const +{ + int column = 0; + + if (params().noindent()) { + os << "\\noindent "; + column += 10; + } + + switch (params().align()) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: + break; + case LYX_ALIGN_LEFT: + case LYX_ALIGN_RIGHT: + case LYX_ALIGN_CENTER: + if (moving_arg) { + os << "\\protect"; + column = 8; + } + break; + } + + switch (params().align()) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: + break; + case LYX_ALIGN_LEFT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\begin{flushleft}"; + column += 17; + } else { + os << "\\begin{flushright}"; + column += 18; + } + break; + case LYX_ALIGN_RIGHT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\begin{flushright}"; + column += 18; + } else { + os << "\\begin{flushleft}"; + column += 17; + } + break; + case LYX_ALIGN_CENTER: + os << "\\begin{center}"; + column += 14; + break; + } + + return column; +} + + +// This could go to ParagraphParameters if we want to +int Paragraph::endTeXParParams(BufferParams const & bparams, + ostream & os, bool moving_arg) const +{ + int column = 0; + + switch (params().align()) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: + break; + case LYX_ALIGN_LEFT: + case LYX_ALIGN_RIGHT: + case LYX_ALIGN_CENTER: + if (moving_arg) { + os << "\\protect"; + column = 8; + } + break; + } + + switch (params().align()) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: + break; + case LYX_ALIGN_LEFT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\end{flushleft}"; + column = 15; + } else { + os << "\\end{flushright}"; + column = 16; + } + break; + case LYX_ALIGN_RIGHT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\end{flushright}"; + column+= 16; + } else { + os << "\\end{flushleft}"; + column = 15; + } + break; + case LYX_ALIGN_CENTER: + os << "\\end{center}"; + column = 12; + break; + } + return column; +} + + // This one spits out the text of the paragraph bool Paragraph::simpleTeXOnePar(Buffer const * buf, - BufferParams const & bparams, - ostream & os, TexRow & texrow, - bool moving_arg) + BufferParams const & bparams, + ostream & os, TexRow & texrow, + bool moving_arg) { lyxerr[Debug::LATEX] << "SimpleTeXOnePar... " << this << endl; bool return_value = false; - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - getLayout()); + LyXLayout_ptr style; + + // well we have to check if we are in an inset with unlimited + // lenght (all in one row) if that is true then we don't allow + // any special options in the paragraph and also we don't allow + // any environment other then "Standard" to be valid! + bool asdefault = + (inInset() && inInset()->forceDefaultParagraphs(inInset())); + + if (asdefault) { + style = bparams.getLyXTextClass().defaultLayout(); + } else { + style = layout(); + } + LyXFont basefont; // Maybe we have to create a optional argument. - size_type main_body; - if (style.labeltype != LABEL_MANUAL) + pos_type main_body; + if (style->labeltype != LABEL_MANUAL) main_body = 0; else main_body = beginningOfMainBody(); @@ -1445,16 +1352,8 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, basefont = getLayoutFont(bparams); } - if (main_body >= 0 - && !pimpl_->size()) { - if (style.isCommand()) { - os << '{'; - ++column; - } - } + moving_arg |= style->needprotect; - moving_arg |= style.needprotect; - // Which font is currently active? LyXFont running_font(basefont); // Do we have an open font change? @@ -1462,7 +1361,18 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, texrow.start(this, 0); - for (size_type i = 0; i < size(); ++i) { + // if the paragraph is empty, the loop will not be entered at all + if (empty()) { + if (style->isCommand()) { + os << '{'; + ++column; + } + if (!asdefault) + column += startTeXParParams(bparams, os, moving_arg); + + } + + for (pos_type i = 0; i < size(); ++i) { ++column; // First char in paragraph or after label? if (i == main_body) { @@ -1476,44 +1386,14 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, os << ']'; ++column; } - if (style.isCommand()) { + if (style->isCommand()) { os << '{'; ++column; } - if (params().noindent()) { - os << "\\noindent "; - column += 10; - } - switch (params().align()) { - case LYX_ALIGN_NONE: - case LYX_ALIGN_BLOCK: - case LYX_ALIGN_LAYOUT: - case LYX_ALIGN_SPECIAL: - break; - case LYX_ALIGN_LEFT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\begin{flushleft}"; - column += 17; - } else { - os << "\\begin{flushright}"; - column += 18; - } - break; - case LYX_ALIGN_RIGHT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\begin{flushright}"; - column += 18; - } else { - os << "\\begin{flushleft}"; - column += 17; - } - break; - case LYX_ALIGN_CENTER: - os << "\\begin{center}"; - column += 14; - break; - } + if (!asdefault) + column += startTeXParParams(bparams, os, + moving_arg); } value_type c = getChar(i); @@ -1527,15 +1407,18 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, // outside font change, i.e. we write "\textXX{text} " // rather than "\textXX{text }". (Asger) if (open_font && c == ' ' && i <= size() - 2) { - LyXFont const next_font = getFont(bparams, i + 1); + LyXFont const & next_font = getFont(bparams, i + 1); if (next_font != running_font && next_font != font) { font = next_font; } } - + // We end font definition before blanks - if (font != running_font && open_font) { + if (open_font && + (font != running_font || + font.language() != running_font.language())) + { column += running_font.latexWriteEndChanges(os, basefont, (i == main_body-1) ? basefont : font); @@ -1548,12 +1431,15 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, // Do not print the separation of the optional argument if (i != main_body - 1) { pimpl_->simpleTeXBlanks(os, texrow, i, - column, font, style); + column, font, *style); } } // Do we need to change font? - if (font != running_font && i != main_body - 1) { + if ((font != running_font || + font.language() != running_font.language()) && + i != main_body - 1) + { column += font.latexWriteStartChanges(os, basefont, last_font); running_font = font; @@ -1563,7 +1449,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, if (c == Paragraph::META_NEWLINE) { // newlines are handled differently here than // the default in SimpleTeXSpecialChars(). - if (!style.newline_allowed) { + if (!style->newline_allowed) { os << '\n'; } else { if (open_font) { @@ -1572,12 +1458,13 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, } basefont = getLayoutFont(bparams); running_font = basefont; - if (font.family() == + if (font.family() == LyXFont::TYPEWRITER_FAMILY) { - os << "~"; + os << '~'; } if (moving_arg) os << "\\protect "; + os << "\\\\\n"; } texrow.newline(); @@ -1586,9 +1473,9 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, } else { pimpl_->simpleTeXSpecialChars(buf, bparams, os, texrow, moving_arg, - font, running_font, - basefont, open_font, - style, i, column, c); + font, running_font, + basefont, open_font, + *style, i, column, c); } } @@ -1598,17 +1485,17 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, if (next_) { running_font .latexWriteEndChanges(os, basefont, - next_->getFont(bparams, - 0)); + next_->getFont(bparams, + 0)); } else { running_font.latexWriteEndChanges(os, basefont, - basefont); + basefont); } #else #ifdef WITH_WARNINGS -#warning For now we ALWAYS have to close the foreign font settings if they are -#warning there as we start another \selectlanguage with the next paragraph if -#warning we are in need of this. This should be fixed sometime (Jug) +//#warning For now we ALWAYS have to close the foreign font settings if they are +//#warning there as we start another \selectlanguage with the next paragraph if +//#warning we are in need of this. This should be fixed sometime (Jug) #endif running_font.latexWriteEndChanges(os, basefont, basefont); #endif @@ -1620,146 +1507,84 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, return_value = false; } - switch (params().align()) { - case LYX_ALIGN_NONE: - case LYX_ALIGN_BLOCK: - case LYX_ALIGN_LAYOUT: - case LYX_ALIGN_SPECIAL: - break; - case LYX_ALIGN_LEFT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\end{flushleft}"; - column+= 15; - } else { - os << "\\end{flushright}"; - column+= 16; - } - break; - case LYX_ALIGN_RIGHT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\end{flushright}"; - column+= 16; - } else { - os << "\\end{flushleft}"; - column+= 15; - } - break; - case LYX_ALIGN_CENTER: - os << "\\end{center}"; - column+= 12; - break; - } + if (!asdefault) { + column += endTeXParParams(bparams, os, moving_arg); + } lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl; return return_value; } -bool Paragraph::linuxDocConvertChar(char c, string & sgml_string) -{ - bool retval = false; - switch (c) { - case Paragraph::META_HFILL: - sgml_string.erase(); - break; - case Paragraph::META_NEWLINE: - sgml_string = '\n'; - break; - case '&': - sgml_string = "&"; - break; - case '<': - sgml_string = "<"; - break; - case '>': - sgml_string = ">"; - break; - case '$': - sgml_string = "$"; - break; - case '#': - sgml_string = "#"; - break; - case '%': - sgml_string = "%"; - break; - case '[': - sgml_string = "["; - break; - case ']': - sgml_string = "]"; - break; - case '{': - sgml_string = "{"; - break; - case '}': - sgml_string = "}"; - break; - case '~': - sgml_string = "˜"; - break; - case '"': - sgml_string = """; - break; - case '\\': - sgml_string = "\"; - break; - case ' ': - retval = true; - sgml_string = ' '; - break; - case '\0': // Ignore :-) - sgml_string.erase(); - break; - default: - sgml_string = c; - break; - } - return retval; -} - - Paragraph * Paragraph::TeXEnvironment(Buffer const * buf, BufferParams const & bparams, ostream & os, TexRow & texrow) { lyxerr[Debug::LATEX] << "TeXEnvironment... " << this << endl; - LyXLayout const & style = - textclasslist.Style(bparams.textclass, - layout); + LyXLayout_ptr const & style = layout(); + + Language const * language = getParLanguage(bparams); + Language const * doc_language = bparams.language; + Language const * previous_language = previous_ + ? previous_->getParLanguage(bparams) : doc_language; + if (language->babel() != previous_language->babel()) { + + if (!lyxrc.language_command_end.empty() && + previous_language->babel() != doc_language->babel()) { + os << subst(lyxrc.language_command_end, "$$lang", + previous_language->babel()) + << endl; + texrow.newline(); + } + + if (lyxrc.language_command_end.empty() || + language->babel() != doc_language->babel()) { + os << subst(lyxrc.language_command_begin, "$$lang", + language->babel()) + << endl; + texrow.newline(); + } + } + + bool leftindent_open = false; + if (!params().leftIndent().zero()) { + os << "\\begin{LyXParagraphLeftIndent}{" << + params().leftIndent().asLatexString() << "}\n"; + texrow.newline(); + leftindent_open = true; + } - if (style.isEnvironment()){ - if (style.latextype == LATEX_LIST_ENVIRONMENT) { - os << "\\begin{" << style.latexname() << "}{" + if (style->isEnvironment()) { + if (style->latextype == LATEX_LIST_ENVIRONMENT) { + os << "\\begin{" << style->latexname() << "}{" << params().labelWidthString() << "}\n"; - } else if (style.labeltype == LABEL_BIBLIO) { + } else if (style->labeltype == LABEL_BIBLIO) { // ale970405 - os << "\\begin{" << style.latexname() << "}{" + os << "\\begin{" << style->latexname() << "}{" << bibitemWidest(buf) << "}\n"; - } else if (style.latextype == LATEX_ITEM_ENVIRONMENT) { - os << "\\begin{" << style.latexname() << '}' - << style.latexparam() << '\n'; - } else - os << "\\begin{" << style.latexname() << '}' - << style.latexparam() << '\n'; + } else if (style->latextype == LATEX_ITEM_ENVIRONMENT) { + os << "\\begin{" << style->latexname() << '}' + << style->latexparam() << '\n'; + } else + os << "\\begin{" << style->latexname() << '}' + << style->latexparam() << '\n'; texrow.newline(); } Paragraph * par = this; do { - par = par->TeXOnePar(buf, bparams, - os, texrow, false); + par = par->TeXOnePar(buf, bparams, os, texrow, false); if (par && par->params().depth() > params().depth()) { - if (textclasslist.Style(bparams.textclass, - par->layout).isParagraph() + if (par->layout()->isParagraph()) { + // Thinko! // How to handle this? (Lgb) //&& !suffixIs(os, "\n\n") - ) { + //) { // There should be at least one '\n' already - // but we need there to be two for Standard + // but we need there to be two for Standard // paragraphs that are depth-increment'ed to be // output correctly. However, tables can // also be paragraphs so don't adjust them. @@ -1774,11 +1599,18 @@ Paragraph * Paragraph::TeXEnvironment(Buffer const * buf, par = par->pimpl_->TeXDeeper(buf, bparams, os, texrow); } } while (par - && par->layout == layout - && par->params().depth() == params().depth()); - - if (style.isEnvironment()) { - os << "\\end{" << style.latexname() << "}\n"; + && par->layout() == layout() + && par->params().depth() == params().depth() + && par->params().leftIndent() == params().leftIndent()); + + if (style->isEnvironment()) { + os << "\\end{" << style->latexname() << "}\n"; + texrow.newline(); + } + + if (leftindent_open) { + os << "\\end{LyXParagraphLeftIndent}\n"; + texrow.newline(); } lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl; @@ -1786,77 +1618,70 @@ Paragraph * Paragraph::TeXEnvironment(Buffer const * buf, } -bool Paragraph::isHfill(size_type pos) const +bool Paragraph::isHfill(pos_type pos) const { return IsHfillChar(getChar(pos)); } -bool Paragraph::isInset(size_type pos) const +bool Paragraph::isInset(pos_type pos) const { return IsInsetChar(getChar(pos)); } -bool Paragraph::isNewline(size_type pos) const +bool Paragraph::isNewline(pos_type pos) const { return pos >= 0 && IsNewlineChar(getChar(pos)); } -bool Paragraph::isSeparator(size_type pos) const +bool Paragraph::isSeparator(pos_type pos) const { return IsSeparatorChar(getChar(pos)); } -bool Paragraph::isLineSeparator(size_type pos) const +bool Paragraph::isLineSeparator(pos_type pos) const { - return IsLineSeparatorChar(getChar(pos)); + value_type const c = getChar(pos); + return IsLineSeparatorChar(c) + || (IsInsetChar(c) && getInset(pos) && + getInset(pos)->isLineSeparator()); } -bool Paragraph::isKomma(size_type pos) const +bool Paragraph::isKomma(pos_type pos) const { return IsKommaChar(getChar(pos)); } /// Used by the spellchecker -bool Paragraph::isLetter(Paragraph::size_type pos) const +bool Paragraph::isLetter(pos_type pos) const { value_type const c = getChar(pos); if (IsLetterChar(c)) return true; - // '\0' is not a letter, allthough every string contains "" (below) - if (c == '\0') - return false; + if (isInset(pos)) + return getInset(pos)->isLetter(); // We want to pass the ' and escape chars to ispell string const extra = lyxrc.isp_esc_chars + '\''; - char ch[2] = { c, 0 }; - return contains(extra, ch); + return contains(extra, c); } - - -bool Paragraph::isWord(size_type pos ) const + + +bool Paragraph::isWord(pos_type pos) const { return IsWordChar(getChar(pos)) ; } Language const * -Paragraph::getParLanguage(BufferParams const & bparams) const +Paragraph::getParLanguage(BufferParams const & bparams) const { - if (size() > 0) { -#ifndef INHERIT_LANGUAGE + if (!empty()) { return getFirstFontSettings().language(); -#else - Language const * lang = getFirstFontSettings().language(); -#warning We should make this somewhat better, any ideas? (Jug) - if (lang == inherit_language || lang == ignore_language) - lang = bparams.language; - return lang; -#endif } else if (previous_) return previous_->getParLanguage(bparams); else @@ -1867,14 +1692,16 @@ Paragraph::getParLanguage(BufferParams const & bparams) const bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const { return lyxrc.rtl_support - && getParLanguage(bparams)->RightToLeft(); + && getParLanguage(bparams)->RightToLeft() + && !(inInset() && inInset()->owner() && + inInset()->owner()->lyxCode() == Inset::ERT_CODE); } void Paragraph::changeLanguage(BufferParams const & bparams, Language const * from, Language const * to) { - for (size_type i = 0; i < size(); ++i) { + for (pos_type i = 0; i < size(); ++i) { LyXFont font = getFontSettings(bparams, i); if (font.language() == from) { font.setLanguage(to); @@ -1887,13 +1714,12 @@ void Paragraph::changeLanguage(BufferParams const & bparams, bool Paragraph::isMultiLingual(BufferParams const & bparams) { Language const * doc_language = bparams.language; - for (Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); - cit != pimpl_->fontlist.end(); ++cit) + Pimpl::FontList::const_iterator cit = pimpl_->fontlist.begin(); + Pimpl::FontList::const_iterator end = pimpl_->fontlist.end(); + + for (; cit != end; ++cit) if (cit->font().language() != ignore_language && cit->font().language() != latex_language && -#ifdef INHERIT_LANGUAGE - cit->font().language() != inherit_language && -#endif cit->font().language() != doc_language) return true; return false; @@ -1902,7 +1728,7 @@ bool Paragraph::isMultiLingual(BufferParams const & bparams) // Convert the paragraph to a string. // Used for building the table of contents -string const Paragraph::asString(Buffer const * buffer, bool label) +string const Paragraph::asString(Buffer const * buffer, bool label) const { BufferParams const & bparams = buffer->params; string s; @@ -1910,7 +1736,7 @@ string const Paragraph::asString(Buffer const * buffer, bool label) s += params().labelString() + ' '; string::size_type const len = s.size(); - for (Paragraph::size_type i = 0; i < size(); ++i) { + for (pos_type i = 0; i < size(); ++i) { value_type c = getChar(i); if (IsPrintable(c)) s += c; @@ -1918,7 +1744,7 @@ string const Paragraph::asString(Buffer const * buffer, bool label) getInset(i)->lyxCode() == Inset::MATH_CODE) { ostringstream ost; getInset(i)->ascii(buffer, ost); - s += subst(ost.str().c_str(),'\n',' '); + s += subst(STRCONV(ost.str()),'\n',' '); } } @@ -1929,35 +1755,39 @@ string const Paragraph::asString(Buffer const * buffer, bool label) } -string const Paragraph::asString(Buffer const * buffer, - Paragraph::size_type beg, - Paragraph::size_type end) +string const Paragraph::asString(Buffer const * buffer, + pos_type beg, pos_type end, bool label) const { ostringstream ost; - if (beg == 0 && !params().labelString().empty()) + if (beg == 0 && label && !params().labelString().empty()) ost << params().labelString() << ' '; - for (Paragraph::size_type i = beg; i < end; ++i) { + for (pos_type i = beg; i < end; ++i) { value_type const c = getUChar(buffer->params, i); if (IsPrintable(c)) ost << c; + else if (c == META_NEWLINE) + ost << '\n'; + else if (c == META_HFILL) + ost << '\t'; else if (c == META_INSET) { getInset(i)->ascii(buffer, ost); } } - return ost.str().c_str(); + return STRCONV(ost.str()); } void Paragraph::setInsetOwner(Inset * i) { pimpl_->inset_owner = i; - for (InsetList::const_iterator cit = insetlist.begin(); - cit != insetlist.end(); ++cit) { - if (cit->inset) - cit->inset->setOwner(i); + InsetList::iterator it = insetlist.begin(); + InsetList::iterator end = insetlist.end(); + for (; it != end; ++it) { + if (it.getInset()) + it.getInset()->setOwner(i); } } @@ -1965,31 +1795,14 @@ void Paragraph::setInsetOwner(Inset * i) void Paragraph::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, true); - } - } - } + insetlist.deleteInsetsLyXText(bv); } void Paragraph::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, true); - } - } - } + insetlist.resizeInsetsLyXText(bv); } @@ -1999,14 +1812,19 @@ void Paragraph::setContentsFromPar(Paragraph * par) } -Paragraph::size_type Paragraph::size() const +lyx::pos_type Paragraph::size() const { return pimpl_->size(); } -Paragraph::value_type -Paragraph::getChar(Paragraph::size_type pos) const +bool Paragraph::empty() const +{ + return pimpl_->empty(); +} + + +Paragraph::value_type Paragraph::getChar(pos_type pos) const { return pimpl_->getChar(pos); } @@ -2018,15 +1836,15 @@ int Paragraph::id() const } -void Paragraph::id(int id_arg) +LyXLayout_ptr const & Paragraph::layout() const { - pimpl_->id_ = id_arg; + return layout_; } -LyXTextClass::LayoutList::size_type Paragraph::getLayout() const +void Paragraph::layout(LyXLayout_ptr const & new_layout) { - return layout; + layout_ = new_layout; } @@ -2034,7 +1852,7 @@ bool Paragraph::isFirstInSequence() const { Paragraph const * dhook = depthHook(getDepth()); return (dhook == this - || dhook->getLayout() != getLayout() + || dhook->layout() != layout() || dhook->getDepth() != getDepth()); } @@ -2050,48 +1868,12 @@ void Paragraph::clearContents() pimpl_->clear(); } - -void Paragraph::setCounter(int i, int v) -{ - pimpl_->counter_[i] = v; -} - - -int Paragraph::getCounter(int i) const -{ - return pimpl_->counter_[i]; -} - - -void Paragraph::incCounter(int i) -{ - pimpl_->counter_[i]++; -} - - -void Paragraph::setChar(size_type pos, value_type c) +void Paragraph::setChar(pos_type pos, value_type c) { pimpl_->setChar(pos, c); } -Paragraph::inset_iterator::inset_iterator(Paragraph::InsetList::iterator const & iter) - : it(iter) -{} - - -Paragraph::inset_iterator Paragraph::inset_iterator_begin() -{ - return inset_iterator(insetlist.begin()); -} - - -Paragraph::inset_iterator Paragraph::inset_iterator_end() -{ - return inset_iterator(insetlist.end()); -} - - ParagraphParameters & Paragraph::params() { return pimpl_->params; @@ -2108,3 +1890,13 @@ Paragraph * Paragraph::getParFromID(int id) const { return pimpl_->getParFromID(id); } + + +bool Paragraph::isFreeSpacing() const +{ + // for now we just need this, later should we need this in some + // other way we can always add a function to Inset::() too. + if (pimpl_->inset_owner && pimpl_->inset_owner->owner()) + return (pimpl_->inset_owner->owner()->lyxCode() == Inset::ERT_CODE); + return false; +}