DocBook: specific fix for Localization_Test.lyx.

[features.git] / src / output_docbook.cpp

diff --git a/src/output_docbook.cpp b/src/output_docbook.cpp
index 58e1b810f1b43cd4e6b0fd1e52b39eb3703a67f9..ae65aedbe50fdd8c62f4ecbef009a987632c5a92 100644 (file)
--- a/src/output_docbook.cpp
+++ b/src/output_docbook.cpp
@@ -412,6 +412,11 @@ void makeParagraph(
                OutputParams const & runparams,
                ParagraphList::const_iterator const & par)
 {
+       // If this kind of layout should be ignored, already leave.
+       if (par->layout().docbooktag() == "IGNORE")
+               return;
+
+       // Useful variables.
        auto const begin = text.paragraphs().begin();
        auto const end = text.paragraphs().end();
        auto prevpar = text.paragraphs().getParagraphBefore(par);
@@ -445,42 +450,55 @@ void makeParagraph(
        }
 
        size_t nInsets = std::distance(par->insetList().begin(), par->insetList().end());
+       auto parSize = (size_t) par->size();
+
+       auto isLyxCodeToIgnore = [](InsetCode x) { return x == TOC_CODE; }; // If this LyX code does not produce any output,
+       // it can be safely ignored in the following checks: if this thing is present in the paragraph, it has no impact
+       // on the definition of the special case (i.e. whether or not a <para> tag should be output).
+
+       // TODO: if a paragraph *only* contains floats, listings, bibliographies, etc., should this be considered as a
+       //  special case? If so, the code could be largely simplifies (all the calls to all_of, basically) and optimised
+       //  at the compilation stage.
 
        // 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).
        // 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) {
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
                return inset.inset && inset.inset->asInsetMath() && inset.inset->asInsetMath()->getType() != hullSimple;
        });
-       // Tables doe not deserve their own paragraphs (DocBook allows them outside paragraphs).
-       special_case |= nInsets == (size_t) par->size() && std::all_of(par->insetList().begin(), par->insetList().end(), [](InsetList::Element inset) {
-               return inset.inset->lyxCode() == TABULAR_CODE;
+       // Tables do not deserve their own paragraphs (DocBook allows them outside paragraphs).
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [isLyxCodeToIgnore](InsetList::Element inset) {
+               return inset.inset->lyxCode() == TABULAR_CODE || isLyxCodeToIgnore(inset.inset->lyxCode());
        });
        // 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;
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [isLyxCodeToIgnore](InsetList::Element inset) {
+               return inset.inset->lyxCode() == FLOAT_CODE || isLyxCodeToIgnore(inset.inset->lyxCode());
        });
        // 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;
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [isLyxCodeToIgnore](InsetList::Element inset) {
+               return inset.inset->lyxCode() == BIBTEX_CODE || isLyxCodeToIgnore(inset.inset->lyxCode());
        });
        // 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;
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [isLyxCodeToIgnore](InsetList::Element inset) {
+               return inset.inset->lyxCode() == ERT_CODE || isLyxCodeToIgnore(inset.inset->lyxCode());
        });
        // 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;
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [isLyxCodeToIgnore](InsetList::Element inset) {
+               return inset.inset->lyxCode() == LISTINGS_CODE || isLyxCodeToIgnore(inset.inset->lyxCode());
        });
        // 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;
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [isLyxCodeToIgnore](InsetList::Element inset) {
+               return inset.inset->lyxCode() == BOX_CODE || isLyxCodeToIgnore(inset.inset->lyxCode());
        });
        // 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;
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [isLyxCodeToIgnore](InsetList::Element inset) {
+               return inset.inset->lyxCode() == INCLUDE_CODE || isLyxCodeToIgnore(inset.inset->lyxCode());
+       });
+       // Glossaries should not have a paragraph.
+       special_case |= nInsets == parSize && std::all_of(par->insetList().begin(), par->insetList().end(), [isLyxCodeToIgnore](InsetList::Element inset) {
+               return inset.inset->lyxCode() == NOMENCL_PRINT_CODE || isLyxCodeToIgnore(inset.inset->lyxCode());
        });
 
        bool const open_par = runparams.docbook_make_pars
@@ -503,15 +521,16 @@ void makeParagraph(
        ++nextpar;
        auto pars = par->simpleDocBookOnePar(buf, runparams, text.outerFont(distance(begin, par)), 0, nextpar == end, special_case);
        for (docstring const & parXML : pars) {
-               if (xml::isNotOnlySpace(parXML)) {
-                       if (open_par)
-                               openParTag(xs, &*par, prevpar);
+               if (!xml::isNotOnlySpace(parXML))
+                       continue;
 
-                       xs << XMLStream::ESCAPE_NONE << parXML;
+               if (open_par)
+                       openParTag(xs, &*par, prevpar);
 
-                       if (close_par)
-                               closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
-               }
+               xs << XMLStream::ESCAPE_NONE << parXML;
+
+               if (close_par)
+                       closeParTag(xs, &*par, (nextpar != end) ? &*nextpar : nullptr);
        }
 }
 
@@ -522,6 +541,11 @@ void makeEnvironment(Text const &text,
                      OutputParams const &runparams,
                      ParagraphList::const_iterator const & par)
 {
+       // If this kind of layout should be ignored, already leave.
+       if (par->layout().docbooktag() == "IGNORE")
+               return;
+
+       // Useful variables.
        auto const end = text.paragraphs().end();
        auto nextpar = par;
        ++nextpar;
@@ -618,10 +642,18 @@ ParagraphList::const_iterator makeListEnvironment(Text const &text,
                                                          OutputParams const &runparams,
                                                          ParagraphList::const_iterator const & begin)
 {
+       // Useful variables.
        auto par = begin;
        auto const end = text.paragraphs().end();
        auto const envend = findEndOfEnvironment(par, end);
 
+       // If this kind of layout should be ignored, already leave.
+       if (begin->layout().docbooktag() == "IGNORE") {
+               auto nextpar = par;
+               ++nextpar;
+               return nextpar;
+       }
+
        // Output the opening tag for this environment.
        Layout const & envstyle = par->layout();
        openTag(xs, envstyle.docbookwrappertag(), envstyle.docbookwrapperattr(), envstyle.docbookwrappertagtype());
@@ -708,6 +740,11 @@ void makeCommand(
                OutputParams const & runparams,
                ParagraphList::const_iterator const & par)
 {
+       // If this kind of layout should be ignored, already leave.
+       if (par->layout().docbooktag() == "IGNORE")
+               return;
+
+       // Useful variables.
        // 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();