#include <config.h>
+#include "output_docbook.h"
+
#include "Buffer.h"
#include "buffer_funcs.h"
#include "BufferParams.h"
#include "insets/InsetBibtex.h"
#include "insets/InsetBibitem.h"
#include "insets/InsetLabel.h"
+#include "mathed/InsetMath.h"
#include "insets/InsetNote.h"
#include "support/lassert.h"
+#include "support/textutils.h"
#include <stack>
#include <iostream>
case xml::FontTypes::FT_BOLD:
return "emphasis";
case xml::FontTypes::FT_NOUN:
- return "person";
+ return "personname";
case xml::FontTypes::FT_UBAR:
case xml::FontTypes::FT_WAVE:
case xml::FontTypes::FT_DBAR:
if (prevpar != nullptr) {
Layout const & prevlay = prevpar->layout();
if (prevlay.docbookwrappertag() != "NONE") {
- if (prevlay.docbookwrappertag() == lay.docbookwrappertag())
+ if (prevlay.docbookwrappertag() == lay.docbookwrappertag() &&
+ prevlay.docbookwrapperattr() == lay.docbookwrapperattr())
openWrapper = !lay.docbookwrappermergewithprevious();
else
openWrapper = true;
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.
+ 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());
+ openTag(xs, lay.docbookinnertag(), lay.docbookinnerattr(), lay.docbookinnertagtype());
+ }
}
openTag(xs, lay.docbookitemtag(), lay.docbookitemattr(), lay.docbookitemtagtype());
if (nextpar != nullptr) {
Layout const & nextlay = nextpar->layout();
if (nextlay.docbookwrappertag() != "NONE") {
- if (nextlay.docbookwrappertag() == lay.docbookwrappertag())
+ if (nextlay.docbookwrappertag() == lay.docbookwrappertag() &&
+ nextlay.docbookwrapperattr() == lay.docbookwrapperattr())
closeWrapper = !nextlay.docbookwrappermergewithprevious();
else
closeWrapper = true;
// Main logic.
closeTag(xs, lay.docbookiteminnertag(), lay.docbookiteminnertagtype());
closeTag(xs, lay.docbookitemtag(), lay.docbookitemtagtype());
+ closeTag(xs, lay.docbookinnertag(), lay.docbookinnertagtype());
closeTag(xs, lay.docbooktag(), lay.docbooktagtype());
if (closeWrapper)
closeTag(xs, lay.docbookwrappertag(), lay.docbookwrappertagtype());
}
-void openLabelTag(XMLStream & xs, Layout const & lay) // Mostly for definition lists.
-{
- openTag(xs, lay.docbookitemlabeltag(), lay.docbookitemlabelattr(), lay.docbookitemlabeltagtype());
-}
-
-
-void closeLabelTag(XMLStream & xs, Layout const & lay)
-{
- closeTag(xs, lay.docbookitemlabeltag(), lay.docbookitemlabeltagtype());
-}
-
-
-void openItemTag(XMLStream & xs, Layout const & lay)
-{
- openTag(xs, lay.docbookitemtag(), lay.docbookitemattr(), lay.docbookitemtagtype());
-}
-
-
-void closeItemTag(XMLStream & xs, Layout const & lay)
-{
- closeTag(xs, lay.docbookitemtag(), lay.docbookitemtagtype());
-}
-
-
-ParagraphList::const_iterator makeAny(Text const &,
- Buffer const &,
- XMLStream &,
- OutputParams const &,
- ParagraphList::const_iterator);
-
-
void makeBibliography(
Text const & text,
Buffer const & buf,
ParagraphList::const_iterator const & par)
{
// If this is the first paragraph in a bibliography, open the bibliography tag.
- auto pbegin_before = text.paragraphs().getParagraphBefore(par);
- if (pbegin_before->layout().latextype != LATEX_BIB_ENVIRONMENT) {
+ auto const * pbegin_before = text.paragraphs().getParagraphBefore(par);
+ if (pbegin_before == nullptr || (pbegin_before && pbegin_before->layout().latextype != LATEX_BIB_ENVIRONMENT)) {
xs << xml::StartTag("bibliography");
xs << xml::CR();
}
// 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();
+ // Exception: any case that generates an <inlineequation> must still get a paragraph to be valid.
+ special_case |= nInsets == (size_t) par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset && inset.inset->asInsetMath() && inset.inset->asInsetMath()->getType() != hullSimple;
+ });
+ // Floats cannot be in paragraphs.
+ special_case |= nInsets == (size_t) par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset->lyxCode() == FLOAT_CODE;
+ });
+ // Bibliographies cannot be in paragraphs. Bibitems should still be handled as paragraphs, though
+ // (see makeParagraphBibliography).
+ special_case |= nInsets == (size_t) par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset->lyxCode() == BIBTEX_CODE;
+ });
+ // ERTs are in comments, not paragraphs.
+ special_case |= nInsets == (size_t) par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset->lyxCode() == ERT_CODE;
+ });
+ // Listings should not get into their own paragraph.
+ special_case |= nInsets == (size_t) par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset->lyxCode() == LISTINGS_CODE;
+ });
+ // Boxes cannot get into their own paragraph.
+ special_case |= nInsets == (size_t) par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset->lyxCode() == BOX_CODE;
+ });
+ // Includes should not have a paragraph.
+ special_case |= nInsets == (size_t) par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
+ return inset.inset->lyxCode() == INCLUDE_CODE;
});
-
- // 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);
-
- // Floats cannot be in paragraphs.
- special_case = to_utf8(firstInset->layoutName()).substr(0, 6) == "Float:";
-
- // Bibliographies cannot be in paragraphs.
- if (!special_case && firstInset->asInsetCommand())
- special_case = firstInset->asInsetCommand()->params().getCmdName() == "bibtex";
-
- // 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
auto nextpar = par;
++nextpar;
auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(distance(begin, par)), 0, nextpar == end, special_case);
- for (auto & parXML : pars) {
- if (!std::all_of(parXML.begin(), parXML.end(), ::isspace)) {
+ for (docstring const & parXML : pars) {
+ if (xml::isNotOnlySpace(parXML)) {
if (open_par)
openParTag(xs, &*par, prevpar);
OutputParams const &runparams,
ParagraphList::const_iterator const & par)
{
- // TODO: simplify me!
auto const end = text.paragraphs().end();
+ auto nextpar = par;
+ ++nextpar;
+
+ // Special cases for listing-like environments provided in layouts. This is quite ad-hoc, but provides a useful
+ // default. This should not be used by too many environments (only LyX-Code right now).
+ // This would be much simpler if LyX-Code was implemented as InsetListings...
+ bool mimicListing = false;
+ bool ignoreFonts = false;
+ if (par->layout().docbooktag() == "programlisting") {
+ mimicListing = true;
+ ignoreFonts = true;
+ }
// Output the opening tag for this environment, but only if it has not been previously opened (condition
// implemented in openParTag).
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();
+ // Generate the paragraph, if need be.
+ auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(std::distance(text.paragraphs().begin(), par)), 0, false, ignoreFonts);
- 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);
- }
- }
-
- // 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 (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);
+ if (mimicListing) {
auto p = pars.begin();
- while (true) {
+ while (p != pars.end()) {
+ openTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnerattr(), par->layout().docbookiteminnertagtype());
xs << XMLStream::ESCAPE_NONE << *p;
+ closeTag(xs, par->layout().docbookiteminnertag(), par->layout().docbookiteminnertagtype());
++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;
+
+ if (p != pars.end())
+ xs << xml::CR();
+ }
+ } else {
+ for (auto const & 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 {
}
// Close the environment.
- auto nextpar = par;
- ++nextpar;
closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr); // TODO: switch in layout for par/block?
}
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);
+ openTag(xs, style.docbookitemlabeltag(), style.docbookitemlabelattr(), style.docbookitemlabeltagtype());
sep = 1 + par->firstWordDocBook(xs, runparams);
- closeLabelTag(xs, style);
+ closeTag(xs, style.docbookitemlabeltag(), style.docbookitemlabeltagtype());
} 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);
+ openTag(xs, style.docbookitemlabeltag(), style.docbookitemlabelattr(), style.docbookitemlabeltagtype());
xs << lbl;
- closeLabelTag(xs, style);
+ closeTag(xs, style.docbookitemlabeltag(), style.docbookitemlabeltagtype());
}
}
}
}
-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;
- }
- ++par;
- return par;
-}
-
-
bool isLayoutSectioning(Layout const & lay)
{
return lay.category() == from_utf8("Sectioning");
} // end anonymous namespace
+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;
+ }
+ ++par;
+ return par;
+}
+
+
xml::FontTag docbookStartFontTag(xml::FontTypes type)
{
return xml::FontTag(from_utf8(fontToDocBookTag(type)), from_utf8(fontToAttribute(type)), type);
// 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());
+ cleaned.erase(std::remove_if(cleaned.begin(), cleaned.end(), lyx::isSpace), cleaned.end());
// Nothing? Then there is no abstract!
if (cleaned.empty())
for (auto pit : info.mustBeInInfo)
makeAny(text, buf, xs, runparams, paragraphs.iterator_at(pit));
+ // If there is no title, generate one (required for the document to be valid).
+ // This code is called for the main document, for table cells, etc., so be precise in this condition.
+ if (text.isMainText() && info.shouldBeInInfo.empty() && !runparams.inInclude) {
+ xs << xml::StartTag("title");
+ xs << "Untitled Document";
+ xs << xml::EndTag("title");
+ xs << xml::CR();
+ }
+
// 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) {
// Close all sections before the bibliography.
// TODO: Only close all when the bibliography is at the end of the document? Or force to output the bibliography at the end of the document? Or don't care (as allowed by DocBook)?
- auto insetsLength = distance(par->insetList().begin(), par->insetList().end());
- if (insetsLength > 0) {
+ if (!par->insetList().empty()) {
Inset const *firstInset = par->getInset(0);
if (firstInset && (firstInset->lyxCode() == BIBITEM_CODE || firstInset->lyxCode() == BIBTEX_CODE)) {
while (!headerLevels.empty()) {