The branch, master, has been updated.

- Log -----------------------------------------------------------------

commit ad56bb7286cabddefb4d2e470b833ac1874623a3
Author: Richard Heck <[email protected]>
Date:   Tue May 7 01:16:14 2013 -0400

    Rework how paragraph ids are handled.
    
    Previously, an empty paragraph would always yield something like:
        <div><a id='magicparid-35' /></div>
    because we had no way to "defer" the anchor tag. Now this is wrapped
    into the div, in effect, and we abandon it all if there's no content.

diff --git a/src/Paragraph.cpp b/src/Paragraph.cpp
index c7e6565..535506f 100644
--- a/src/Paragraph.cpp
+++ b/src/Paragraph.cpp
@@ -2864,12 +2864,6 @@ docstring Paragraph::simpleLyXHTMLOnePar(Buffer const & 
buf,
 
        xs.startParagraph(allowEmpty());
 
-       if (!runparams.for_toc && runparams.html_make_pars) {
-               // generate a magic label for this paragraph
-               string const attr = "id='" + magicLabel() + "'";
-               xs << html::CompTag("a", attr);
-       }
-
        FontInfo font_old =
                style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
 
diff --git a/src/output_xhtml.cpp b/src/output_xhtml.cpp
index 13e5c19..b06f8bd 100644
--- a/src/output_xhtml.cpp
+++ b/src/output_xhtml.cpp
@@ -46,7 +46,6 @@ namespace lyx {
 
 namespace html {
 
-
 docstring escapeChar(char_type c, XHTMLStream::EscapeSettings e)
 {
        docstring str;
@@ -174,6 +173,19 @@ docstring StartTag::asEndTag() const
 }
 
 
+docstring ParTag::asTag() const
+{
+       docstring output = StartTag::asTag();
+
+       if (parid_.empty())
+               return output;
+
+       string const pattr = "id='" + parid_ + "'";
+       output += html::CompTag("a", pattr).asTag();
+       return output;
+}
+
+
 docstring EndTag::asEndTag() const
 {
        string output = "</" + tag_ + ">";
@@ -398,6 +410,15 @@ XHTMLStream & XHTMLStream::operator<<(html::StartTag const 
& tag)
 }
 
 
+XHTMLStream & XHTMLStream::operator<<(html::ParTag const & tag)
+{
+       if (tag.tag_.empty())
+               return *this;
+       pending_tags_.push_back(makeTagPtr(tag));
+       return *this;
+}
+
+
 XHTMLStream & XHTMLStream::operator<<(html::CompTag const & tag) 
 {
        if (tag.tag_.empty())
@@ -611,6 +632,28 @@ void openTag(XHTMLStream & xs, Layout const & lay,
 }
 
 
+inline void openParTag(XHTMLStream & xs, Layout const & lay,
+                       std::string parlabel)
+{
+       xs << html::ParTag(lay.htmltag(), lay.htmlattr(), parlabel);
+}
+
+
+void openParTag(XHTMLStream & xs, Layout const & lay,
+                ParagraphParameters const & params,
+                std::string parlabel)
+{
+       // FIXME Are there other things we should handle here?
+       string const align = alignmentToCSS(params.align());
+       if (align.empty()) {
+               openParTag(xs, lay, parlabel);
+               return;
+       }
+       string attrs = lay.htmlattr() + " style='text-align: " + align + ";'";
+       xs << html::ParTag(lay.htmltag(), attrs, parlabel);
+}
+
+
 inline void closeTag(XHTMLStream & xs, Layout const & lay)
 {
        xs << html::EndTag(lay.htmltag());
@@ -721,8 +764,12 @@ ParagraphList::const_iterator makeParagraphs(Buffer const 
& buf,
                // 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)
-                       openTag(xs, lay, par->params());
+                       openParTag(xs, lay, par->params(),
+                                  make_parid ? par->magicLabel() : "");
+
                docstring const deferred = 
                        par->simpleLyXHTMLOnePar(buf, xs, runparams, 
text.outerFont(distance(begin, par)));
 
@@ -789,7 +836,7 @@ ParagraphList::const_iterator makeEnvironment(Buffer const 
& buf,
        depth_type const origdepth = pbegin->params().depth();
 
        // open tag for this environment
-       openTag(xs, bstyle);
+       openParTag(xs, bstyle, pbegin->magicLabel());
        xs << html::CR();
 
        // we will on occasion need to remember a layout from before.
@@ -930,7 +977,10 @@ void makeCommand(Buffer const & buf,
                buf.masterBuffer()->params().
                    documentClass().counters().step(style.counter, 
OutputUpdate);
 
-       openTag(xs, style, pbegin->params());
+       bool const make_parid = !runparams.for_toc && runparams.html_make_pars;
+
+       openParTag(xs, style, pbegin->params(),
+                  make_parid ? pbegin->magicLabel() : "");
 
        // Label around sectioning number:
        // FIXME Probably need to account for LABEL_MANUAL
diff --git a/src/output_xhtml.h b/src/output_xhtml.h
index 99d07be..ceabc42 100644
--- a/src/output_xhtml.h
+++ b/src/output_xhtml.h
@@ -32,17 +32,20 @@ class Text;
 namespace html {
 /// Attributes will be escaped automatically and so should NOT
 /// be escaped before being passed to the constructor.
-struct StartTag {
+struct StartTag
+{
        ///
        explicit StartTag(std::string const & tag) : tag_(tag), 
keepempty_(false) {}
        ///
        explicit StartTag(std::string const & tag, std::string const & attr, 
                bool keepempty = false) 
                : tag_(tag), attr_(attr), keepempty_(keepempty) {}
+       ///
+       ~StartTag() {}
        /// <tag_ attr_>
-       docstring asTag() const;
+       virtual docstring asTag() const;
        /// </tag_>
-       docstring asEndTag() const;
+       virtual docstring asEndTag() const;
        ///
        std::string tag_;
        ///
@@ -53,7 +56,25 @@ struct StartTag {
 };
 
 
-struct EndTag {
+/// A special case of StartTag, used exclusively for tags that wrap paragraphs.
+struct ParTag : public StartTag
+{
+       ///
+       ParTag(std::string const & tag, std::string const & attr,
+              std::string const & parid)
+         : StartTag(tag, attr), parid_(parid)
+       {}
+       ///
+       ~ParTag() {}
+       ///
+       docstring asTag() const;
+       /// the "magic par label" for this paragraph
+       std::string parid_;
+};
+
+
+struct EndTag
+{
        ///
        explicit EndTag(std::string tag) : tag_(tag) {}
        /// </tag_>
@@ -63,14 +84,11 @@ struct EndTag {
 };
 
 
-// FIXME XHTML
-// We need to allow these to be deferrable, which means it should
-// inherit from StartTag. This is probably better, anyway, but we'll
-// need to re-work a bit of code....
 /// Tags like <img />
 /// Attributes will be escaped automatically and so should NOT
 /// be escaped before being passed to the constructor.
-struct CompTag {
+struct CompTag
+{
        ///
        explicit CompTag(std::string const & tag)
                : tag_(tag) {}
@@ -127,6 +145,8 @@ public:
        ///
        XHTMLStream & operator<<(html::CompTag const &);
        ///
+       XHTMLStream & operator<<(html::ParTag const &);
+       ///
        XHTMLStream & operator<<(html::CR const &);
        ///
        enum EscapeSettings {

-----------------------------------------------------------------------

Summary of changes:
 src/Paragraph.cpp    |    6 -----
 src/output_xhtml.cpp |   58 ++++++++++++++++++++++++++++++++++++++++++++++---
 src/output_xhtml.h   |   38 +++++++++++++++++++++++++-------
 3 files changed, 83 insertions(+), 19 deletions(-)


hooks/post-receive
-- 
The LyX Source Repository

Reply via email to