X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_latex.cpp;h=a5473bf4813d5684a00479d1570d3670de9810d2;hb=a5b01f8f96efc95633a8da1cf4748aa473a89f1a;hp=2ebde776ef905653173406a40ad39d8c7fb0702f;hpb=8e092e6ca6ff426b9e2bdc5d330e1cad6e67ec14;p=lyx.git diff --git a/src/output_latex.cpp b/src/output_latex.cpp index 2ebde776ef..a5473bf481 100644 --- a/src/output_latex.cpp +++ b/src/output_latex.cpp @@ -77,7 +77,7 @@ struct TeXEnvironementData static TeXEnvironementData prepareEnvironement(Buffer const & buf, Text const & text, - ParagraphList::const_iterator pit, odocstream & os, TexRow & texrow, + ParagraphList::const_iterator pit, otexstream & os, TexRow & texrow, OutputParams const & runparams) { TeXEnvironementData data; @@ -202,7 +202,7 @@ static TeXEnvironementData prepareEnvironement(Buffer const & buf, Text const & } -static void finishEnvironement(odocstream & os, TexRow & texrow, +static void finishEnvironement(otexstream & os, TexRow & texrow, OutputParams const & runparams, TeXEnvironementData const & data) { if (open_encoding_ == CJK && data.cjk_nested) { @@ -239,7 +239,7 @@ static void finishEnvironement(odocstream & os, TexRow & texrow, void TeXEnvironment(Buffer const & buf, Text const & text, OutputParams const & runparams, - pit_type & pit, odocstream & os, TexRow & texrow) + pit_type & pit, otexstream & os, TexRow & texrow) { ParagraphList const & paragraphs = text.paragraphs(); ParagraphList::const_iterator par = paragraphs.constIterator(pit); @@ -272,7 +272,7 @@ void TeXEnvironment(Buffer const & buf, && par->params().depth() == current_depth && par->params().leftIndent() == current_left_indent) { // We are still in the same environment so TeXOnePar and continue; - TeXOnePar(buf, text, par, os, texrow, runparams); + TeXOnePar(buf, text, pit, os, texrow, runparams); continue; } @@ -307,7 +307,7 @@ void TeXEnvironment(Buffer const & buf, if (!style.isEnvironment()) { // This is a standard paragraph, no need to call TeXEnvironment. - TeXOnePar(buf, text, par, os, texrow, runparams); + TeXOnePar(buf, text, pit, os, texrow, runparams); continue; } @@ -326,7 +326,7 @@ void TeXEnvironment(Buffer const & buf, } // namespace anon -int latexArgInsets(Paragraph const & par, odocstream & os, +int latexArgInsets(Paragraph const & par, otexstream & os, OutputParams const & runparams, unsigned int reqargs, unsigned int optargs) { @@ -380,54 +380,86 @@ int latexArgInsets(Paragraph const & par, odocstream & os, return lines; } +namespace { + +// output the proper paragraph start according to latextype. +void parStartCommand(Paragraph const & par, otexstream & os, TexRow & texrow, + OutputParams const & runparams,Layout const & style) +{ + switch (style.latextype) { + case LATEX_COMMAND: + os << '\\' << from_ascii(style.latexname()); + + // Separate handling of optional argument inset. + if (style.optargs != 0 || style.reqargs != 0) { + int ret = latexArgInsets(par, os, runparams, style.reqargs, style.optargs); + while (ret > 0) { + texrow.newline(); + --ret; + } + } + else + os << from_ascii(style.latexparam()); + break; + case LATEX_ITEM_ENVIRONMENT: + case LATEX_LIST_ENVIRONMENT: + os << "\\item "; + break; + case LATEX_BIB_ENVIRONMENT: + // ignore this, the inset will write itself + break; + default: + break; + } +} + +} // namespace anon // FIXME: this should be anonymous void TeXOnePar(Buffer const & buf, Text const & text, - ParagraphList::const_iterator const pit, - odocstream & os, TexRow & texrow, + pit_type pit, + otexstream & os, TexRow & texrow, OutputParams const & runparams_in, string const & everypar, int start_pos, int end_pos) { - BufferParams const & bparams = buf.params(); + ParagraphList const & paragraphs = text.paragraphs(); + Paragraph const & par = paragraphs.at(pit); // FIXME This check should not really be needed. // Perhaps we should issue an error if it is. Layout const style = text.inset().forcePlainLayout() ? - bparams.documentClass().plainLayout() : pit->layout(); - - ParagraphList const & paragraphs = text.paragraphs(); - ParagraphList::const_iterator const priorpit = - pit == paragraphs.begin() ? pit : boost::prior(pit); - ParagraphList::const_iterator const nextpit = - pit == paragraphs.end() ? pit : boost::next(pit); + bparams.documentClass().plainLayout() : par.layout(); if (style.inpreamble) return; - size_t pos = paragraphs.position(pit); - LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pos << " ptr " << &*pit << " '" + LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pit << " ptr " << &par << " '" << everypar << "'"); OutputParams runparams = runparams_in; - runparams.isLastPar = nextpit == paragraphs.end(); + runparams.isLastPar = (pit == pit_type(paragraphs.size() - 1)); + // We reinitialze par begin and end to be on the safe side + // with embedded inset as we don't know if they set those + // value correctly. + runparams.par_begin = 0; + runparams.par_end = 0; bool const maintext = text.isMainText(); // we are at the beginning of an inset and CJK is already open; // we count inheritation levels to get the inset nesting right. - if (pit == paragraphs.begin() && !maintext + if (pit == 0 && !maintext && (cjk_inherited_ > 0 || open_encoding_ == CJK)) { cjk_inherited_ += 1; open_encoding_ = none; } if (text.inset().getLayout().isPassThru()) { - int const dist = paragraphs.position(pit); - Font const outerfont = text.outerFont(dist); + Font const outerfont = text.outerFont(pit); // No newline before first paragraph in this lyxtext - if (dist > 0) { + if (pit > 0) { os << '\n'; texrow.newline(); if (!text.inset().getLayout().parbreakIsNewline()) { @@ -436,24 +468,35 @@ void TeXOnePar(Buffer const & buf, } } - pit->latex(bparams, outerfont, os, texrow, - runparams, start_pos, end_pos); + par.latex(bparams, outerfont, os, texrow, runparams, start_pos, + end_pos); return; } + Paragraph const * nextpar = runparams.isLastPar + ? 0 : ¶graphs.at(pit + 1); + if (style.pass_thru) { - int const dist = paragraphs.position(pit); - Font const outerfont = text.outerFont(dist); - pit->latex(bparams, outerfont, os, texrow, - runparams, start_pos, end_pos); - os << '\n'; + Font const outerfont = text.outerFont(pit); + parStartCommand(par, os, texrow,runparams, style); + + par.latex(bparams, outerfont, os, texrow, runparams, start_pos, + end_pos); + + // I did not create a parEndCommand for this minuscule + // task because in the other user of parStartCommand + // the code is different (JMarc) + if (style.isCommand()) + os << "}\n"; + else + os << '\n'; texrow.newline(); if (!style.parbreak_is_newline) { os << '\n'; texrow.newline(); - } else if (nextpit != paragraphs.end()) { + } else if (nextpar) { Layout const nextstyle = text.inset().forcePlainLayout() ? - bparams.documentClass().plainLayout() : nextpit->layout(); + bparams.documentClass().plainLayout() : nextpar->layout(); if (nextstyle.name() != style.name()) { os << '\n'; texrow.newline(); @@ -464,7 +507,7 @@ void TeXOnePar(Buffer const & buf, } // This paragraph's language - Language const * const par_language = pit->getParLanguage(bparams); + Language const * const par_language = par.getParLanguage(bparams); // The document's language Language const * const doc_language = bparams.language; // The language that was in effect when the environment this paragraph is @@ -473,20 +516,23 @@ void TeXOnePar(Buffer const & buf, (runparams.local_font != 0) ? runparams.local_font->language() : doc_language; + Paragraph const * priorpar = (pit == 0) ? 0 : ¶graphs.at(pit - 1); + // The previous language that was in effect is the language of the // previous paragraph, unless the previous paragraph is inside an // environment with nesting depth greater than (or equal to, but with // a different layout) the current one. If there is no previous // paragraph, the previous language is the outer language. bool const use_prev_env_language = prev_env_language_ != 0 - && priorpit->layout().isEnvironment() - && (priorpit->getDepth() > pit->getDepth() - || (priorpit->getDepth() == pit->getDepth() - && priorpit->layout() != pit->layout())); + && priorpar + && priorpar->layout().isEnvironment() + && (priorpar->getDepth() > par.getDepth() + || (priorpar->getDepth() == par.getDepth() + && priorpar->layout() != par.layout())); Language const * const prev_language = - (pit != paragraphs.begin()) + (pit != 0) ? (use_prev_env_language ? prev_env_language_ - : priorpit->getParLanguage(bparams)) + : priorpar->getParLanguage(bparams)) : outer_language; string par_lang = par_language->babel(); @@ -505,12 +551,11 @@ void TeXOnePar(Buffer const & buf, lang_end_command = "\\end{$$lang}"; } if (par_lang != prev_lang - // check if we already put language command in TeXEnvironment() - && !(style.isEnvironment() - && (pit == paragraphs.begin() || - (priorpit->layout() != pit->layout() && - priorpit->getDepth() <= pit->getDepth()) - || priorpit->getDepth() < pit->getDepth()))) + // check if we already put language command in TeXEnvironment() + && !(style.isEnvironment() + && (pit == 0 || (priorpar->layout() != par.layout() + && priorpar->getDepth() <= par.getDepth()) + || priorpar->getDepth() < par.getDepth()))) { if (!lang_end_command.empty() && prev_lang != outer_lang && @@ -529,20 +574,19 @@ void TeXOnePar(Buffer const & buf, // the previous one, if the current language is different than the // outer_language (which is currently in effect once the previous one // is closed). - if ((lang_end_command.empty() || - par_lang != outer_lang) && - !par_lang.empty()) { + if ((lang_end_command.empty() || par_lang != outer_lang) + && !par_lang.empty()) { // If we're inside an inset, and that inset is within an \L or \R // (or equivalents), then within the inset, too, any opposite // language paragraph should appear within an \L or \R (in addition // to, outside of, the normal language switch commands). // This behavior is not correct for ArabTeX, though. - if (!runparams.use_polyglossia && + if (!runparams.use_polyglossia // not for ArabTeX - (par_language->lang() != "arabic_arabtex" && - outer_language->lang() != "arabic_arabtex") && + && par_language->lang() != "arabic_arabtex" + && outer_language->lang() != "arabic_arabtex" // are we in an inset? - runparams.local_font != 0 && + && runparams.local_font != 0 // is the inset within an \L or \R? // // FIXME: currently, we don't check this; this means that @@ -550,9 +594,7 @@ void TeXOnePar(Buffer const & buf, // doesn't seem to hurt (though latex will complain) // // is this paragraph in the opposite direction? - runparams.local_font->isRightToLeft() != - par_language->rightToLeft() - ) { + && runparams.local_font->isRightToLeft() != par_language->rightToLeft()) { // FIXME: I don't have a working copy of the Arabi package, so // I'm not sure if the farsi and arabic_arabi stuff is correct // or not... @@ -591,61 +633,62 @@ void TeXOnePar(Buffer const & buf, // Switch file encoding if necessary; no need to do this for "default" // encoding, since this only affects the position of the outputted // \inputencoding command; the encoding switch will occur when necessary - if (bparams.inputenc == "auto" && - runparams.encoding->package() != Encoding::none) { + if (bparams.inputenc == "auto" + && runparams.encoding->package() != Encoding::none) { // Look ahead for future encoding changes. // We try to output them at the beginning of the paragraph, // since the \inputencoding command is not allowed e.g. in // sections. For this reason we only set runparams.moving_arg // after checking for the encoding change, otherwise the // change would be always avoided by switchEncoding(). - for (pos_type i = 0; i < pit->size(); ++i) { - char_type const c = pit->getChar(i); + for (pos_type i = 0; i < par.size(); ++i) { + char_type const c = par.getChar(i); Encoding const * const encoding = - pit->getFontSettings(bparams, i).language()->encoding(); - if (encoding->package() != Encoding::CJK && - runparams.encoding->package() == Encoding::inputenc && - c < 0x80) + par.getFontSettings(bparams, i).language()->encoding(); + if (encoding->package() != Encoding::CJK + && runparams.encoding->package() == Encoding::inputenc + && c < 0x80) continue; - if (pit->isInset(i)) + if (par.isInset(i)) break; // All characters before c are in the ASCII range, and // c is non-ASCII (but no inset), so change the // encoding to that required by the language of c. // With CJK, only add switch if we have CJK content at the beginning // of the paragraph - if (encoding->package() != Encoding::CJK || i == 0) { - pair enc_switch = switchEncoding(os, bparams, runparams, - *encoding); - // the following is necessary after a CJK environment in a multilingual - // context (nesting issue). - if (par_language->encoding()->package() == Encoding::CJK && - open_encoding_ != CJK && cjk_inherited_ == 0) { - os << "\\begin{CJK}{" << from_ascii(par_language->encoding()->latexName()) - << "}{" << from_ascii(bparams.fonts_cjk) << "}%\n"; - open_encoding_ = CJK; + if (i != 0 && encoding->package() == Encoding::CJK) + continue; + + pair enc_switch = switchEncoding(os.os(), + bparams, runparams, *encoding); + // the following is necessary after a CJK environment in a multilingual + // context (nesting issue). + if (par_language->encoding()->package() == Encoding::CJK + && open_encoding_ != CJK && cjk_inherited_ == 0) { + os << "\\begin{CJK}{" << from_ascii(par_language->encoding()->latexName()) + << "}{" << from_ascii(bparams.fonts_cjk) << "}%\n"; + open_encoding_ = CJK; + texrow.newline(); + } + if (encoding->package() != Encoding::none && enc_switch.first) { + if (enc_switch.second > 0) { + // the '%' is necessary to prevent unwanted whitespace + os << "%\n"; texrow.newline(); } - if (encoding->package() != Encoding::none && enc_switch.first) { - if (enc_switch.second > 0) { - // the '%' is necessary to prevent unwanted whitespace - os << "%\n"; - texrow.newline(); - } - // With CJK, the CJK tag had to be closed first (see above) - if (runparams.encoding->package() == Encoding::CJK) { - os << from_ascii(subst( - lang_begin_command, - "$$lang", - par_lang)) - // the '%' is necessary to prevent unwanted whitespace - << "%\n"; - texrow.newline(); - } - runparams.encoding = encoding; + // With CJK, the CJK tag had to be closed first (see above) + if (runparams.encoding->package() == Encoding::CJK) { + os << from_ascii(subst( + lang_begin_command, + "$$lang", + par_lang)) + // the '%' is necessary to prevent unwanted whitespace + << "%\n"; + texrow.newline(); } - break; + runparams.encoding = encoding; } + break; } } @@ -653,17 +696,16 @@ void TeXOnePar(Buffer const & buf, Encoding const * const prev_encoding = runparams.encoding; bool const useSetSpace = bparams.documentClass().provides("SetSpace"); - if (pit->allowParagraphCustomization()) { - if (pit->params().startOfAppendix()) { + if (par.allowParagraphCustomization()) { + if (par.params().startOfAppendix()) { os << "\\appendix\n"; texrow.newline(); } - if (!pit->params().spacing().isDefault() - && (pit == paragraphs.begin() - || !priorpit->hasSameLayout(*pit))) + if (!par.params().spacing().isDefault() + && (pit == 0 || !priorpar->hasSameLayout(par))) { - os << from_ascii(pit->params().spacing().writeEnvirBegin(useSetSpace)) + os << from_ascii(par.params().spacing().writeEnvirBegin(useSetSpace)) << '\n'; texrow.newline(); } @@ -674,38 +716,13 @@ void TeXOnePar(Buffer const & buf, } } - switch (style.latextype) { - case LATEX_COMMAND: - os << '\\' << from_ascii(style.latexname()); - - // Separate handling of optional argument inset. - if (style.optargs != 0 || style.reqargs != 0) { - int ret = latexArgInsets(*pit, os, runparams, style.reqargs, style.optargs); - while (ret > 0) { - texrow.newline(); - --ret; - } - } - else - os << from_ascii(style.latexparam()); - break; - case LATEX_ITEM_ENVIRONMENT: - case LATEX_LIST_ENVIRONMENT: - os << "\\item "; - break; - case LATEX_BIB_ENVIRONMENT: - // ignore this, the inset will write itself - break; - default: - break; - } + parStartCommand(par, os, texrow,runparams, style); - Font const outerfont = text.outerFont(paragraphs.position(pit)); + Font const outerfont = text.outerFont(pit); // FIXME UNICODE os << from_utf8(everypar); - pit->latex(bparams, outerfont, os, texrow, - runparams, start_pos, end_pos); + par.latex(bparams, outerfont, os, texrow, runparams, start_pos, end_pos); // Make sure that \\par is done with the font of the last // character if this has another size as the default. @@ -717,14 +734,14 @@ void TeXOnePar(Buffer const & buf, // We do not need to use to change the font for the last paragraph // or for a command. - Font const font = pit->empty() - ? pit->getLayoutFont(bparams, outerfont) - : pit->getFont(bparams, pit->size() - 1, outerfont); + Font const font = par.empty() + ? par.getLayoutFont(bparams, outerfont) + : par.getFont(bparams, par.size() - 1, outerfont); bool const is_command = style.isCommand(); if (style.resfont.size() != font.fontInfo().size() - && nextpit != paragraphs.end() + && nextpar && !is_command) { os << '{'; os << "\\" << from_ascii(font.latexSize()) << " \\par}"; @@ -741,35 +758,33 @@ void TeXOnePar(Buffer const & buf, switch (style.latextype) { case LATEX_ITEM_ENVIRONMENT: case LATEX_LIST_ENVIRONMENT: - if (nextpit != paragraphs.end() - && (pit->params().depth() < nextpit->params().depth())) + if (nextpar && (par.params().depth() < nextpar->params().depth())) pending_newline = true; break; case LATEX_ENVIRONMENT: { // if its the last paragraph of the current environment // skip it otherwise fall through - if (nextpit != paragraphs.end() && - (nextpit->layout() != pit->layout() - || nextpit->params().depth() != pit->params().depth())) + if (nextpar + && (nextpar->layout() != par.layout() + || nextpar->params().depth() != par.params().depth())) break; } // fall through possible default: // we don't need it for the last paragraph!!! - if (nextpit != paragraphs.end()) + if (nextpar) pending_newline = true; } - if (pit->allowParagraphCustomization()) { - if (!pit->params().spacing().isDefault() - && (nextpit == paragraphs.end() || !nextpit->hasSameLayout(*pit))) - { + if (par.allowParagraphCustomization()) { + if (!par.params().spacing().isDefault() + && (runparams.isLastPar || !nextpar->hasSameLayout(par))) { if (pending_newline) { os << '\n'; texrow.newline(); } - os << from_ascii(pit->params().spacing().writeEnvirEnd(useSetSpace)); + os << from_ascii(par.params().spacing().writeEnvirEnd(useSetSpace)); pending_newline = true; } } @@ -777,23 +792,19 @@ void TeXOnePar(Buffer const & buf, // Closing the language is needed for the last paragraph; it is also // needed if we're within an \L or \R that we may have opened above (not // necessarily in this paragraph) and are about to close. - bool closing_rtl_ltr_environment = - !runparams.use_polyglossia && + bool closing_rtl_ltr_environment = !runparams.use_polyglossia // not for ArabTeX - (par_language->lang() != "arabic_arabtex" && - outer_language->lang() != "arabic_arabtex") && - // have we opened and \L or \R environment? - runparams.local_font != 0 && - runparams.local_font->isRightToLeft() != par_language->rightToLeft() && + && (par_language->lang() != "arabic_arabtex" + && outer_language->lang() != "arabic_arabtex") + // have we opened and \L or \R environment? + && runparams.local_font != 0 + && runparams.local_font->isRightToLeft() != par_language->rightToLeft() // are we about to close the language? - ((nextpit != paragraphs.end() && - par_language->babel() != - (nextpit->getParLanguage(bparams))->babel()) || - (nextpit == paragraphs.end() && - par_language->babel() != outer_language->babel())); - - if (closing_rtl_ltr_environment || (nextpit == paragraphs.end() - && par_language->babel() != outer_language->babel())) { + &&((nextpar && par_language->babel() != (nextpar->getParLanguage(bparams))->babel()) + || (runparams.isLastPar && par_language->babel() != outer_language->babel())); + + if (closing_rtl_ltr_environment + || (runparams.isLastPar && par_language->babel() != outer_language->babel())) { // Since \selectlanguage write the language to the aux file, // we need to reset the language at the end of footnote or // float. @@ -808,8 +819,7 @@ void TeXOnePar(Buffer const & buf, // If this is a child, we should restore the // master language after the last paragraph. Language const * const current_language = - (nextpit == paragraphs.end() - && runparams.master_language) + (runparams.isLastPar && runparams.master_language) ? runparams.master_language : outer_language; string const current_lang = runparams.use_polyglossia ? @@ -841,18 +851,19 @@ void TeXOnePar(Buffer const & buf, // if this is a CJK-paragraph and the next isn't, close CJK // also if the next paragraph is a multilingual environment (because of nesting) - if (nextpit != paragraphs.end() && open_encoding_ == CJK && - (nextpit->getParLanguage(bparams)->encoding()->package() != Encoding::CJK || - (nextpit->layout().isEnvironment() && nextpit->isMultiLingual(bparams))) - // inbetween environments, CJK has to be closed later (nesting!) - && (!style.isEnvironment() || !nextpit->layout().isEnvironment())) { + if (nextpar + && open_encoding_ == CJK + && (nextpar->getParLanguage(bparams)->encoding()->package() != Encoding::CJK + || (nextpar->layout().isEnvironment() && nextpar->isMultiLingual(bparams))) + // inbetween environments, CJK has to be closed later (nesting!) + && (!style.isEnvironment() || !nextpar->layout().isEnvironment())) { os << "\\end{CJK}\n"; open_encoding_ = none; } // If this is the last paragraph, close the CJK environment // if necessary. If it's an environment, we'll have to \end that first. - if (nextpit == paragraphs.end() && !style.isEnvironment()) { + if (runparams.isLastPar && !style.isEnvironment()) { switch (open_encoding_) { case CJK: { // do nothing at the end of child documents @@ -887,7 +898,7 @@ void TeXOnePar(Buffer const & buf, // should be set back to that local_font's encoding. // However, do not change the encoding when a fully unicode aware backend // such as XeTeX is used. - if (nextpit == paragraphs.end() && runparams_in.local_font != 0 + if (runparams.isLastPar && runparams_in.local_font != 0 && runparams_in.encoding != runparams_in.local_font->language()->encoding() && (bparams.inputenc == "auto" || bparams.inputenc == "default") && (!runparams.isFullUnicode())) { @@ -902,8 +913,8 @@ void TeXOnePar(Buffer const & buf, // we don't need a newline for the last paragraph!!! // Note from JMarc: we will re-add a \n explicitly in // TeXEnvironment, because it is needed in this case - if (nextpit != paragraphs.end()) { - Layout const & next_layout = nextpit->layout(); + if (nextpar) { + Layout const & next_layout = nextpar->layout(); if (style == next_layout // no blank lines before environments! || !next_layout.isEnvironment() @@ -914,14 +925,14 @@ void TeXOnePar(Buffer const & buf, // information whether the current TeX row is empty or not. // For some ideas about how to fix this, see this thread: // http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg145787.html - || nextpit->params().depth() != pit->params().depth()) { + || nextpar->params().depth() != par.params().depth()) { os << '\n'; texrow.newline(); } } - if (nextpit != paragraphs.end()) - LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pos << " done; ptr " << &*pit << " next " << &*nextpit); + LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pit << " done; ptr " + << &par << " next " << nextpar); return; } @@ -930,7 +941,7 @@ void TeXOnePar(Buffer const & buf, // LaTeX all paragraphs void latexParagraphs(Buffer const & buf, Text const & text, - odocstream & os, + otexstream & os, TexRow & texrow, OutputParams const & runparams, string const & everypar) @@ -985,7 +996,7 @@ void latexParagraphs(Buffer const & buf, pit_type pit = runparams.par_begin; // lastpit is for the language check after the loop. - pit_type lastpit; + pit_type lastpit = pit; // variables used in the loop: bool was_title = false; bool already_title = false; @@ -1031,7 +1042,7 @@ void latexParagraphs(Buffer const & buf, if (!layout.isEnvironment() && par->params().leftIndent().zero()) { // This is a standard top level paragraph, TeX it and continue. - TeXOnePar(buf, text, par, os, texrow, runparams, everypar); + TeXOnePar(buf, text, pit, os, texrow, runparams, everypar); continue; } @@ -1054,12 +1065,11 @@ void latexParagraphs(Buffer const & buf, if (was_title && !already_title) { if (tclass.titletype() == TITLE_ENVIRONMENT) { os << "\\end{" << from_ascii(tclass.titlename()) - << "}\n"; - } - else { + << "}\n"; + } else { os << "\\" << from_ascii(tclass.titlename()) - << "\n"; - } + << "\n"; + } texrow.newline(); }