#include "BufferParams.h"
#include "Font.h"
#include "InsetList.h"
-#include "Layout.h"
-#include "OutputParams.h"
#include "Paragraph.h"
#include "ParagraphList.h"
#include "ParagraphParameters.h"
#include "insets/InsetLabel.h"
#include "insets/InsetNote.h"
-#include "support/convert.h"
-#include "support/debug.h"
#include "support/lassert.h"
-#include "support/lstrings.h"
-#include "support/textutils.h"
#include <stack>
#include <iostream>
#include <algorithm>
+#include <sstream>
using namespace std;
using namespace lyx::support;
namespace {
-std::string const fontToDocBookTag(xml::FontTypes type)
+std::string fontToDocBookTag(xml::FontTypes type)
{
switch (type) {
case xml::FontTypes::FT_EMPH:
}
}
+
string fontToRole(xml::FontTypes type)
{
// Specific fonts are achieved with roles. The only common ones are "" for basic emphasis,
return "";
case xml::FontTypes::FT_BOLD:
return "bold";
- case xml::FontTypes::FT_NOUN:
- return ""; // Outputs a <person>
- case xml::FontTypes::FT_TYPE:
- return ""; // Outputs a <code>
+ case xml::FontTypes::FT_NOUN: // Outputs a <person>
+ case xml::FontTypes::FT_TYPE: // Outputs a <code>
+ return "";
case xml::FontTypes::FT_UBAR:
return "underline";
- // All other roles are non-standard for DocBook.
+ // All other roles are non-standard for DocBook.
case xml::FontTypes::FT_WAVE:
return "wave";
}
}
+
string fontToAttribute(xml::FontTypes type) {
// If there is a role (i.e. nonstandard use of a tag), output the attribute. Otherwise, the sheer tag is sufficient
// for the font.
}
}
-} // end anonymous namespace
-
-xml::FontTag docbookStartFontTag(xml::FontTypes type)
+// Convenience functions to open and close tags. First, very low-level ones to ensure a consistent new-line behaviour.
+// Block style:
+// Content before
+// <blocktag>
+// Contents of the block.
+// </blocktag>
+// Content after
+// Paragraph style:
+// Content before
+// <paratag>Contents of the paragraph.</paratag>
+// Content after
+// Inline style:
+// Content before<inlinetag>Contents of the paragraph.</inlinetag>Content after
+
+void openInlineTag(XMLStream & xs, const std::string & tag, const std::string & attr)
{
- return xml::FontTag(from_utf8(fontToDocBookTag(type)), from_utf8(fontToAttribute(type)), type);
+ xs << xml::StartTag(tag, attr);
}
-xml::EndFontTag docbookEndFontTag(xml::FontTypes type)
+void closeInlineTag(XMLStream & xs, const std::string & tag)
{
- return xml::EndFontTag(from_utf8(fontToDocBookTag(type)), type);
+ xs << xml::EndTag(tag);
}
-namespace {
-
-// convenience functions
-
-void openParTag(XMLStream &xs, Layout const &lay)
+void openParTag(XMLStream & xs, const std::string & tag, const std::string & attr)
{
- if (lay.docbookwrappertag() != "NONE") {
- xs << xml::StartTag(lay.docbookwrappertag(), lay.docbookwrapperattr());
- }
-
- string tag = lay.docbooktag();
- if (tag == "Plain Layout")
- tag = "para";
-
- xs << xml::ParTag(tag, lay.docbookattr());
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::StartTag(tag, attr);
}
-void closeTag(XMLStream &xs, Layout const &lay)
+void closeParTag(XMLStream & xs, const std::string & tag)
{
- string tag = lay.docbooktag();
- if (tag == "Plain Layout")
- tag = "para";
-
xs << xml::EndTag(tag);
- if (lay.docbookwrappertag() != "NONE")
- xs << xml::EndTag(lay.docbookwrappertag());
+ xs << xml::CR();
}
-void openLabelTag(XMLStream & xs, Layout const & lay) // Mostly for definition lists.
+void openBlockTag(XMLStream & xs, const std::string & tag, const std::string & attr)
{
- xs << xml::StartTag(lay.docbookitemlabeltag(), lay.docbookitemlabelattr());
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::StartTag(tag, attr);
+ xs << xml::CR();
}
-void closeLabelTag(XMLStream & xs, Layout const & lay)
+void closeBlockTag(XMLStream & xs, const std::string & tag)
{
- xs << xml::EndTag(lay.docbookitemlabeltag());
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+ xs << xml::EndTag(tag);
xs << xml::CR();
}
-void openItemTag(XMLStream &xs, Layout const &lay)
+void openTag(XMLStream & xs, const std::string & tag, const std::string & attr, const std::string & tagtype)
{
- xs << xml::StartTag(lay.docbookitemtag(), lay.docbookitemattr());
+ if (tag.empty() || tag == "NONE") // Common check to be performed elsewhere, if it was not here.
+ return;
+
+ if (tag == "para" || tagtype == "paragraph") // Special case for <para>: always considered as a paragraph.
+ openParTag(xs, tag, attr);
+ else if (tagtype == "block")
+ openBlockTag(xs, tag, attr);
+ else if (tagtype == "inline")
+ openInlineTag(xs, tag, attr);
+ else
+ xs.writeError("Unrecognised tag type '" + tagtype + "' for '" + tag + " " + attr + "'");
}
-// Return true when new elements are output in a paragraph, false otherwise.
-bool openInnerItemTag(XMLStream &xs, Layout const &lay)
+void closeTag(XMLStream & xs, const std::string & tag, const std::string & tagtype)
{
- if (lay.docbookiteminnertag() != "NONE") {
- xs << xml::CR();
- xs << xml::ParTag(lay.docbookiteminnertag(), lay.docbookiteminnerattr());
+ if (tag.empty() || tag == "NONE")
+ return;
- if (lay.docbookiteminnertag() == "para") {
- return true;
- }
- }
- return false;
+ if (tag == "para" || tagtype == "paragraph") // Special case for <para>: always considered as a paragraph.
+ closeParTag(xs, tag);
+ else if (tagtype == "block")
+ closeBlockTag(xs, tag);
+ else if (tagtype == "inline")
+ closeInlineTag(xs, tag);
+ else
+ xs.writeError("Unrecognised tag type '" + tagtype + "' for '" + tag + "'");
}
-void closeInnerItemTag(XMLStream &xs, Layout const &lay)
+// Higher-level convenience functions.
+
+void openParTag(XMLStream & xs, const Paragraph * par, const Paragraph * prevpar)
{
- if (lay.docbookiteminnertag()!= "NONE") {
- xs << xml::EndTag(lay.docbookiteminnertag());
- xs << xml::CR();
+ Layout const & lay = par->layout();
+
+ if (par == prevpar)
+ prevpar = nullptr;
+
+ // When should the wrapper be opened here? Only if the previous paragraph has the SAME wrapper tag
+ // (usually, they won't have the same layout) and the CURRENT one allows merging.
+ // The main use case is author information in several paragraphs: if the name of the author is the
+ // first paragraph of an author, then merging with the previous tag does not make sense. Say the
+ // next paragraph is the affiliation, then it should be output in the same <author> tag (different
+ // layout, same wrapper tag).
+ bool openWrapper = lay.docbookwrappertag() != "NONE";
+ if (prevpar != nullptr) {
+ Layout const & prevlay = prevpar->layout();
+ if (prevlay.docbookwrappertag() != "NONE") {
+ openWrapper = prevlay.docbookwrappertag() == lay.docbookwrappertag()
+ && !lay.docbookwrappermergewithprevious();
+ }
}
-}
+ // Main logic.
+ if (openWrapper)
+ openTag(xs, lay.docbookwrappertag(), lay.docbookwrapperattr(), lay.docbookwrappertagtype());
+
+ const string & tag = lay.docbooktag();
+ if (tag != "NONE") {
+ auto xmltag = xml::ParTag(tag, lay.docbookattr());
+ if (!xs.isTagOpen(xmltag, 1)) // Don't nest a paragraph directly in a paragraph.
+ // TODO: required or not?
+ // TODO: avoid creating a ParTag object just for this query...
+ openTag(xs, lay.docbooktag(), lay.docbookattr(), lay.docbooktagtype());
+ }
-inline void closeItemTag(XMLStream &xs, Layout const &lay)
-{
- xs << xml::EndTag(lay.docbookitemtag());
- xs << xml::CR();
+ openTag(xs, lay.docbookitemtag(), lay.docbookitemattr(), lay.docbookitemtagtype());
+ openTag(xs, lay.docbookiteminnertag(), lay.docbookiteminnerattr(), lay.docbookiteminnertagtype());
}
-// end of convenience functions
-ParagraphList::const_iterator findLastParagraph(
- ParagraphList::const_iterator p,
- ParagraphList::const_iterator const & pend) {
- for (++p; p != pend && p->layout().latextype == LATEX_PARAGRAPH; ++p);
+void closeParTag(XMLStream & xs, Paragraph const * par, Paragraph const * nextpar)
+{
+ if (par == nextpar)
+ nextpar = nullptr;
+
+ // See comment in openParTag.
+ Layout const & lay = par->layout();
+ bool closeWrapper = lay.docbookwrappertag() != "NONE";
+ if (nextpar != nullptr) {
+ Layout const & nextlay = nextpar->layout();
+ if (nextlay.docbookwrappertag() != "NONE") {
+ closeWrapper = nextlay.docbookwrappertag() == lay.docbookwrappertag()
+ && !nextlay.docbookwrappermergewithprevious();
+ }
+ }
- return p;
+ // Main logic.
+ closeTag(xs, lay.docbookiteminnertag(), lay.docbookiteminnertagtype());
+ closeTag(xs, lay.docbookitemtag(), lay.docbookitemtagtype());
+ closeTag(xs, lay.docbooktag(), lay.docbooktagtype());
+ if (closeWrapper)
+ closeTag(xs, lay.docbookwrappertag(), lay.docbookwrappertagtype());
}
-ParagraphList::const_iterator findEndOfEnvironment(
- ParagraphList::const_iterator const & pstart,
- ParagraphList::const_iterator const & pend)
+void openLabelTag(XMLStream & xs, Layout const & lay) // Mostly for definition lists.
{
- ParagraphList::const_iterator p = pstart;
- Layout const &bstyle = p->layout();
- size_t const depth = p->params().depth();
- for (++p; p != pend; ++p) {
- Layout const &style = p->layout();
- // It shouldn't happen that e.g. a section command occurs inside
- // a quotation environment, at a higher depth, but as of 6/2009,
- // it can happen. We pretend that it's just at lowest depth.
- if (style.latextype == LATEX_COMMAND)
- return p;
+ openTag(xs, lay.docbookitemlabeltag(), lay.docbookitemlabelattr(), lay.docbookitemlabeltagtype());
+}
- // If depth is down, we're done
- if (p->params().depth() < depth)
- return p;
- // If depth is up, we're not done
- if (p->params().depth() > depth)
- continue;
+void closeLabelTag(XMLStream & xs, Layout const & lay)
+{
+ closeTag(xs, lay.docbookitemlabeltag(), lay.docbookitemlabeltagtype());
+}
- // FIXME I am not sure about the first check.
- // Surely we *could* have different layouts that count as
- // LATEX_PARAGRAPH, right?
- if (style.latextype == LATEX_PARAGRAPH || style != bstyle)
- return p;
- }
- return pend;
+
+void openItemTag(XMLStream & xs, Layout const & lay)
+{
+ openTag(xs, lay.docbookitemtag(), lay.docbookitemattr(), lay.docbookitemtagtype());
}
-ParagraphList::const_iterator makeParagraphBibliography(
- Buffer const &buf,
- XMLStream &xs,
- OutputParams const &runparams,
- Text const &text,
- ParagraphList::const_iterator const & pbegin,
- ParagraphList::const_iterator const & pend)
+void closeItemTag(XMLStream & xs, Layout const & lay)
{
- auto const begin = text.paragraphs().begin();
- auto const end = text.paragraphs().end();
+ closeTag(xs, lay.docbookitemtag(), lay.docbookitemtagtype());
+}
- // Find the paragraph *before* pbegin.
- ParagraphList::const_iterator pbegin_before = begin;
- if (pbegin != begin) {
- ParagraphList::const_iterator pbegin_before_next = begin;
- ++pbegin_before_next;
- while (pbegin_before_next != pbegin) {
- ++pbegin_before;
- ++pbegin_before_next;
- }
- }
+ParagraphList::const_iterator makeAny(Text const &,
+ Buffer const &,
+ XMLStream &,
+ OutputParams const &,
+ ParagraphList::const_iterator);
- ParagraphList::const_iterator par = pbegin;
+void makeBibliography(
+ Text const & text,
+ Buffer const & buf,
+ XMLStream & xs,
+ OutputParams const & runparams,
+ ParagraphList::const_iterator const & par)
+{
// If this is the first paragraph in a bibliography, open the bibliography tag.
- if (pbegin != begin && pbegin_before->layout().latextype != LATEX_BIB_ENVIRONMENT) {
+ auto pbegin_before = text.paragraphs().getParagraphBefore(par);
+ if (pbegin_before->layout().latextype != LATEX_BIB_ENVIRONMENT) {
xs << xml::StartTag("bibliography");
xs << xml::CR();
}
- // Generate the required paragraphs.
- for (; par != pend; ++par) {
- // Start the precooked bibliography entry. This is very much like opening a paragraph tag.
- // Don't forget the citation ID!
- docstring attr;
- for (auto i = 0; i < par->size(); ++i) {
- if (par->getInset(0)->lyxCode() == BIBITEM_CODE) {
- const auto * bibitem = dynamic_cast<const InsetBibitem*>(par->getInset(i));
- attr = from_utf8("xml:id='") + bibitem->bibLabel() + from_utf8("'");
- break;
- }
+ // Start the precooked bibliography entry. This is very much like opening a paragraph tag.
+ // Don't forget the citation ID!
+ docstring attr;
+ for (auto i = 0; i < par->size(); ++i) {
+ Inset const *ip = par->getInset(i);
+ if (!ip)
+ continue;
+ if (const auto * bibitem = dynamic_cast<const InsetBibitem*>(ip)) {
+ attr = from_utf8("xml:id='") + bibitem->getParam("key") + from_utf8("'");
+ break;
}
- xs << xml::StartTag(from_utf8("bibliomixed"), attr);
+ }
+ xs << xml::StartTag(from_utf8("bibliomixed"), attr);
- // Generate the entry.
- par->simpleDocBookOnePar(buf, xs, runparams, text.outerFont(distance(begin, par)), true, true, 0);
+ // Generate the entry. Concatenate the different parts of the paragraph if any.
+ auto const begin = text.paragraphs().begin();
+ auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(std::distance(begin, par)), 0);
+ for (auto & parXML : pars)
+ xs << XMLStream::ESCAPE_NONE << parXML;
- // End the precooked bibliography entry.
- xs << xml::EndTag("bibliomixed");
- xs << xml::CR();
- }
+ // End the precooked bibliography entry.
+ xs << xml::EndTag("bibliomixed");
+ xs << xml::CR();
// If this is the last paragraph in a bibliography, close the bibliography tag.
- if (par == end || par->layout().latextype != LATEX_BIB_ENVIRONMENT) {
+ auto const end = text.paragraphs().end();
+ bool endBibliography = par == end;
+ if (!endBibliography) {
+ auto nextpar = par;
+ ++nextpar;
+ endBibliography = par->layout().latextype != LATEX_BIB_ENVIRONMENT;
+ }
+
+ if (endBibliography) {
xs << xml::EndTag("bibliography");
xs << xml::CR();
}
-
- return pend;
}
-ParagraphList::const_iterator makeParagraphs(
- Buffer const &buf,
- XMLStream &xs,
- OutputParams const &runparams,
- Text const &text,
- ParagraphList::const_iterator const & pbegin,
- ParagraphList::const_iterator const & pend)
+void makeParagraph(
+ Text const & text,
+ Buffer const & buf,
+ XMLStream & xs,
+ OutputParams const & runparams,
+ ParagraphList::const_iterator const & par)
{
- ParagraphList::const_iterator const begin = text.paragraphs().begin();
- ParagraphList::const_iterator par = pbegin;
- for (; par != pend; ++par) {
- Layout const &lay = par->layout();
-
- // We want to open the paragraph tag if:
- // (i) the current layout permits multiple paragraphs
- // (ii) we are either not already inside a paragraph (HTMLIsBlock) OR
- // we are, but this is not the first paragraph
- //
- // But there is also a special case, and we first see whether we are in it.
- // We do not want to open the paragraph tag if this paragraph contains
- // only one item, and that item is "inline", i.e., not HTMLIsBlock (such
- // as a branch). On the other hand, if that single item has a font change
- // applied to it, then we still do need to open the paragraph.
- //
- // Obviously, this is very fragile. The main reason we need to do this is
- // because of branches, e.g., a branch that contains an entire new section.
- // We do not really want to wrap that whole thing in a <div>...</div>.
- bool special_case = false;
- Inset const *specinset = par->size() == 1 ? par->getInset(0) : 0;
- if (specinset && !specinset->getLayout().htmlisblock()) { // TODO: Convert htmlisblock to a DocBook parameter?
- Layout const &style = par->layout();
- FontInfo const first_font = style.labeltype == LABEL_MANUAL ?
- style.labelfont : style.font;
- FontInfo const our_font =
- par->getFont(buf.masterBuffer()->params(), 0,
- text.outerFont(distance(begin, par))).fontInfo();
-
- if (first_font == our_font)
- special_case = true;
- }
+ auto const begin = text.paragraphs().begin();
+ auto const end = text.paragraphs().end();
+ auto prevpar = text.paragraphs().getParagraphBefore(par);
+
+ // We want to open the paragraph tag if:
+ // (i) the current layout permits multiple paragraphs
+ // (ii) we are either not already inside a paragraph (HTMLIsBlock) OR
+ // we are, but this is not the first paragraph
+ //
+ // But there is also a special case, and we first see whether we are in it.
+ // We do not want to open the paragraph tag if this paragraph contains
+ // only one item, and that item is "inline", i.e., not HTMLIsBlock (such
+ // as a branch). On the other hand, if that single item has a font change
+ // applied to it, then we still do need to open the paragraph.
+ //
+ // Obviously, this is very fragile. The main reason we need to do this is
+ // because of branches, e.g., a branch that contains an entire new section.
+ // We do not really want to wrap that whole thing in a <div>...</div>.
+ bool special_case = false;
+ Inset const *specinset = par->size() == 1 ? par->getInset(0) : nullptr;
+ if (specinset && !specinset->getLayout().htmlisblock()) { // TODO: Convert htmlisblock to a DocBook parameter?
+ Layout const &style = par->layout();
+ FontInfo const first_font = style.labeltype == LABEL_MANUAL ?
+ style.labelfont : style.font;
+ FontInfo const our_font =
+ par->getFont(buf.masterBuffer()->params(), 0,
+ text.outerFont(std::distance(begin, par))).fontInfo();
- // Plain layouts must be ignored.
- if (!special_case && buf.params().documentClass().isPlainLayout(lay) && !runparams.docbook_force_pars)
+ if (first_font == our_font)
special_case = true;
- // TODO: Could get rid of this with a DocBook equivalent to htmlisblock?
- if (!special_case && par->size() == 1 && par->getInset(0)) {
- Inset const * firstInset = par->getInset(0);
+ }
+
+ size_t nInsets = std::distance(par->insetList().begin(), par->insetList().end());
- // Floats cannot be in paragraphs.
- special_case = to_ascii(firstInset->layoutName()).substr(0, 6) == "Float:";
+ // Plain layouts must be ignored.
+ special_case |= buf.params().documentClass().isPlainLayout(par->layout()) && !runparams.docbook_force_pars;
+ // Equations do not deserve their own paragraph (DocBook allows them outside paragraphs).
+ special_case |= nInsets == par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset && inset.inset->asInsetMath();
+ });
- // Bibliographies cannot be in paragraphs.
- if (!special_case && firstInset->asInsetCommand())
- special_case = firstInset->asInsetCommand()->params().getCmdName() == "bibtex";
+ // TODO: Could get rid of this with a DocBook equivalent to htmlisblock? Not for all cases, unfortunately... See above for those that have been determined not to be allowable for this potential refactoring.
+ if (!special_case && par->size() == 1 && par->getInset(0)) {
+ Inset const * firstInset = par->getInset(0);
- // Equations do not deserve their own paragraph (DocBook allows them outside paragraphs).
- if (!special_case && firstInset->asInsetMath())
- special_case = true;
+ // Floats cannot be in paragraphs.
+ special_case = to_utf8(firstInset->layoutName()).substr(0, 6) == "Float:";
- // ERTs are in comments, not paragraphs.
- if (!special_case && firstInset->lyxCode() == lyx::ERT_CODE)
- special_case = true;
+ // Bibliographies cannot be in paragraphs.
+ if (!special_case && firstInset->asInsetCommand())
+ special_case = firstInset->asInsetCommand()->params().getCmdName() == "bibtex";
- // Listings should not get into their own paragraph.
- if (!special_case && firstInset->lyxCode() == lyx::LISTINGS_CODE)
- special_case = true;
+ // ERTs are in comments, not paragraphs.
+ if (!special_case && firstInset->lyxCode() == lyx::ERT_CODE)
+ special_case = true;
+
+ // Listings should not get into their own paragraph.
+ if (!special_case && firstInset->lyxCode() == lyx::LISTINGS_CODE)
+ special_case = true;
+ }
+
+ bool const open_par = runparams.docbook_make_pars
+ && !runparams.docbook_in_par
+ && !special_case;
+
+ // We want to issue the closing tag if either:
+ // (i) We opened it, and either docbook_in_par is false,
+ // or we're not in the last paragraph, anyway.
+ // (ii) We didn't open it and docbook_in_par is true,
+ // but we are in the first par, and there is a next par.
+ auto nextpar = par;
+ ++nextpar;
+ bool const close_par = open_par && (!runparams.docbook_in_par);
+
+ // Determine if this paragraph has some real content. Things like new pages are not caught
+ // by Paragraph::empty(), even though they do not generate anything useful in DocBook.
+ // Thus, remove all spaces (including new lines: \r, \n) before checking for emptiness.
+ // std::all_of allows doing this check without having to copy the string.
+ // Open and close tags around each contained paragraph.
+ auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(distance(begin, par)), 0);
+ for (auto & parXML : pars) {
+ if (!std::all_of(parXML.begin(), parXML.end(), ::isspace)) {
+ if (open_par)
+ openParTag(xs, &*par, prevpar);
+
+ xs << XMLStream::ESCAPE_NONE << parXML;
+
+ if (close_par)
+ closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
}
+ }
+}
- bool const open_par = runparams.docbook_make_pars
- && (!runparams.docbook_in_par || par != pbegin)
- && !special_case;
- // We want to issue the closing tag if either:
- // (i) We opened it, and either docbook_in_par is false,
- // or we're not in the last paragraph, anyway.
- // (ii) We didn't open it and docbook_in_par is true,
- // but we are in the first par, and there is a next par.
- ParagraphList::const_iterator nextpar = par;
- ++nextpar;
- bool const close_par =
- ((open_par && (!runparams.docbook_in_par || nextpar != pend))
- || (!open_par && runparams.docbook_in_par && par == pbegin && nextpar != pend));
+void makeEnvironment(Text const &text,
+ Buffer const &buf,
+ XMLStream &xs,
+ OutputParams const &runparams,
+ ParagraphList::const_iterator const & par)
+{
+ // TODO: simplify me!
+ auto const end = text.paragraphs().end();
+
+ // Output the opening tag for this environment, but only if it has not been previously opened (condition
+ // implemented in openParTag).
+ auto prevpar = text.paragraphs().getParagraphBefore(par);
+ openParTag(xs, &*par, prevpar); // TODO: switch in layout for par/block?
- if (open_par) {
- openParTag(xs, lay);
+ // Generate the contents of this environment. There is a special case if this is like some environment.
+ Layout const & style = par->layout();
+ if (style.latextype == LATEX_COMMAND) {
+ // Nothing to do (otherwise, infinite loops).
+ } else if (style.latextype == LATEX_ENVIRONMENT) {
+ // Open a wrapper tag if needed.
+ if (style.docbookitemwrappertag() != "NONE")
+ openTag(xs, style.docbookitemwrappertag(), style.docbookitemwrapperattr(), style.docbookitemwrappertagtype());
+
+ // Generate the label, if need be. If it is taken from the text, sep != 0 and corresponds to the first
+ // character after the label.
+ pos_type sep = 0;
+ if (style.labeltype != LABEL_NO_LABEL && style.docbookitemlabeltag() != "NONE") {
+ // At least one condition must be met:
+ // - this environment is not a list
+ // - if this is a list, the label must not be manual (i.e. it must be taken from the layout)
+ if (style.latextype != LATEX_LIST_ENVIRONMENT || style.labeltype != LABEL_MANUAL) {
+ // Usual cases: maybe there is something specified at the layout level. Highly unlikely, though.
+ docstring const lbl = par->params().labelString();
+
+ if (!lbl.empty()) {
+ openLabelTag(xs, style);
+ xs << lbl;
+ closeLabelTag(xs, style);
+ }
+ } else {
+ // Only variablelist gets here (or similar items defined as an extension in the layout).
+ openLabelTag(xs, style);
+ sep = par->firstWordDocBook(xs, runparams);
+ closeLabelTag(xs, style);
+ }
}
- par->simpleDocBookOnePar(buf, xs, runparams, text.outerFont(distance(begin, par)), open_par, close_par, 0);
+ // Maybe the item is completely empty, i.e. if the first word ends at the end of the current paragraph
+ // AND if the next paragraph doesn't have the same depth (if there is such a paragraph).
+ // Common case: there is only the first word on the line, but there is a nested list instead
+ // of more text.
+ bool emptyItem = false;
+ if (sep == par->size()) { // If the separator is already at the end of this paragraph...
+ auto next_par = par;
+ ++next_par;
+ if (next_par == text.paragraphs().end()) // There is no next paragraph.
+ emptyItem = true;
+ else // There is a next paragraph: check depth.
+ emptyItem = par->params().depth() >= next_par->params().depth();
+ }
- if (close_par) {
- closeTag(xs, lay);
- xs << xml::CR();
+ if (emptyItem) {
+ // Avoid having an empty item, this is not valid DocBook. A single character is enough to force
+ // generation of a full <para>.
+ // TODO: this always worked only by magic...
+ xs << ' ';
+ } else {
+ // Generate the rest of the paragraph, if need be. Open as many inner tags as necessary.
+ auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(std::distance(text.paragraphs().begin(), par)), sep);
+ auto p = pars.begin();
+ while (true) {
+ xs << XMLStream::ESCAPE_NONE << *p;
+ ++p;
+ if (p != pars.end()) {
+ closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
+ openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(), par->layout().docbookiteminnertagtype());
+ } else
+ break;
+ }
}
+ } else {
+ makeAny(text, buf, xs, runparams, par);
}
- return pend;
-}
-
-bool isNormalEnv(Layout const &lay)
-{
- return lay.latextype == LATEX_ENVIRONMENT
- || lay.latextype == LATEX_BIB_ENVIRONMENT;
+ // Close the environment.
+ auto nextpar = par;
+ ++nextpar;
+ closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr); // TODO: switch in layout for par/block?
}
-ParagraphList::const_iterator makeEnvironment(
- Buffer const &buf,
- XMLStream &xs,
- OutputParams const &runparams,
- Text const &text,
- ParagraphList::const_iterator const & pbegin,
+ParagraphList::const_iterator findEndOfEnvironment(
+ ParagraphList::const_iterator const & pstart,
ParagraphList::const_iterator const & pend)
{
- ParagraphList::const_iterator const begin = text.paragraphs().begin();
- ParagraphList::const_iterator par = pbegin;
- Layout const &bstyle = par->layout();
- depth_type const origdepth = pbegin->params().depth();
+ // Copy-paste from XHTML. Should be factored out at some point...
+ ParagraphList::const_iterator p = pstart;
+ Layout const & bstyle = p->layout();
+ size_t const depth = p->params().depth();
+ for (++p; p != pend; ++p) {
+ Layout const & style = p->layout();
+ // It shouldn't happen that e.g. a section command occurs inside
+ // a quotation environment, at a higher depth, but as of 6/2009,
+ // it can happen. We pretend that it's just at lowest depth.
+ if (style.latextype == LATEX_COMMAND)
+ return p;
- // open tag for this environment
- openParTag(xs, bstyle);
- xs << xml::CR();
+ // If depth is down, we're done
+ if (p->params().depth() < depth)
+ return p;
- // we will on occasion need to remember a layout from before.
- Layout const *lastlay = nullptr;
+ // If depth is up, we're not done
+ if (p->params().depth() > depth)
+ continue;
- while (par != pend) {
- Layout const & style = par->layout();
- ParagraphList::const_iterator send;
-
- // Actual content of this paragraph.
- switch (style.latextype) {
- case LATEX_ENVIRONMENT:
- case LATEX_LIST_ENVIRONMENT:
- case LATEX_ITEM_ENVIRONMENT: {
- // There are two possibilities in this case.
- // One is that we are still in the environment in which we
- // started---which we will be if the depth is the same.
- if (par->params().depth() == origdepth) {
- LATTEST(bstyle == style);
- if (lastlay != nullptr) {
- closeItemTag(xs, *lastlay);
- if (lastlay->docbookitemwrappertag() != "NONE") {
- xs << xml::EndTag(lastlay->docbookitemwrappertag());
- xs << xml::CR();
- }
- lastlay = nullptr;
- }
+ // FIXME I am not sure about the first check.
+ // Surely we *could* have different layouts that count as
+ // LATEX_PARAGRAPH, right?
+ if (style.latextype == LATEX_PARAGRAPH || style != bstyle)
+ return p;
+ }
+ return pend;
+}
- // this will be positive if we want to skip the
- // initial word (if it's been taken for the label).
- pos_type sep = 0;
- // Open a wrapper tag if needed.
- if (style.docbookitemwrappertag() != "NONE") {
- xs << xml::StartTag(style.docbookitemwrappertag(), style.docbookitemwrapperattr());
- xs << xml::CR();
- }
+ParagraphList::const_iterator makeListEnvironment(Text const &text,
+ Buffer const &buf,
+ XMLStream &xs,
+ OutputParams const &runparams,
+ ParagraphList::const_iterator const & begin)
+{
+ auto par = begin;
+ auto const end = text.paragraphs().end();
+ auto const envend = findEndOfEnvironment(par, end);
- // label output
- if (style.labeltype != LABEL_NO_LABEL &&
- style.docbookitemlabeltag() != "NONE") {
-
- if (isNormalEnv(style)) {
- // in this case, we print the label only for the first
- // paragraph (as in a theorem or an abstract).
- if (par == pbegin) {
- docstring const lbl = pbegin->params().labelString();
- if (!lbl.empty()) {
- openLabelTag(xs, style);
- xs << lbl;
- closeLabelTag(xs, style);
- }
- xs << xml::CR();
- }
- } else { // some kind of list
- if (style.labeltype == LABEL_MANUAL) {
- // Only variablelist gets here.
-
- openLabelTag(xs, style);
- sep = par->firstWordDocBook(xs, runparams);
- closeLabelTag(xs, style);
- xs << xml::CR();
- } else {
- openLabelTag(xs, style);
- xs << par->params().labelString();
- closeLabelTag(xs, style);
- xs << xml::CR();
- }
- }
- } // end label output
-
- // Start generating the item.
- bool wasInParagraph = runparams.docbook_in_par;
- openItemTag(xs, style);
- bool getsIntoParagraph = openInnerItemTag(xs, style);
- OutputParams rp = runparams;
- rp.docbook_in_par = wasInParagraph | getsIntoParagraph;
-
- // Maybe the item is completely empty, i.e. if the first word ends at the end of the current paragraph
- // AND if the next paragraph doesn't have the same depth (if there is such a paragraph).
- // Common case: there is only the first word on the line, but there is a nested list instead.
- bool emptyItem = false;
- if (sep == par->size()) {
- auto next_par = par;
- ++next_par;
- if (next_par == text.paragraphs().end()) // There is no next paragraph.
- emptyItem = true;
- else // There is a next paragraph: check depth.
- emptyItem = par->params().depth() > next_par->params().depth();
- }
+ // Output the opening tag for this environment.
+ Layout const & envstyle = par->layout();
+ openTag(xs, envstyle.docbookwrappertag(), envstyle.docbookwrapperattr(), envstyle.docbookwrappertagtype());
+ openTag(xs, envstyle.docbooktag(), envstyle.docbookattr(), envstyle.docbooktagtype());
- if (emptyItem) {
- // Avoid having an empty item, this is not valid DocBook. A single character is enough to force
- // generation of a full <para>.
- xs << ' ';
- } else {
- // Generate the rest of the paragraph, if need be.
- par->simpleDocBookOnePar(buf, xs, rp, text.outerFont(distance(begin, par)), true, true, sep);
- }
+ // Handle the content of the list environment, item by item.
+ while (par != envend) {
+ Layout const & style = par->layout();
- ++par;
- if (getsIntoParagraph)
- closeInnerItemTag(xs, style);
-
- // We may not want to close the tag yet, in particular:
- // If we're not at the end of the item...
- if (par != pend
- // and are doing items...
- && !isNormalEnv(style)
- // and if the depth has changed...
- && par->params().depth() != origdepth) {
- // then we'll save this layout for later, and close it when
- // we get another item.
- lastlay = &style;
- } else {
- closeItemTag(xs, style);
-
- // Eventually, close the item wrapper.
- if (style.docbookitemwrappertag() != "NONE") {
- xs << xml::EndTag(style.docbookitemwrappertag());
- xs << xml::CR();
- }
+ // Open the item wrapper.
+ openTag(xs, style.docbookitemwrappertag(), style.docbookitemwrapperattr(), style.docbookitemwrappertagtype());
+
+ // Generate the label, if need be. If it is taken from the text, sep != 0 and corresponds to the first
+ // character after the label.
+ pos_type sep = 0;
+ if (style.labeltype != LABEL_NO_LABEL && style.docbookitemlabeltag() != "NONE") {
+ if (style.labeltype == LABEL_MANUAL) {
+ // Only variablelist gets here (or similar items defined as an extension in the layout).
+ openLabelTag(xs, style);
+ sep = 1 + par->firstWordDocBook(xs, runparams);
+ closeLabelTag(xs, style);
+ } else {
+ // Usual cases: maybe there is something specified at the layout level. Highly unlikely, though.
+ docstring const lbl = par->params().labelString();
+
+ if (!lbl.empty()) {
+ openLabelTag(xs, style);
+ xs << lbl;
+ closeLabelTag(xs, style);
}
}
- // The other possibility is that the depth has increased.
- else {
- send = findEndOfEnvironment(par, pend);
- par = makeEnvironment(buf, xs, runparams, text, par, send);
- }
- break;
}
- case LATEX_PARAGRAPH:
- send = findLastParagraph(par, pend);
- par = makeParagraphs(buf, xs, runparams, text, par, send);
- break;
- case LATEX_BIB_ENVIRONMENT:
- send = findLastParagraph(par, pend);
- par = makeParagraphBibliography(buf, xs, runparams, text, par, send);
- break;
- case LATEX_COMMAND:
- ++par;
- break;
- }
- }
- if (lastlay != nullptr) {
- closeItemTag(xs, *lastlay);
- if (lastlay->docbookitemwrappertag() != "NONE") {
- xs << xml::EndTag(lastlay->docbookitemwrappertag());
- xs << xml::CR();
+ // Open the item (after the wrapper and the label).
+ openTag(xs, style.docbookitemtag(), style.docbookitemattr(), style.docbookitemtagtype());
+
+ // Generate the content of the item.
+ if (sep < par->size()) {
+ auto pars = par->simpleDocBookOnePar(buf, runparams,
+ text.outerFont(std::distance(text.paragraphs().begin(), par)), sep);
+ for (auto &p : pars) {
+ openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(),
+ par->layout().docbookiteminnertagtype());
+ xs << XMLStream::ESCAPE_NONE << p;
+ closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
+ }
+ } else {
+ // DocBook doesn't like emptiness.
+ openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(),
+ par->layout().docbookiteminnertagtype());
+ closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
}
+
+ // If the next item is deeper, it must go entirely within this item (do it recursively).
+ // By construction, with findEndOfEnvironment, depth can only stay constant or increase, never decrease.
+ depth_type currentDepth = par->getDepth();
+ ++par;
+ while (par != envend && par->getDepth() != currentDepth)
+ par = makeAny(text, buf, xs, runparams, par);
+ // Usually, this loop only makes one iteration, except in complex scenarios, like an item with a paragraph,
+ // a list, and another paragraph; or an item with two types of list (itemise then enumerate, for instance).
+
+ // Close the item.
+ closeTag(xs, style.docbookitemtag(), style.docbookitemtagtype());
+ closeTag(xs, style.docbookitemwrappertag(), style.docbookitemwrappertagtype());
}
- closeTag(xs, bstyle);
- xs << xml::CR();
- return pend;
+
+ // Close this environment in exactly the same way as it was opened.
+ closeTag(xs, envstyle.docbooktag(), envstyle.docbooktagtype());
+ closeTag(xs, envstyle.docbookwrappertag(), envstyle.docbookwrappertagtype());
+
+ return envend;
}
void makeCommand(
+ Text const & text,
Buffer const & buf,
XMLStream & xs,
OutputParams const & runparams,
- Text const & text,
- ParagraphList::const_iterator const & pbegin)
+ ParagraphList::const_iterator const & par)
{
- Layout const &style = pbegin->layout();
+ // Unlike XHTML, no need for labels, as they are handled by DocBook tags.
+ auto const begin = text.paragraphs().begin();
+ auto const end = text.paragraphs().end();
+ auto nextpar = par;
+ ++nextpar;
- // No need for labels, as they are handled by DocBook tags.
+ // Generate this command.
+ auto prevpar = text.paragraphs().getParagraphBefore(par);
+ openParTag(xs, &*par, prevpar);
- openParTag(xs, style);
+ auto pars = par->simpleDocBookOnePar(buf, runparams,text.outerFont(distance(begin, par)));
+ for (auto & parXML : pars)
+ // TODO: decide what to do with openParTag/closeParTag in new lines.
+ xs << XMLStream::ESCAPE_NONE << parXML;
- ParagraphList::const_iterator const begin = text.paragraphs().begin();
- pbegin->simpleDocBookOnePar(buf, xs, runparams,
- text.outerFont(distance(begin, pbegin)));
- closeTag(xs, style);
- xs << xml::CR();
+ closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
}
-pair<ParagraphList::const_iterator, ParagraphList::const_iterator> makeAny(
- Text const &text,
- Buffer const &buf,
- XMLStream &xs,
- OutputParams const &ourparams,
- ParagraphList::const_iterator par,
- ParagraphList::const_iterator send,
- ParagraphList::const_iterator pend)
-{
- Layout const & style = par->layout();
- switch (style.latextype) {
- case LATEX_COMMAND: {
- // The files with which we are working never have more than
- // one paragraph in a command structure.
- // FIXME
- // if (ourparams.docbook_in_par)
- // fix it so we don't get sections inside standard, e.g.
- // note that we may then need to make runparams not const, so we
- // can communicate that back.
- // FIXME Maybe this fix should be in the routines themselves, in case
- // they are called from elsewhere.
- makeCommand(buf, xs, ourparams, text, par);
- ++par;
- break;
- }
- case LATEX_ENVIRONMENT:
- case LATEX_LIST_ENVIRONMENT:
- case LATEX_ITEM_ENVIRONMENT: {
- // FIXME Same fix here.
- send = findEndOfEnvironment(par, pend);
- par = makeEnvironment(buf, xs, ourparams, text, par, send);
- break;
- }
- case LATEX_BIB_ENVIRONMENT: {
- send = findLastParagraph(par, pend);
- par = makeParagraphBibliography(buf, xs, ourparams, text, par, send);
- break;
- }
- case LATEX_PARAGRAPH: {
- send = findLastParagraph(par, pend);
- par = makeParagraphs(buf, xs, ourparams, text, par, send);
- break;
- }
+ParagraphList::const_iterator makeAny(Text const &text,
+ Buffer const &buf,
+ XMLStream &xs,
+ OutputParams const &runparams,
+ ParagraphList::const_iterator par)
+{
+ switch (par->layout().latextype) {
+ case LATEX_COMMAND:
+ makeCommand(text, buf, xs, runparams, par);
+ break;
+ case LATEX_ENVIRONMENT:
+ makeEnvironment(text, buf, xs, runparams, par);
+ break;
+ case LATEX_LIST_ENVIRONMENT:
+ case LATEX_ITEM_ENVIRONMENT:
+ // Only case when makeAny() might consume more than one paragraph.
+ return makeListEnvironment(text, buf, xs, runparams, par);
+ case LATEX_PARAGRAPH:
+ makeParagraph(text, buf, xs, runparams, par);
+ break;
+ case LATEX_BIB_ENVIRONMENT:
+ makeBibliography(text, buf, xs, runparams, par);
+ break;
}
-
- return make_pair(par, send);
+ ++par;
+ return par;
}
-} // end anonymous namespace
+
+bool isLayoutSectioning(Layout const & lay)
+{
+ return lay.category() == from_utf8("Sectioning");
+}
using DocBookDocumentSectioning = tuple<bool, pit_type>;
-using DocBookInfoTag = tuple<set<pit_type>, set<pit_type>, pit_type, pit_type>;
+
+
+struct DocBookInfoTag
+{
+ const set<pit_type> shouldBeInInfo;
+ const set<pit_type> mustBeInInfo; // With the notable exception of the abstract!
+ const set<pit_type> abstract;
+ const bool abstractLayout;
+ pit_type bpit;
+ pit_type epit;
+
+ DocBookInfoTag(const set<pit_type> & shouldBeInInfo, const set<pit_type> & mustBeInInfo,
+ const set<pit_type> & abstract, bool abstractLayout, pit_type bpit, pit_type epit) :
+ shouldBeInInfo(shouldBeInInfo), mustBeInInfo(mustBeInInfo), abstract(abstract),
+ abstractLayout(abstractLayout), bpit(bpit), epit(epit) {}
+};
DocBookDocumentSectioning hasDocumentSectioning(ParagraphList const ¶graphs, pit_type bpit, pit_type const epit) {
while (bpit < epit) {
Layout const &style = paragraphs[bpit].layout();
- documentHasSections |= style.category() == from_utf8("Sectioning");
+ documentHasSections |= isLayoutSectioning(style);
- if (documentHasSections) {
+ if (documentHasSections)
break;
- }
bpit += 1;
}
// Paragraphs before the first section: [ runparams.par_begin ; eppit )
}
-DocBookInfoTag getParagraphsWithInfo(ParagraphList const ¶graphs, pit_type const bpit, pit_type const epit) {
+bool hasOnlyNotes(Paragraph const & par)
+{
+ // Precondition: the paragraph is not empty. Otherwise, the function will always return true...
+ for (int i = 0; i < par.size(); ++i)
+ // If you find something that is not an inset (like actual text) or an inset that is not a note,
+ // return false.
+ if (!par.isInset(i) || !dynamic_cast<InsetNote *>(par.insetList().get(i)))
+ return false;
+ return true;
+}
+
+
+DocBookInfoTag getParagraphsWithInfo(ParagraphList const ¶graphs,
+ pit_type bpit, pit_type const epit,
+ // Typically, bpit is the beginning of the document and epit the end *or* the first section.
+ bool documentHasSections) {
set<pit_type> shouldBeInInfo;
set<pit_type> mustBeInInfo;
+ set<pit_type> abstractWithLayout;
+ set<pit_type> abstractNoLayout;
+
+ // Find the first non empty paragraph by mutating bpit.
+ while (bpit < epit) {
+ Paragraph const &par = paragraphs[bpit];
+ if (par.empty() || hasOnlyNotes(par))
+ bpit += 1;
+ else
+ break;
+ }
+ // Traverse everything that might belong to <info>.
+ bool hasAbstractLayout = false;
pit_type cpit = bpit;
- while (cpit < epit) {
- // Skip paragraphs only containing one note.
- Paragraph const &par = paragraphs[cpit];
- if (par.size() == 1 && dynamic_cast<InsetNote*>(paragraphs[cpit].insetList().get(0))) {
- cpit += 1;
+ for (; cpit < epit; ++cpit) {
+ // Skip paragraphs that don't generate anything in DocBook.
+ Paragraph const & par = paragraphs[cpit];
+ if (par.empty() || par.emptyTag() || hasOnlyNotes(par))
+ continue;
+
+ // There should never be any section here. (Just a sanity check: if this fails, this function could end up
+ // processing the whole document.)
+ if (isLayoutSectioning(par.layout())) {
+ LYXERR0("Assertion failed: section found in potential <info> paragraphs.");
+ break;
+ }
+
+ // If this is marked as an abstract by the layout, put it in the right set.
+ if (par.layout().docbookabstract()) {
+ hasAbstractLayout = true;
+ abstractWithLayout.emplace(cpit);
continue;
}
- // Based on layout information, store this paragraph in one set: should be in <info>, must be.
+ // Based on layout information, store this paragraph in one set: should be in <info>, must be,
+ // or abstract ().
Layout const &style = par.layout();
- if (style.docbookininfo() == "always") {
+ if (style.docbookininfo() == "always")
mustBeInInfo.emplace(cpit);
- } else if (style.docbookininfo() == "maybe") {
+ else if (style.docbookininfo() == "maybe")
shouldBeInInfo.emplace(cpit);
- } else {
- // Hypothesis: the <info> parts should be grouped together near the beginning bpit.
+ else if (!hasAbstractLayout)
+ abstractNoLayout.emplace(cpit);
+ else // This should definitely not be in <info>.
break;
- }
- cpit += 1;
}
- // Now, cpit points to the last paragraph that has things that could go in <info>.
- // bpit is still the beginning of the <info> part.
+ // Now, cpit points to the first paragraph that no more has things that could go in <info>.
+ // bpit is the beginning of the <info> part.
- return make_tuple(shouldBeInInfo, mustBeInInfo, bpit, cpit);
+ return DocBookInfoTag(shouldBeInInfo, mustBeInInfo,
+ hasAbstractLayout ? abstractWithLayout : abstractNoLayout,
+ hasAbstractLayout, bpit, cpit);
}
+} // end anonymous namespace
-bool hasAbstractBetween(ParagraphList const ¶graphs, pit_type const bpitAbstract, pit_type const epitAbstract)
+
+xml::FontTag docbookStartFontTag(xml::FontTypes type)
{
- // Hypothesis: the paragraphs between bpitAbstract and epitAbstract can be considered an abstract because they
- // are just after a document or part title.
- if (epitAbstract - bpitAbstract <= 0)
- return false;
-
- // If there is something between these paragraphs, check if it's compatible with an abstract (i.e. some text).
- pit_type bpit = bpitAbstract;
- while (bpit < epitAbstract) {
- const Paragraph &p = paragraphs.at(bpit);
-
- if (p.layout().name() == from_ascii("Abstract"))
- return true;
-
- if (!p.insetList().empty()) {
- for (const auto &i : p.insetList()) {
- if (i.inset->getText(0) != nullptr) {
- return true;
- }
- }
- }
- bpit++;
- }
- return false;
+ return xml::FontTag(from_utf8(fontToDocBookTag(type)), from_utf8(fontToAttribute(type)), type);
}
-pit_type generateDocBookParagraphWithoutSectioning(
- Text const & text,
- Buffer const & buf,
- XMLStream & xs,
- OutputParams const & runparams,
- ParagraphList const & paragraphs,
- pit_type bpit,
- pit_type epit)
+xml::EndFontTag docbookEndFontTag(xml::FontTypes type)
{
- auto par = paragraphs.iterator_at(bpit);
- auto lastStartedPar = par;
- ParagraphList::const_iterator send;
- auto const pend =
- (epit == (int) paragraphs.size()) ?
- paragraphs.end() : paragraphs.iterator_at(epit);
-
- while (bpit < epit) {
- tie(par, send) = makeAny(text, buf, xs, runparams, par, send, pend);
- bpit += distance(lastStartedPar, par);
- lastStartedPar = par;
- }
-
- return bpit;
+ return xml::EndFontTag(from_utf8(fontToDocBookTag(type)), type);
}
XMLStream & xs,
OutputParams const & runparams,
ParagraphList const & paragraphs,
- DocBookInfoTag const & info,
- pit_type bpitAbstract,
- pit_type const epitAbstract)
+ DocBookInfoTag const & info)
{
- // Consider everything between bpitAbstract and epitAbstract (excluded) as paragraphs for the abstract.
- // Use bpitAbstract >= epitAbstract to indicate there is no abstract.
-
- set<pit_type> shouldBeInInfo;
- set<pit_type> mustBeInInfo;
- pit_type bpitInfo;
- pit_type epitInfo;
- tie(shouldBeInInfo, mustBeInInfo, bpitInfo, epitInfo) = info;
+ // Perform an additional check on the abstract. Sometimes, there are many paragraphs that should go
+ // into the abstract, but none generates actual content. Thus, first generate to a temporary stream,
+ // then only create the <abstract> tag if these paragraphs generate some content.
+ // This check must be performed *before* a decision on whether or not to output <info> is made.
+ bool hasAbstract = !info.abstract.empty();
+ docstring abstract;
+ if (hasAbstract) {
+ // Generate the abstract XML into a string before further checks.
+ odocstringstream os2;
+ XMLStream xs2(os2);
+ for (auto const & p : info.abstract)
+ makeAny(text, buf, xs2, runparams, paragraphs.iterator_at(p));
+
+ // Actually output the abstract if there is something to do. Don't count line feeds or spaces in this,
+ // even though they must be properly output if there is some abstract.
+ abstract = os2.str();
+ docstring cleaned = abstract;
+ cleaned.erase(std::remove_if(cleaned.begin(), cleaned.end(), ::isspace), cleaned.end());
+
+ // Nothing? Then there is no abstract!
+ if (cleaned.empty())
+ hasAbstract = false;
+ }
- // The abstract must go in <info>.
- bool hasAbstract = hasAbstractBetween(paragraphs, bpitAbstract, epitAbstract);
- bool needInfo = !mustBeInInfo.empty() || hasAbstract;
+ // The abstract must go in <info>. Otherwise, decide whether to open <info> based on the layouts.
+ bool needInfo = !info.mustBeInInfo.empty() || hasAbstract;
// Start the <info> tag if required.
if (needInfo) {
xs << xml::CR();
}
- // Output the elements that should go in <info>.
- generateDocBookParagraphWithoutSectioning(text, buf, xs, runparams, paragraphs, bpitInfo, epitInfo);
+ // Output the elements that should go in <info>, before and after the abstract.
+ for (auto pit : info.shouldBeInInfo) // Typically, the title: these elements are so important and ubiquitous
+ // that mandating a wrapper like <info> would repel users. Thus, generate them first.
+ makeAny(text, buf, xs, runparams, paragraphs.iterator_at(pit));
+ for (auto pit : info.mustBeInInfo)
+ if (info.abstract.find(pit) == info.abstract.end()) // The abstract must be in info, but is dealt with after.
+ makeAny(text, buf, xs, runparams, paragraphs.iterator_at(pit));
+ // Always output the abstract as the last item of the <info>, as it requires special treatment (especially if
+ // it contains several paragraphs that are empty).
if (hasAbstract) {
- string tag = paragraphs[bpitAbstract].layout().docbookforceabstracttag();
- if (tag == "NONE")
- tag = "abstract";
+ if (info.abstractLayout) {
+ xs << XMLStream::ESCAPE_NONE << abstract;
+ xs << xml::CR();
+ } else {
+ string tag = paragraphs[*info.abstract.begin()].layout().docbookforceabstracttag();
+ if (tag == "NONE")
+ tag = "abstract";
- xs << xml::StartTag(tag);
- xs << xml::CR();
- xs.startDivision(false);
- generateDocBookParagraphWithoutSectioning(text, buf, xs, runparams, paragraphs, bpitAbstract, epitAbstract);
- xs.endDivision();
- xs << xml::EndTag(tag);
- xs << xml::CR();
+ if (!xs.isLastTagCR())
+ xs << xml::CR();
+
+ xs << xml::StartTag(tag);
+ xs << xml::CR();
+ xs << XMLStream::ESCAPE_NONE << abstract;
+ xs << xml::EndTag(tag);
+ xs << xml::CR();
+ }
}
// End the <info> tag if it was started.
}
-void docbookFirstParagraphs(
- Text const &text,
- Buffer const &buf,
- XMLStream &xs,
- OutputParams const &runparams,
- pit_type epit)
-{
- // Handle the beginning of the document, supposing it has sections.
- // Major role: output the first <info> tag.
-
- ParagraphList const ¶graphs = text.paragraphs();
- pit_type bpit = runparams.par_begin;
- DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit);
- outputDocBookInfo(text, buf, xs, runparams, paragraphs, info, get<3>(info), epit);
-}
-
-
-bool isParagraphEmpty(const Paragraph &par)
-{
- InsetList const &insets = par.insetList();
- size_t insetsLength = distance(insets.begin(), insets.end());
- bool hasParagraphOnlyNote = insetsLength == 1 && insets.get(0) && insets.get(0)->asInsetCollapsible() &&
- dynamic_cast<InsetNote *>(insets.get(0));
- return hasParagraphOnlyNote;
-}
-
-
void docbookSimpleAllParagraphs(
Text const & text,
Buffer const & buf,
XMLStream & xs,
OutputParams const & runparams)
{
- // Handle the document, supposing it has no sections (i.e. a "simple" document).
+ // Handle the given text, supposing it has no sections (i.e. a "simple" text). The input may vary in length
+ // between a single paragraph to a whole document.
// First, the <info> tag.
ParagraphList const ¶graphs = text.paragraphs();
pit_type bpit = runparams.par_begin;
pit_type const epit = runparams.par_end;
- DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit);
- outputDocBookInfo(text, buf, xs, runparams, paragraphs, info, 0, 0);
- bpit = get<3>(info); // Generate the content starting from the end of the <info> part.
-
- // Then, the content.
- ParagraphList::const_iterator const pend =
- (epit == (int) paragraphs.size()) ?
- paragraphs.end() : paragraphs.iterator_at(epit);
-
- while (bpit < epit) {
- auto par = paragraphs.iterator_at(bpit);
- ParagraphList::const_iterator const lastStartedPar = par;
- ParagraphList::const_iterator send;
-
- if (isParagraphEmpty(*par)) {
+ DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, epit, false);
+ outputDocBookInfo(text, buf, xs, runparams, paragraphs, info);
+
+ // Then, the content. It starts where the <info> ends.
+ auto par = text.paragraphs().iterator_at(info.epit);
+ auto end = text.paragraphs().iterator_at(epit);
+ while (par != end) {
+ if (!hasOnlyNotes(*par))
+ par = makeAny(text, buf, xs, runparams, par);
+ else
++par;
- bpit += distance(lastStartedPar, par);
- continue;
- }
-
- // Generate this paragraph.
- tie(par, send) = makeAny(text, buf, xs, runparams, par, send, pend);
- bpit += distance(lastStartedPar, par);
}
}
return;
});
- ParagraphList::const_iterator const pend =
- (epit == (int) paragraphs.size()) ?
- paragraphs.end() : paragraphs.iterator_at(epit);
std::stack<std::pair<int, string>> headerLevels; // Used to determine when to open/close sections: store the depth
// of the section and the tag that was used to open it.
- // Detect whether the document contains sections. If there are no sections, there can be no automatically
- // discovered abstract.
+ // Detect whether the document contains sections. If there are no sections, treatment is largely simplified.
+ // In particular, there can't be an abstract, unless it is manually marked.
bool documentHasSections;
pit_type eppit;
tie(documentHasSections, eppit) = hasDocumentSectioning(paragraphs, bpit, epit);
- if (documentHasSections) {
- docbookFirstParagraphs(text, buf, xs, runparams, eppit);
- bpit = eppit;
- } else {
+ // Deal with "simple" documents, i.e. those without sections.
+ if (!documentHasSections){
docbookSimpleAllParagraphs(text, buf, xs, runparams);
return;
}
+ // Output the first <info> tag (or just the title).
+ DocBookInfoTag info = getParagraphsWithInfo(paragraphs, bpit, eppit, true);
+ outputDocBookInfo(text, buf, xs, runparams, paragraphs, info);
+ bpit = eppit;
+
+ // Then, iterate through the paragraphs of this document.
bool currentlyInAppendix = false;
- while (bpit < epit) {
+ auto par = text.paragraphs().iterator_at(bpit);
+ auto end = text.paragraphs().iterator_at(epit);
+ while (par != end) {
OutputParams ourparams = runparams;
- auto par = paragraphs.iterator_at(bpit);
if (par->params().startOfAppendix())
currentlyInAppendix = true;
- Layout const &style = par->layout();
- ParagraphList::const_iterator const lastStartedPar = par;
- ParagraphList::const_iterator send;
-
- if (isParagraphEmpty(*par)) {
+ if (hasOnlyNotes(*par)) {
++par;
- bpit += distance(lastStartedPar, par);
continue;
}
+ Layout const &style = par->layout();
+
// Think about adding <section> and/or </section>s.
- const bool isLayoutSectioning = style.category() == from_utf8("Sectioning");
- if (isLayoutSectioning) {
+ if (isLayoutSectioning(style)) {
int level = style.toclevel;
// Need to close a previous section if it has the same level or a higher one (close <section> if opening a <h2>
}
// Generate this paragraph.
- tie(par, send) = makeAny(text, buf, xs, ourparams, par, send, pend);
- bpit += distance(lastStartedPar, par);
+ par = makeAny(text, buf, xs, ourparams, par);
}
// If need be, close <section>s, but only at the end of the document (otherwise, dealt with at the beginning
}
}
-} // namespace lyx
+} // namespace lyx
\ No newline at end of file
projects / features.git / blobdiff