Fix problem with branch handling. The problem was that we were not

dealing properly with the paragraph separator tag.

We really need to use that tag as a kind of general marker for which
tags we're responsible for in a given paragraph and which tags we are
not. So the changes to InsetText.cpp use the tag as that kind of marker.

Note that, as of this commit, the User Guide again exports without any
kind of error. I haven't yet checked the other manuals.

This fixes bug #8022.

(cherry picked from commit 31e25c8ec695f864bec3679c3e11495e3011a0e2)

diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp
index 0d1c8d3047b269073869c665a5019d8037433927..23315204be40093b5a989c1e60ad05d552e819fd 100644 (file)
--- a/src/Paragraph.cpp
+++ b/src/Paragraph.cpp
@@ -2760,7 +2760,8 @@ void doFontSwitch(vector<html::FontTag> & tagsToOpen,
 docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                                    XHTMLStream & xs,
                                    OutputParams const & runparams,
-                                   Font const & outerfont,
+                                   Font const & outerfont, 
+                                   bool start_paragraph, bool close_paragraph,
                                    pos_type initial) const
 {
        docstring retval;
@@ -2782,7 +2783,8 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
 
        Layout const & style = *d->layout_;
 
-       xs.startParagraph(allowEmpty());
+       if (start_paragraph)
+               xs.startParagraph(allowEmpty());
 
        FontInfo font_old =
                style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
@@ -3068,7 +3070,9 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                        if (!runparams.for_toc || inset->isInToc()) {
                                OutputParams np = runparams;
                                np.local_font = &font;
-                               if (!inset->getLayout().htmlisblock())
+                               // If the paragraph has size 1, then we are in the "special
+                               // case" where we do not output the containing paragraph info
+                               if (!inset->getLayout().htmlisblock() && size() != 1)
                                        np.html_in_par = true;
                                retval += inset->xhtml(xs, np);
                        }
@@ -3079,8 +3083,13 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & buf,
                font_old = font.fontInfo();
        }
 
+       // FIXME XHTML
+       // I'm worried about what happens if a branch, say, is itself
+       // wrapped in some font stuff. I think that will not work.
        xs.closeFontTags();
-       xs.endParagraph();
+       if (close_paragraph)
+               xs.endParagraph();
+
        return retval;
 }
 

diff --git a/src/Paragraph.h b/src/Paragraph.h
index ce9710ed05a851141c74232aecf88e6f06d5cff2..bfb43e94745410dc52091b4022c5aaef1c0b3d4b 100644 (file)
--- a/src/Paragraph.h
+++ b/src/Paragraph.h
@@ -222,6 +222,8 @@ public:
                                 XHTMLStream & xs,
                                 OutputParams const & runparams,
                                 Font const & outerfont,
+                                bool start_paragraph = true,
+                                bool close_paragraph = true,
                                 pos_type initial = 0) const;
 
        ///

diff --git a/src/insets/InsetText.cpp b/src/insets/InsetText.cpp
index 660826309f33931a0121a51113a65a9c8a08c009..cf896043e9020d8f7d6d452adf1867b09dc04174 100644 (file)
--- a/src/insets/InsetText.cpp
+++ b/src/insets/InsetText.cpp
@@ -588,7 +588,9 @@ docstring InsetText::insetAsXHTML(XHTMLStream & xs, OutputParams const & rp,
        runparams.par_end = text().paragraphs().size();
        
        if (undefined()) {
+               xs.startParagraph(false);
                xhtmlParagraphs(text_, buffer(), xs, runparams);
+               xs.endParagraph();
                return docstring();
        }
 
@@ -622,7 +624,9 @@ docstring InsetText::insetAsXHTML(XHTMLStream & xs, OutputParams const & rp,
        if (il.isPassThru())
                runparams.pass_thru = true;
 
+       xs.startParagraph(false);
        xhtmlParagraphs(text_, buffer(), xs, runparams);
+       xs.endParagraph();
 
        if (opts & WriteInnerTag)
                xs << html::EndTag(il.htmlinnertag());

diff --git a/src/output_xhtml.cpp b/src/output_xhtml.cpp
index c6b3c7875dbecf0759aa024b3e17b9433b0a2f0a..da199111c9820c618aabd3f3b0490739b6473e47 100644 (file)
--- a/src/output_xhtml.cpp
+++ b/src/output_xhtml.cpp
@@ -832,25 +832,26 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
                if (!lay.counter.empty())
                        buf.masterBuffer()->params().
                            documentClass().counters().step(lay.counter, OutputUpdate);
+
                // FIXME We should see if there's a label to be output and
                // do something with it.
                if (par != pbegin)
                        xs << html::CR();
 
-               // If we are already in a paragraph, and this is the first one, then we
-               // do not want to open the paragraph tag.
-               // we also do not want to open it if the current layout does not permit
-               // multiple paragraphs.
-               bool const opened = runparams.html_make_pars &&
-                       (par != pbegin || !runparams.html_in_par);
-               bool const make_parid = !runparams.for_toc && runparams.html_make_pars;
-
-               if (opened)
-                       openParTag(xs, lay, par->params(),
-                                  make_parid ? par->magicLabel() : "");
-
-               docstring const deferred =
-                       par->simpleLyXHTMLOnePar(buf, xs, runparams, text.outerFont(distance(begin, 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 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). That is the "special case" we handle first.
+               Inset const * specinset = par->size() == 1 ? par->getInset(0) : 0;
+               bool const special_case =  
+                       specinset && !specinset->getLayout().htmlisblock();
+
+               bool const opened = runparams.html_make_pars
+                       && (!runparams.html_in_par || par != pbegin)
+                       && !special_case;
 
                // We want to issue the closing tag if either:
                //   (i)  We opened it, and either html_in_par is false,
@@ -862,13 +863,25 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
                bool const needclose =
                        (opened && (!runparams.html_in_par || nextpar != pend))
                        || (!opened && runparams.html_in_par && par == pbegin && nextpar != pend);
-               if (needclose) {
-                       closeTag(xs, lay);
-                       xs << html::CR();
+
+               if (opened) {
+                       // We do not issue the paragraph id if we are doing 
+                       // this for the TOC (or some similar purpose)
+                       openParTag(xs, lay, par->params(),
+                                  runparams.for_toc ? "" : par->magicLabel());
                }
+
+               docstring const deferred = par->simpleLyXHTMLOnePar(buf, xs, 
+                       runparams, text.outerFont(distance(begin, par)),
+                       opened, needclose);
+
                if (!deferred.empty()) {
                        xs << XHTMLStream::ESCAPE_NONE << deferred << html::CR();
                }
+               if (needclose) {
+                       closeTag(xs, lay);
+                       xs << html::CR();
+               }
        }
        return pend;
 }
@@ -995,7 +1008,7 @@ ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
                                        openItemTag(xs, style, par->params());
 
                                par->simpleLyXHTMLOnePar(buf, xs, runparams,
-                                       text.outerFont(distance(begin, par)), sep);
+                                       text.outerFont(distance(begin, par)), true, true, sep);
                                ++par;
 
                                // We may not want to close the tag yet, in particular:

diff --git a/status.22x b/status.22x
index d97237088ec6a249871033e79830ddd1dd5aff81..2660366e0eed95d07eae127c8d17282e111d08e6 100644 (file)
--- a/status.22x
+++ b/status.22x
@@ -71,6 +71,8 @@ What's new
 
 * LYXHTML
 
+Fix problem with output of branches (bug 8022).
+
 
 * TEX2LYX