X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fparagraph.C;h=2e3a09feb90743f57049f9464cc9308d89bdad66;hb=9a5f7d1fe43ddbc1308f69bc609825ac9d618922;hp=80745161f20150c9eccb35ee135df76fd12affe2;hpb=271f8d7eec31175f53d012147af164cb27b043ce;p=lyx.git diff --git a/src/paragraph.C b/src/paragraph.C index 80745161f2..2e3a09feb9 100644 --- a/src/paragraph.C +++ b/src/paragraph.C @@ -14,35 +14,38 @@ #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 "lyxtextclasslist.h" + +#include "insets/insetinclude.h" +#include "insets/insetbib.h" +#include "insets/insettext.h" + +#include "support/filetools.h" +#include "support/lstrings.h" +#include "support/lyxmanip.h" +#include "support/FileInfo.h" +#include "support/LAssert.h" +#include "support/textutils.h" + +#include +#include +#include using std::ostream; using std::endl; @@ -52,6 +55,9 @@ using std::lower_bound; using std::upper_bound; using std::reverse; +using lyx::pos_type; +using lyx::layout_type; + int tex_code_break_column = 72; // needs non-zero initialization. set later. // this is a bad idea, but how can Paragraph find its buffer to get // parameters? (JMarc) @@ -73,21 +79,22 @@ extern BufferView * current_view; Paragraph::Paragraph() - : pimpl_(new Paragraph::Pimpl(this)) + : layout(0), pimpl_(new Paragraph::Pimpl(this)) { - for (int i = 0; i < 10; ++i) setCounter(i , 0); + for (int i = 0; i < 10; ++i) + setCounter(i, 0); next_ = 0; previous_ = 0; enumdepth = 0; itemdepth = 0; - bibkey = 0; // ale970302 + bibkey = 0; // ale970302 clear(); } -// This konstruktor inserts the new paragraph in a list. +// This constructor inserts the new paragraph in a list. Paragraph::Paragraph(Paragraph * par) - : pimpl_(new Paragraph::Pimpl(this)) + : layout(0), pimpl_(new Paragraph::Pimpl(this)) { for (int i = 0; i < 10; ++i) setCounter(i, 0); @@ -102,27 +109,27 @@ Paragraph::Paragraph(Paragraph * par) previous_->next_ = this; // end - bibkey = 0; // ale970302 - + bibkey = 0; // ale970302 + clear(); } Paragraph::Paragraph(Paragraph const & lp, bool same_ids) - : pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids)) + : layout(0), pimpl_(new Paragraph::Pimpl(*lp.pimpl_, this, same_ids)) { for (int i = 0; i < 10; ++i) - setCounter(i , 0); + setCounter(i, 0); enumdepth = 0; itemdepth = 0; - next_ = 0; + next_ = 0; previous_ = 0; // this is because of the dummy layout of the paragraphs that // follow footnotes layout = lp.layout; - // ale970302 + // ale970302 if (lp.bibkey) { bibkey = static_cast (lp.bibkey->clone(*current_view->buffer())); @@ -131,12 +138,13 @@ Paragraph::Paragraph(Paragraph const & lp, bool same_ids) } // copy everything behind the break-position to the new paragraph - insetlist = lp.insetlist; for (InsetList::iterator it = insetlist.begin(); it != insetlist.end(); ++it) { it->inset = it->inset->clone(*current_view->buffer(), same_ids); + // tell the new inset who is the boss now + it->inset->parOwner(this); } } @@ -154,7 +162,7 @@ Paragraph::~Paragraph() delete it->inset; } - // ale970302 + // ale970302 delete bibkey; delete pimpl_; @@ -243,7 +251,7 @@ void Paragraph::writeFile(Buffer const * buf, ostream & os, LyXFont font1(LyXFont::ALL_INHERIT, bparams.language); int column = 0; - for (size_type i = 0; i < size(); ++i) { + for (pos_type i = 0; i < size(); ++i) { if (!i) { os << "\n"; column = 0; @@ -329,12 +337,12 @@ void Paragraph::validate(LaTeXFeatures & features) const // check the params. if (params().lineTop() || params().lineBottom()) - features.lyxline = true; + features.require("lyxline"); if (!params().spacing().isDefault()) - features.setspace = true; + features.require("setspace"); // then the layouts - features.layout[getLayout()] = true; + features.useLayout(getLayout()); // then the fonts Language const * doc_language = bparams.language; @@ -345,7 +353,7 @@ void Paragraph::validate(LaTeXFeatures & features) const lyxerr[Debug::LATEX] << "font.noun: " << cit->font().noun() << endl; - features.noun = true; + features.require("noun"); lyxerr[Debug::LATEX] << "Noun enabled. Font: " << cit->font().stateText(0) << endl; @@ -360,7 +368,7 @@ void Paragraph::validate(LaTeXFeatures & features) const case LColor::note: break; default: - features.color = true; + features.require("color"); lyxerr[Debug::LATEX] << "Color enabled. Font: " << cit->font().stateText(0) << endl; @@ -374,24 +382,30 @@ void Paragraph::validate(LaTeXFeatures & features) const #endif language != latex_language) { - features.UsedLanguages.insert(language); + features.useLanguage(language); lyxerr[Debug::LATEX] << "Found language " << language->babel() << endl; } } // then the insets + LyXLayout const & layout = + textclasslist.Style(bparams.textclass, getLayout()); + for (InsetList::const_iterator cit = insetlist.begin(); cit != insetlist.end(); ++cit) { - if (cit->inset) + if (cit->inset) { cit->inset->validate(features); + if (layout.needprotect && + cit->inset->lyxCode() == Inset::FOOT_CODE) + features.require("NeedLyXFootnoteCode"); + } } } // 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,8 +424,7 @@ 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); @@ -430,6 +443,8 @@ void Paragraph::cutIntoMinibuffer(BufferParams const & bparams, search_elem, Pimpl::matchIT()); if (it != insetlist.end() && it->pos == pos) it->inset = 0; + // the inset is not in a paragraph anymore + minibuffer_inset->parOwner(0); } else { minibuffer_inset = 0; minibuffer_char = ' '; @@ -442,17 +457,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; } @@ -470,7 +487,7 @@ void Paragraph::clear() } -void Paragraph::erase(Paragraph::size_type pos) +void Paragraph::erase(pos_type pos) { pimpl_->erase(pos); } @@ -484,32 +501,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); } @@ -525,7 +538,7 @@ bool Paragraph::insetAllowed(Inset::Code code) } -Inset * Paragraph::getInset(Paragraph::size_type pos) +Inset * Paragraph::getInset(pos_type pos) { lyx::Assert(pos < size()); @@ -550,7 +563,7 @@ Inset * Paragraph::getInset(Paragraph::size_type pos) } -Inset const * Paragraph::getInset(Paragraph::size_type pos) const +Inset const * Paragraph::getInset(pos_type pos) const { lyx::Assert(pos < size()); @@ -576,7 +589,7 @@ Inset const * Paragraph::getInset(Paragraph::size_type pos) const // 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()); @@ -603,10 +616,8 @@ 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 (size() > 0 && !pimpl_->fontlist.empty()) + return pimpl_->fontlist[0].font(); return LyXFont(LyXFont::ALL_INHERIT); } @@ -620,14 +631,14 @@ 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; + pos_type main_body = 0; if (layout.labeltype == LABEL_MANUAL) main_body = beginningOfMainBody(); @@ -675,8 +686,7 @@ 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()) @@ -709,8 +719,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 +759,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()); @@ -852,7 +860,7 @@ Paragraph const * Paragraph::previous() const void Paragraph::breakParagraph(BufferParams const & bparams, - Paragraph::size_type pos, + pos_type pos, int flag) { // create a new paragraph @@ -886,9 +894,9 @@ void Paragraph::breakParagraph(BufferParams const & bparams, // 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; + pos_type pos_end = pimpl_->size() - 1; + pos_type i = pos; + pos_type j = pos; for (; i <= pos_end; ++i) { cutIntoMinibuffer(bparams, i); if (tmp->insertFromMinibuffer(j - pos)) @@ -924,14 +932,16 @@ void Paragraph::makeSameLayout(Paragraph const * par) } -int Paragraph::stripLeadingSpaces(LyXTextClassList::size_type tclass) +int Paragraph::stripLeadingSpaces(lyx::textclass_type tclass) { - if (textclasslist.Style(tclass, getLayout()).free_spacing) + if (textclasslist.Style(tclass, getLayout()).free_spacing || + isFreeSpacing()) + { return 0; + } int i = 0; - while (size() - && (isNewline(0) || isLineSeparator(0))){ + while (size() && (isNewline(0) || isLineSeparator(0))) { erase(0); ++i; } @@ -949,7 +959,7 @@ bool Paragraph::hasSameLayout(Paragraph const * par) const void Paragraph::breakParagraphConservative(BufferParams const & bparams, - Paragraph::size_type pos) + pos_type pos) { // create a new paragraph Paragraph * tmp = new Paragraph(this); @@ -960,22 +970,22 @@ void Paragraph::breakParagraphConservative(BufferParams const & bparams, if (size() > pos) { // copy everything behind the break-position to the new // paragraph - size_type pos_end = pimpl_->size() - 1; + pos_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) { + //pos_type i = pos; + //pos_type j = pos; + for (pos_type i = pos, j = pos; i <= pos_end; ++i) { cutIntoMinibuffer(bparams, i); if (tmp->insertFromMinibuffer(j - pos)) ++j; } - for (size_type k = pos_end; k >= pos; --k) { + for (pos_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. @@ -984,22 +994,22 @@ 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(); + pos_type pos_end = the_next->pimpl_->size() - 1; + pos_type pos_insert = size(); // ok, now copy the paragraph - for (size_type i = 0, j = 0; i <= pos_end; ++i) { + for (pos_type i = 0, j = 0; i <= pos_end; ++i) { the_next->cutIntoMinibuffer(bparams, i); if (insertFromMinibuffer(pos_insert + j)) ++j; } - + // delete the next paragraph Paragraph * ppar = the_next->previous_; Paragraph * npar = the_next->next_; @@ -1013,7 +1023,7 @@ int Paragraph::getEndLabel(BufferParams const & bparams) const Paragraph const * par = this; depth_type par_depth = getDepth(); while (par) { - LyXTextClass::LayoutList::size_type layout = par->getLayout(); + layout_type layout = par->getLayout(); int const endlabeltype = textclasslist.Style(bparams.textclass, layout).endlabeltype; @@ -1078,15 +1088,15 @@ void Paragraph::setLabelWidthString(string const & s) } -void Paragraph::setOnlyLayout(LyXTextClass::size_type new_layout) +void Paragraph::setOnlyLayout(layout_type new_layout) { layout = new_layout; } -void Paragraph::setLayout(LyXTextClass::size_type new_layout) +void Paragraph::setLayout(layout_type new_layout) { - layout = new_layout; + layout = new_layout; params().labelWidthString(string()); params().align(LYX_ALIGN_LAYOUT); params().spaceTop(VSpace(VSpace::NONE)); @@ -1107,7 +1117,7 @@ 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; + pos_type i = 0; if (i < size() && getChar(i) != Paragraph::META_NEWLINE) { ++i; @@ -1133,11 +1143,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 +1162,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): " @@ -1181,25 +1191,9 @@ Paragraph const * Paragraph::outerHook() const 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) +Paragraph::InsetIterator(pos_type pos) { InsetTable search_inset(pos, 0); InsetList::iterator it = lower_bound(insetlist.begin(), @@ -1210,7 +1204,7 @@ Paragraph::InsetIterator(Paragraph::size_type pos) // 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(); @@ -1227,63 +1221,89 @@ int Paragraph::getPositionOfInset(Inset * inset) const 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 style; + + // well we have to check if we are in an inset with unlimited + // lenght (all in one row) if that is true then we don't allow + // any special options in the paragraph and also we don't allow + // any environment other then "Standard" to be valid! + if ((in == 0) || !in->forceDefaultParagraphs(in)) { + style = textclasslist.Style(bparams.textclass, layout); + + if (params().startOfAppendix()) { + os << "\\appendix\n"; + texrow.newline(); + } - if (params().startOfAppendix()) { - os << "\\appendix\n"; - texrow.newline(); - } - - if (!params().spacing().isDefault() - && (!previous() || !previous()->hasSameLayout(this))) { - os << params().spacing().writeEnvirBegin() << "\n"; - texrow.newline(); - } + if (!params().spacing().isDefault() + && (!previous() || !previous()->hasSameLayout(this))) { + os << params().spacing().writeEnvirBegin() << "\n"; + texrow.newline(); + } - if (tex_code_break_column && style.isCommand()){ - os << '\n'; - texrow.newline(); - } + if (tex_code_break_column && style.isCommand()){ + os << '\n'; + texrow.newline(); + } - if (params().pagebreakTop()) { - os << "\\newpage"; - further_blank_line = true; - } - if (params().spaceTop().kind() != VSpace::NONE) { - os << params().spaceTop().asLatexCommand(bparams); - further_blank_line = true; - } - - if (params().lineTop()) { - os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}' - << "\\vspace{-1\\parskip}"; - further_blank_line = true; - } + if (params().pagebreakTop()) { + os << "\\newpage"; + further_blank_line = true; + } + if (params().spaceTop().kind() != VSpace::NONE) { + os << params().spaceTop().asLatexCommand(bparams); + further_blank_line = true; + } - if (further_blank_line){ - os << '\n'; - texrow.newline(); + if (params().lineTop()) { + os << "\\lyxline{\\" << getFont(bparams, 0).latexSize() << '}' + << "\\vspace{-1\\parskip}"; + further_blank_line = true; + } + + if (further_blank_line){ + os << '\n'; + texrow.newline(); + } + } else { + style = textclasslist.Style(bparams.textclass, 0); } Language const * language = getParLanguage(bparams); Language const * doc_language = bparams.language; - Language const * previous_language = previous_ - ? previous_->getParLanguage(bparams) : doc_language; - if (language->babel() != doc_language->babel() && - language->babel() != previous_language->babel()) { - os << subst(lyxrc.language_command_begin, "$$lang", - language->babel()) - << endl; - texrow.newline(); + Language const * previous_language = previous() + ? previous()->getParLanguage(bparams) : doc_language; + + if (language->babel() != previous_language->babel() + // check if we already put language command in TeXEnvironment() + && !(style.isEnvironment() + && (!previous() || previous()->layout != layout || + previous()->params().depth() != params().depth()))) + { + if (!lyxrc.language_command_end.empty() && + previous_language->babel() != doc_language->babel()) + { + os << subst(lyxrc.language_command_end, "$$lang", + previous_language->babel()) + << endl; + texrow.newline(); + } + + if (lyxrc.language_command_end.empty() || + language->babel() != doc_language->babel()) + { + os << subst(lyxrc.language_command_begin, "$$lang", + language->babel()) + << endl; + texrow.newline(); + } } if (bparams.inputenc == "auto" && @@ -1326,11 +1346,10 @@ Paragraph * Paragraph::TeXOnePar(Buffer const * buf, // or for a command. LyXFont const font = (size() == 0 - ? getLayoutFont(bparams) - : getFont(bparams, size() - 1)); + ? getLayoutFont(bparams) : getFont(bparams, size() - 1)); - bool is_command = textclasslist.Style(bparams.textclass, - getLayout()).isCommand(); + bool is_command = style.isCommand(); + if (style.resfont.size() != font.size() && next_ && !is_command) { if (!need_par) os << "{"; @@ -1340,22 +1359,13 @@ Paragraph * Paragraph::TeXOnePar(Buffer const * buf, } else if (is_command) 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) { 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 @@ -1364,48 +1374,66 @@ Paragraph * Paragraph::TeXOnePar(Buffer const * buf, && (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 ((in == 0) || !in->forceDefaultParagraphs(in)) { + further_blank_line = false; + if (params().lineBottom()) { + os << "\\lyxline{\\" << font.latexSize() << '}'; + further_blank_line = true; + } - if (params().spaceBottom().kind() != VSpace::NONE) { - os << params().spaceBottom().asLatexCommand(bparams); - further_blank_line = true; - } - - if (params().pagebreakBottom()) { - os << "\\newpage"; - further_blank_line = true; - } + if (params().spaceBottom().kind() != VSpace::NONE) { + os << params().spaceBottom().asLatexCommand(bparams); + further_blank_line = true; + } - if (further_blank_line){ - os << '\n'; - texrow.newline(); - } + if (params().pagebreakBottom()) { + os << "\\newpage"; + further_blank_line = true; + } - if (!params().spacing().isDefault() - && (!next_ || !next_->hasSameLayout(this))) { - os << params().spacing().writeEnvirEnd() << "\n"; - texrow.newline(); + if (further_blank_line){ + os << '\n'; + texrow.newline(); + } + + if (!params().spacing().isDefault() + && (!next_ || !next_->hasSameLayout(this))) { + os << params().spacing().writeEnvirEnd() << "\n"; + texrow.newline(); + } } // we don't need it for the last paragraph!!! if (next_) { 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; @@ -1415,21 +1443,33 @@ Paragraph * Paragraph::TeXOnePar(Buffer const * buf, // 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 style; + + // well we have to check if we are in an inset with unlimited + // lenght (all in one row) if that is true then we don't allow + // any special options in the paragraph and also we don't allow + // any environment other then "Standard" to be valid! + bool asdefault = + (inInset() && inInset()->forceDefaultParagraphs(inInset())); + + if (asdefault) { + style = textclasslist.Style(bparams.textclass, 0); + } else { + style = textclasslist.Style(bparams.textclass, layout); + } + LyXFont basefont; // Maybe we have to create a optional argument. - size_type main_body; + pos_type main_body; if (style.labeltype != LABEL_MANUAL) main_body = 0; else @@ -1445,8 +1485,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, basefont = getLayoutFont(bparams); } - if (main_body >= 0 - && !pimpl_->size()) { + if (main_body >= 0 && !pimpl_->size()) { if (style.isCommand()) { os << '{'; ++column; @@ -1462,7 +1501,7 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, texrow.start(this, 0); - for (size_type i = 0; i < size(); ++i) { + for (pos_type i = 0; i < size(); ++i) { ++column; // First char in paragraph or after label? if (i == main_body) { @@ -1481,39 +1520,42 @@ bool Paragraph::simpleTeXOnePar(Buffer const * buf, ++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; + if (!asdefault) { + if (params().noindent()) { + os << "\\noindent "; + column += 10; } - break; - case LYX_ALIGN_RIGHT: - if (getParLanguage(bparams)->babel() != "hebrew") { - os << "\\begin{flushright}"; - column += 18; - } else { - os << "\\begin{flushleft}"; - column += 17; + + switch (params().align()) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: + break; + case LYX_ALIGN_LEFT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\begin{flushleft}"; + column += 17; + } else { + os << "\\begin{flushright}"; + column += 18; + } + break; + case LYX_ALIGN_RIGHT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\begin{flushright}"; + column += 18; + } else { + os << "\\begin{flushleft}"; + column += 17; + } + break; + case LYX_ALIGN_CENTER: + os << "\\begin{center}"; + column += 14; + break; } - break; - case LYX_ALIGN_CENTER: - os << "\\begin{center}"; - column += 14; - break; - } + } } value_type c = getChar(i); @@ -1620,42 +1662,44 @@ 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; + if (!asdefault) { + switch (params().align()) { + case LYX_ALIGN_NONE: + case LYX_ALIGN_BLOCK: + case LYX_ALIGN_LAYOUT: + case LYX_ALIGN_SPECIAL: + break; + case LYX_ALIGN_LEFT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\end{flushleft}"; + column+= 15; + } else { + os << "\\end{flushright}"; + column+= 16; + } + break; + case LYX_ALIGN_RIGHT: + if (getParLanguage(bparams)->babel() != "hebrew") { + os << "\\end{flushright}"; + column+= 16; + } else { + os << "\\end{flushleft}"; + column+= 15; + } + break; + case LYX_ALIGN_CENTER: + os << "\\end{center}"; + column+= 12; + break; } - break; - case LYX_ALIGN_CENTER: - os << "\\end{center}"; - column+= 12; - break; - } + } lyxerr[Debug::LATEX] << "SimpleTeXOnePar...done " << this << endl; return return_value; } -bool Paragraph::linuxDocConvertChar(char c, string & sgml_string) +bool Paragraph::sgmlConvertChar(char c, string & sgml_string) { bool retval = false; switch (c) { @@ -1729,7 +1773,30 @@ Paragraph * Paragraph::TeXEnvironment(Buffer const * buf, textclasslist.Style(bparams.textclass, layout); - if (style.isEnvironment()){ + Language const * language = getParLanguage(bparams); + Language const * doc_language = bparams.language; + Language const * previous_language = previous_ + ? previous_->getParLanguage(bparams) : doc_language; + if (language->babel() != previous_language->babel()) { + + if (!lyxrc.language_command_end.empty() && + previous_language->babel() != doc_language->babel()) { + os << subst(lyxrc.language_command_end, "$$lang", + previous_language->babel()) + << endl; + texrow.newline(); + } + + if (lyxrc.language_command_end.empty() || + language->babel() != doc_language->babel()) { + os << subst(lyxrc.language_command_begin, "$$lang", + language->babel()) + << endl; + texrow.newline(); + } + } + + if (style.isEnvironment()) { if (style.latextype == LATEX_LIST_ENVIRONMENT) { os << "\\begin{" << style.latexname() << "}{" << params().labelWidthString() << "}\n"; @@ -1748,8 +1815,7 @@ Paragraph * Paragraph::TeXEnvironment(Buffer const * buf, } 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, @@ -1779,6 +1845,7 @@ Paragraph * Paragraph::TeXEnvironment(Buffer const * buf, if (style.isEnvironment()) { os << "\\end{" << style.latexname() << "}\n"; + texrow.newline(); } lyxerr[Debug::LATEX] << "TeXEnvironment...done " << par << endl; @@ -1786,59 +1853,57 @@ 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)); } -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)) ; } @@ -1874,7 +1939,7 @@ bool Paragraph::isRightToLeftPar(BufferParams const & bparams) const 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); @@ -1910,7 +1975,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; @@ -1930,18 +1995,21 @@ string const Paragraph::asString(Buffer const * buffer, bool label) string const Paragraph::asString(Buffer const * buffer, - Paragraph::size_type beg, - Paragraph::size_type end) + pos_type beg, pos_type end, bool label) { 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); } @@ -1999,14 +2067,13 @@ 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 +Paragraph::value_type Paragraph::getChar(pos_type pos) const { return pimpl_->getChar(pos); } @@ -2024,7 +2091,7 @@ void Paragraph::id(int id_arg) } -LyXTextClass::LayoutList::size_type Paragraph::getLayout() const +layout_type Paragraph::getLayout() const { return layout; } @@ -2069,7 +2136,7 @@ void Paragraph::incCounter(int i) } -void Paragraph::setChar(size_type pos, value_type c) +void Paragraph::setChar(pos_type pos, value_type c) { pimpl_->setChar(pos, c); } @@ -2108,3 +2175,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; +}