X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_xhtml.cpp;h=f01b0b8e62d04692277661fbba77f8df7b958767;hb=5cb80b867f4a59c3253487652ba74a29ad5b3f0f;hp=0c6c61b162a34f325881c2b13322f362b4ad0b51;hpb=b743c226ca07bd04ba5b146e2e920ddc34b1541b;p=lyx.git

diff --git a/src/output_xhtml.cpp b/src/output_xhtml.cpp
index 0c6c61b162..f01b0b8e62 100644
--- a/src/output_xhtml.cpp
+++ b/src/output_xhtml.cpp
@@ -3,8 +3,8 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author Richard Heck
- * 
+ * \author Richard Kimberly Heck
+ *
  * This code is based upon output_docbook.cpp
  *
  * Full author contact details are available in file CREDITS.
@@ -15,527 +15,235 @@
 #include "output_xhtml.h"
 
 #include "Buffer.h"
-#include "buffer_funcs.h"
 #include "BufferParams.h"
 #include "Counters.h"
 #include "Font.h"
 #include "Layout.h"
-#include "OutputParams.h"
+#include "LayoutEnums.h"
 #include "Paragraph.h"
 #include "ParagraphList.h"
 #include "ParagraphParameters.h"
-#include "sgml.h"
+#include "xml.h"
 #include "Text.h"
 #include "TextClass.h"
 
-#include "support/convert.h"
-#include "support/debug.h"
 #include "support/lassert.h"
-#include "support/lstrings.h"
 
-#include <vector>
+#include <stack>
+#include <iostream>
+
+// Uncomment to activate debugging code.
+// #define XHTML_DEBUG
 
 using namespace std;
 using namespace lyx::support;
 
 namespace lyx {
 
-namespace html {
 
-docstring escapeChar(char_type c)
-{
-	docstring str;
-	switch (c) {
-	case ' ':
-		str += " ";
-		break;
-	case '&':
-		str += "&amp;";
-		break;
-	case '<':
-		str += "&lt;";
-		break;
-	case '>':
-		str += "&gt;";
-		break;
-	default:
-		str += c;
-		break;
+docstring fontToHtmlTag(xml::FontTypes type)
+{
+    switch(type) {
+        case xml::FontTypes::FT_EMPH:
+            return from_utf8("em");
+        case xml::FontTypes::FT_BOLD:
+            return from_utf8("b");
+        case xml::FontTypes::FT_NOUN:
+            return from_utf8("dfn");
+        case xml::FontTypes::FT_UBAR:
+        case xml::FontTypes::FT_WAVE:
+        case xml::FontTypes::FT_DBAR:
+            return from_utf8("u");
+        case xml::FontTypes::FT_SOUT:
+        case xml::FontTypes::FT_XOUT:
+            return from_utf8("del");
+        case xml::FontTypes::FT_ITALIC:
+            return from_utf8("i");
+        case xml::FontTypes::FT_UPRIGHT:
+        case xml::FontTypes::FT_SLANTED:
+        case xml::FontTypes::FT_SMALLCAPS:
+        case xml::FontTypes::FT_ROMAN:
+        case xml::FontTypes::FT_SANS:
+        case xml::FontTypes::FT_TYPE:
+        case xml::FontTypes::FT_SIZE_TINY:
+        case xml::FontTypes::FT_SIZE_SCRIPT:
+        case xml::FontTypes::FT_SIZE_FOOTNOTE:
+        case xml::FontTypes::FT_SIZE_SMALL:
+        case xml::FontTypes::FT_SIZE_NORMAL:
+        case xml::FontTypes::FT_SIZE_LARGE:
+        case xml::FontTypes::FT_SIZE_LARGER:
+        case xml::FontTypes::FT_SIZE_LARGEST:
+        case xml::FontTypes::FT_SIZE_HUGE:
+        case xml::FontTypes::FT_SIZE_HUGER:
+        case xml::FontTypes::FT_SIZE_INCREASE:
+        case xml::FontTypes::FT_SIZE_DECREASE:
+            return from_utf8("span");
+    }
+    // kill warning
+    return docstring();
+}
+
+
+docstring fontToHtmlAttribute(xml::FontTypes type)
+{
+	switch(type) {
+	case xml::FontTypes::FT_EMPH:
+	case xml::FontTypes::FT_BOLD:
+		return from_ascii("");
+	case xml::FontTypes::FT_NOUN:
+		return from_ascii("class='lyxnoun'");
+	case xml::FontTypes::FT_UBAR:
+		return from_ascii("");
+	case xml::FontTypes::FT_DBAR:
+		return from_ascii("class='dline'");
+	case xml::FontTypes::FT_XOUT:
+	case xml::FontTypes::FT_SOUT:
+		return from_ascii("class='strikeout'");
+	case xml::FontTypes::FT_WAVE:
+		return from_ascii("class='wline'");
+	case xml::FontTypes::FT_ITALIC:
+		return from_ascii("");
+	case xml::FontTypes::FT_UPRIGHT:
+		return from_ascii("style='font-style:normal;'");
+	case xml::FontTypes::FT_SLANTED:
+		return from_ascii("style='font-style:oblique;'");
+	case xml::FontTypes::FT_SMALLCAPS:
+		return from_ascii("style='font-variant:small-caps;'");
+	case xml::FontTypes::FT_ROMAN:
+		return from_ascii("style='font-family:serif;'");
+	case xml::FontTypes::FT_SANS:
+		return from_ascii("style='font-family:sans-serif;'");
+	case xml::FontTypes::FT_TYPE:
+		return from_ascii("style='font-family:monospace;'");
+	case xml::FontTypes::FT_SIZE_TINY:
+	case xml::FontTypes::FT_SIZE_SCRIPT:
+	case xml::FontTypes::FT_SIZE_FOOTNOTE:
+		return from_ascii("style='font-size:x-small;'");
+	case xml::FontTypes::FT_SIZE_SMALL:
+		return from_ascii("style='font-size:small;'");
+	case xml::FontTypes::FT_SIZE_NORMAL:
+		return from_ascii("style='font-size:normal;'");
+	case xml::FontTypes::FT_SIZE_LARGE:
+		return from_ascii("style='font-size:large;'");
+	case xml::FontTypes::FT_SIZE_LARGER:
+	case xml::FontTypes::FT_SIZE_LARGEST:
+		return from_ascii("style='font-size:x-large;'");
+	case xml::FontTypes::FT_SIZE_HUGE:
+	case xml::FontTypes::FT_SIZE_HUGER:
+		return from_ascii("style='font-size:xx-large;'");
+	case xml::FontTypes::FT_SIZE_INCREASE:
+		return from_ascii("style='font-size:larger;'");
+	case xml::FontTypes::FT_SIZE_DECREASE:
+		return from_ascii("style='font-size:smaller;'");
 	}
-	return str;
+	// kill warning
+	return from_ascii("");
 }
 
 
-// escape what needs escaping
-docstring htmlize(docstring const & str) {
-	odocstringstream d;
-	docstring::const_iterator it = str.begin();
-	docstring::const_iterator en = str.end();
-	for (; it != en; ++it)
-		d << escapeChar(*it);
-	return d.str();
-}
-
-
-string escapeChar(char c)
+xml::FontTag xhtmlStartFontTag(xml::FontTypes type)
 {
-	string str;
-	switch (c) {
-	case ' ':
-		str += " ";
-		break;
-	case '&':
-		str += "&amp;";
-		break;
-	case '<':
-		str += "&lt;";
-		break;
-	case '>':
-		str += "&gt;";
-		break;
-	default:
-		str += c;
-		break;
-	}
-	return str;
+	return xml::FontTag(fontToHtmlTag(type), fontToHtmlAttribute(type), type);
 }
 
 
-// escape what needs escaping
-string htmlize(string const & str) {
-	ostringstream d;
-	string::const_iterator it = str.begin();
-	string::const_iterator en = str.end();
-	for (; it != en; ++it)
-		d << escapeChar(*it);
-	return d.str();
-}
-
-
-string cleanAttr(string const & str)
-{
-	string newname;
-	string::const_iterator it = str.begin();
-	string::const_iterator en = str.end();
-	for (; it != en; ++it)
-		newname += isalnum(*it) ? *it : '_';
-	return newname;	
-}
-
-
-docstring cleanAttr(docstring const & str)
-{
-	docstring newname;
-	docstring::const_iterator it = str.begin();
-	docstring::const_iterator en = str.end();
-	for (; it != en; ++it)
-		if (isalnum(*it))
-			newname += *it;
-		else
-			newname += '_';
-	return newname;	
-}
-
-
-bool isFontTag(string const & s)
-{
-	return s == "em" || s == "strong"; // others?
-}
-
-
-docstring StartTag::asTag() const
-{
-	string output = "<" + tag_;
-	if (!attr_.empty())
-		output += " " + html::htmlize(attr_);
-	output += ">";
-	return from_utf8(output);
-}
-
-
-docstring StartTag::asEndTag() const
+xml::EndFontTag xhtmlEndFontTag(xml::FontTypes type)
 {
-	string output = "</" + tag_ + ">";
-	return from_utf8(output);
+	return xml::EndFontTag(fontToHtmlTag(type), type);
 }
 
+namespace {
 
-docstring EndTag::asEndTag() const
-{
-	string output = "</" + tag_ + ">";
-	return from_utf8(output);
-}
-
-
-docstring CompTag::asTag() const
-{
-	string output = "<" + tag_;
-	if (!attr_.empty())
-		output += " " + html::htmlize(attr_);
-	output += " />";
-	return from_utf8(output);
-}
-
-} // namespace html
-
-
-
-////////////////////////////////////////////////////////////////
-///
-/// XHTMLStream
-///
-////////////////////////////////////////////////////////////////
-
-XHTMLStream::XHTMLStream(odocstream & os) 
-		: os_(os), nextraw_(false)
-{}
-
-
-void XHTMLStream::cr() 
-{
-	// tabs?
-	os_ << from_ascii("\n");
-}
-
+// convenience functions
 
-void XHTMLStream::writeError(std::string const & s)
+inline void openParTag(XMLStream & xs, Layout const & lay,
+                       std::string const & parlabel)
 {
-	LYXERR0(s);
-	os_ << from_utf8("<!-- Output Error: " + s + " -->");
+	string attrs = lay.htmlGetAttrString();
+	if (!parlabel.empty())
+		attrs += " id='" + parlabel + "'";
+	xs << xml::ParTag(lay.htmltag(), attrs);
 }
 
 
-bool XHTMLStream::closeFontTags()
-{
-	if (tag_stack_.empty())
-		return true;
-	// first, we close any open font tags we can close
-	html::StartTag curtag = tag_stack_.back();
-	while (html::isFontTag(curtag.tag_)) {
-		os_ << curtag.asEndTag();
-		tag_stack_.pop_back();
-		if (tag_stack_.empty())
-			// this probably shouldn't happen, since then the
-			// font tags weren't in any other tag. but that
-			// problem will likely be caught elsewhere.
-			return true;
-		curtag = tag_stack_.back();
-	}
-	// so we've hit a non-font tag. let's see if any of the
-	// remaining tags are font tags.
-	TagStack::const_iterator it = tag_stack_.begin();
-	TagStack::const_iterator en = tag_stack_.end();
-	bool noFontTags = true;
-	for (; it != en; ++it) {
-		if (html::isFontTag(it->tag_)) {
-			writeError("Font tag `" + it->tag_ + "' still open in closeFontTags().\n"
-				"This is likely not a problem, but you might want to check.");
-			noFontTags = false;
-		}
-	}
-	return noFontTags;
+void openParTag(XMLStream & xs, Layout const & lay,
+                std::string const & cssclass,
+                std::string const & parlabel) {
+    string attrs = "class='" + cssclass + "'";
+    if (!parlabel.empty())
+        attrs += " id='" + parlabel + "'";
+    xs << xml::ParTag(lay.htmltag(), attrs);
 }
 
-
-void XHTMLStream::clearTagDeque()
+void openParTag(XMLStream & xs, Layout const & lay,
+                ParagraphParameters const & params,
+                std::string const & parlabel)
 {
-	while (!pending_tags_.empty()) {
-		html::StartTag const & tag = pending_tags_.front();
-		// tabs?
-		os_ << tag.asTag();
-		tag_stack_.push_back(tag);
-		pending_tags_.pop_front();
+	// 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.htmlGetAttrString() + " style='text-align: " + align + ";'";
+	if (!parlabel.empty())
+		attrs += " id='" + parlabel + "'";
+	xs << xml::ParTag(lay.htmltag(), attrs);
 }
 
 
-XHTMLStream & XHTMLStream::operator<<(docstring const & d)
-{
-	clearTagDeque();
-	if (nextraw_) {
-		os_ << d;
-		nextraw_ = false;
-	} else
-		os_ << html::htmlize(d);
-	return *this;
-}
-
-
-XHTMLStream & XHTMLStream::operator<<(const char * s)
-{
-	clearTagDeque();
-	docstring const d = from_ascii(s);
-	if (nextraw_) {
-		os_ << d;
-		nextraw_ = false;
-	} else
-		os_ << html::htmlize(d);
-	return *this;
-}
-
-
-XHTMLStream & XHTMLStream::operator<<(char_type c)
-{
-	clearTagDeque();
-	if (nextraw_) {
-		os_ << c;
-		nextraw_ = false;
-	} else
-		os_ << html::escapeChar(c);
-	return *this;
-}
-
-
-XHTMLStream & XHTMLStream::operator<<(int i)
+inline void closeTag(XMLStream & xs, Layout const & lay)
 {
-	clearTagDeque();
-	os_ << i;
-	nextraw_ = false;
-	return *this;
+	xs << xml::EndTag(lay.htmltag());
 }
 
 
-XHTMLStream & XHTMLStream::operator<<(NextRaw const &) 
-{ 
-	nextraw_ = true; 
-	return *this;
-}
-
-
-XHTMLStream & XHTMLStream::operator<<(html::StartTag const & tag) 
+inline void openLabelTag(XMLStream & xs, Layout const & lay)
 {
-	if (tag.tag_.empty())
-		return *this;
-	pending_tags_.push_back(tag);
-	if (tag.keepempty_)
-		clearTagDeque();
-	return *this;
+	xs << xml::StartTag(lay.htmllabeltag(), lay.htmllabelattr());
 }
 
 
-XHTMLStream & XHTMLStream::operator<<(html::CompTag const & tag) 
+inline void closeLabelTag(XMLStream & xs, Layout const & lay)
 {
-	if (tag.tag_.empty())
-		return *this;
-	clearTagDeque();
-	// tabs?
-	os_ << tag.asTag();
-	cr();
-	return *this;
+	xs << xml::EndTag(lay.htmllabeltag());
 }
 
 
-bool XHTMLStream::isTagOpen(string const & stag)
+inline void openItemTag(XMLStream & xs, Layout const & lay)
 {
-	TagStack::const_iterator sit = tag_stack_.begin();
-	TagStack::const_iterator const sen = tag_stack_.end();
-	for (; sit != sen; ++sit)
-		if (sit->tag_ == stag) 
-			return true;
-	return false;
+	if (lay.htmlitemtag() != "NONE") {
+		xs << xml::StartTag(lay.htmlitemtag(), lay.htmlitemattr(), true);
+	}
 }
 
 
-// this is complicated, because we want to make sure that
-// everything is properly nested. the code ought to make 
-// sure of that, but we won't assert (yet) if we run into
-// a problem. we'll just output error messages and try our
-// best to make things work.
-XHTMLStream & XHTMLStream::operator<<(html::EndTag const & etag)
+void openItemTag(XMLStream & xs, Layout const & lay,
+             ParagraphParameters const & params)
 {
-	if (etag.tag_.empty())
-		return *this;
-
-	// make sure there are tags to be closed
-	if (tag_stack_.empty()) {
-		writeError("Tried to close `" + etag.tag_
-		         + "' when no tags were open!");
-		return *this;		
-	}
-
-	// first make sure we're not closing an empty tag
-	if (!pending_tags_.empty()) {
-		html::StartTag const & stag = pending_tags_.back();
-		if (etag.tag_ == stag.tag_)  {
-			// we have <tag></tag>, so we discard it and remove it 
-			// from the pending_tags_.
-			pending_tags_.pop_back();
-			return *this;
-		}
-		// there is a pending tag that isn't the one we are trying
-		// to close. 
-		// is this tag itself pending?
-		// non-const iterators because we may call erase().
-		TagDeque::iterator dit = pending_tags_.begin();
-		TagDeque::iterator const den = pending_tags_.end();
-		for (; dit != den; ++dit) {
-			if (dit->tag_ == etag.tag_) {
-				// it was pending, so we just erase it
-				writeError("Tried to close pending tag `" + etag.tag_ 
-				        + "' when other tags were pending. Last pending tag is `"
-				        + pending_tags_.back().tag_ + "'. Tag discarded.");
-				pending_tags_.erase(dit);
-				return *this;
-			}
-		}
-		// so etag isn't itself pending. is it even open?
-		if (!isTagOpen(etag.tag_)) {
-			writeError("Tried to close `" + etag.tag_ 
-			         + "' when tag was not open. Tag discarded.");
-			return *this;
-		}
-		// ok, so etag is open.
-		// our strategy will be as below: we will do what we need to 
-		// do to close this tag.
-		string estr = "Closing tag `" + etag.tag_ 
-		        + "' when other tags are pending. Discarded pending tags:\n";
-		for (dit = pending_tags_.begin(); dit != den; ++dit)
-			estr += dit->tag_ + "\n";
-		writeError(estr);
-		// clear the pending tags...
-		pending_tags_.clear();
-		// ...and then just fall through.
-	}
-
-	// is the tag we are closing the last one we opened?
-	if (etag.tag_ == tag_stack_.back().tag_) {
-		// output it...
-		os_ << etag.asEndTag();
-		// ...and forget about it
-		tag_stack_.pop_back();
-		return *this;
-	} 
-	
-	// we are trying to close a tag other than the one last opened. 
-	// let's first see if this particular tag is still open somehow.
-	if (!isTagOpen(etag.tag_)) {
-		writeError("Tried to close `" + etag.tag_ 
-		        + "' when tag was not open. Tag discarded.");
-		return *this;
-	}
-	
-	// so the tag was opened, but other tags have been opened since
-	// and not yet closed.
-	// if it's a font tag, though...
-	if (html::isFontTag(etag.tag_)) {
-		// it won't be a problem if the other tags open since this one
-		// are also font tags.
-		TagStack::const_reverse_iterator rit = tag_stack_.rbegin();
-		TagStack::const_reverse_iterator ren = tag_stack_.rend();
-		for (; rit != ren; ++rit) {
-			if (rit->tag_ == etag.tag_)
-				break;
-			if (!html::isFontTag(rit->tag_)) {
-				// we'll just leave it and, presumably, have to close it later.
-				writeError("Unable to close font tag `" + etag.tag_ 
-				        + "' due to open non-font tag `" + rit->tag_ + "'.");
-				return *this;
-			}
-		}
-		
-		// so we have e.g.:
-		//    <em>this is <strong>bold
-		// and are being asked to closed em. we want:
-		//    <em>this is <strong>bold</strong></em><strong>
-		// first, we close the intervening tags...
-		html::StartTag curtag = tag_stack_.back();
-		// ...remembering them in a stack.
-		TagStack fontstack;
-		while (curtag.tag_ != etag.tag_) {
-			os_ << curtag.asEndTag();
-			fontstack.push_back(curtag);
-			tag_stack_.pop_back();
-			curtag = tag_stack_.back();
+	if (lay.htmlitemtag() != "NONE") {
+		// FIXME Are there other things we should handle here?
+		string const align = alignmentToCSS(params.align());
+		if (align.empty()) {
+			openItemTag(xs, lay);
+			return;
 		}
-		// now close our tag...
-		os_ << etag.asEndTag();
-		tag_stack_.pop_back();
-
-		// ...and restore the other tags.
-		rit = fontstack.rbegin();
-		ren = fontstack.rend();
-		for (; rit != ren; ++rit)
-			pending_tags_.push_back(*rit);
-		return *this;
+		string attrs = lay.htmlGetAttrString() + " style='text-align: " + align + ";'";
+		xs << xml::StartTag(lay.htmlitemtag(), attrs);
 	}
-	
-	// it wasn't a font tag.
-	// so other tags were opened before this one and not properly closed. 
-	// so we'll close them, too. that may cause other issues later, but it 
-	// at least guarantees proper nesting.
-	writeError("Closing tag `" + etag.tag_ 
-	        + "' when other tags are open, namely:");
-	html::StartTag curtag = tag_stack_.back();
-	while (curtag.tag_ != etag.tag_) {
-		writeError(curtag.tag_);
-		os_ << curtag.asEndTag();
-		tag_stack_.pop_back();
-		curtag = tag_stack_.back();
-	}
-	// curtag is now the one we actually want.
-	os_ << curtag.asEndTag();
-	tag_stack_.pop_back();
-	
-	return *this;
-}
-
-// End code for XHTMLStream
-
-namespace {
-	
-// convenience functions
-
-inline void openTag(XHTMLStream & xs, Layout const & lay)
-{
-	xs << html::StartTag(lay.htmltag(), lay.htmlattr());
 }
 
 
-void openTag(XHTMLStream & xs, Layout const & lay, ParagraphParameters const & params)
+inline void closeItemTag(XMLStream & xs, Layout const & lay)
 {
-	// FIXME Are there other things we should handle here?
-	string const align = alignmentToCSS(params.align());
-	if (align.empty()) {
-		openTag(xs, lay);
-		return;
+	if (lay.htmlitemtag() != "NONE") {
+		xs << xml::EndTag(lay.htmlitemtag());
 	}
-	string attrs = lay.htmlattr() + " style='text-align: " + align + ";'";
-	xs << html::StartTag(lay.htmltag(), attrs);
-}
-
-
-inline void closeTag(XHTMLStream & xs, Layout const & lay)
-{
-	xs << html::EndTag(lay.htmltag());
-}
-
-
-inline void openLabelTag(XHTMLStream & xs, Layout const & lay)
-{
-	xs << html::StartTag(lay.htmllabeltag(), lay.htmllabelattr());
-}
-
-
-inline void closeLabelTag(XHTMLStream & xs, Layout const & lay)
-{
-	xs << html::EndTag(lay.htmllabeltag());
-}
-
-
-inline void openItemTag(XHTMLStream & xs, Layout const & lay)
-{
-	xs << html::StartTag(lay.htmlitemtag(), lay.htmlitemattr(), true);
-}
-
-
-inline void closeItemTag(XHTMLStream & xs, Layout const & lay)
-{
-	xs << html::EndTag(lay.htmlitemtag());
 }
 
 // end of convenience functions
 
-ParagraphList::const_iterator searchParagraphHtml(
+ParagraphList::const_iterator findLastParagraph(
 	ParagraphList::const_iterator p,
 	ParagraphList::const_iterator const & pend)
 {
@@ -546,8 +254,8 @@ ParagraphList::const_iterator searchParagraphHtml(
 }
 
 
-ParagraphList::const_iterator searchEnvironmentHtml(
-		ParagraphList::const_iterator const pstart,
+ParagraphList::const_iterator findEndOfEnvironment(
+		ParagraphList::const_iterator const & pstart,
 		ParagraphList::const_iterator const & pend)
 {
 	ParagraphList::const_iterator p = pstart;
@@ -560,15 +268,19 @@ ParagraphList::const_iterator searchEnvironmentHtml(
 		// it can happen. We pretend that it's just at lowest depth.
 		if (style.latextype == LATEX_COMMAND)
 			return p;
+
 		// 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;
-		// Now we know we are at the same depth
-		if (style.latextype == LATEX_PARAGRAPH
-		    || style.latexname() != bstyle.latexname())
+
+		// 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;
@@ -576,7 +288,7 @@ ParagraphList::const_iterator searchEnvironmentHtml(
 
 
 ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
-					    XHTMLStream & xs,
+					    XMLStream & xs,
 					    OutputParams const & runparams,
 					    Text const & text,
 					    ParagraphList::const_iterator const & pbegin,
@@ -587,40 +299,74 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
 	for (; par != pend; ++par) {
 		Layout const & lay = par->layout();
 		if (!lay.counter.empty())
-			buf.params().documentClass().counters().step(lay.counter, OutputUpdate);
+			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.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);
-		if (opened)
-			openTag(xs, lay, par->params());
-		docstring const deferred = 
-			par->simpleLyXHTMLOnePar(buf, xs, runparams, text.outerFont(distance(begin, par)));
+			xs << xml::CR();
+
+		// 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()) {
+			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;
+		}
+
+		bool const open_par = 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,
 		//        or we're not in the last paragraph, anyway.
-		//   (ii) We didn't open it and html_in_par is true, 
+		//   (ii) We didn't open it and html_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 needclose = 
-			(opened && (!runparams.html_in_par || nextpar != pend))
-			|| (!opened && runparams.html_in_par && par == pbegin && nextpar != pend);
-		if (needclose) {
+		++nextpar;
+		bool const close_par =
+			(open_par && (!runparams.html_in_par || nextpar != pend))
+			|| (!open_par && runparams.html_in_par && par == pbegin && nextpar != pend);
+
+		if (open_par) {
+			// 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)),
+			open_par, close_par);
+
+		if (close_par) {
 			closeTag(xs, lay);
-			xs.cr();
+			xs << xml::CR();
 		}
+
 		if (!deferred.empty()) {
-			xs << XHTMLStream::NextRaw() << deferred;
-			xs.cr();
+			xs << XMLStream::ESCAPE_NONE << deferred << xml::CR();
 		}
 	}
 	return pend;
@@ -628,22 +374,22 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
 
 
 ParagraphList::const_iterator makeBibliography(Buffer const & buf,
-				XHTMLStream & xs,
+				XMLStream & xs,
 				OutputParams const & runparams,
 				Text const & text,
 				ParagraphList::const_iterator const & pbegin,
-				ParagraphList::const_iterator const & pend) 
+				ParagraphList::const_iterator const & pend)
 {
 	// FIXME XHTML
 	// Use TextClass::htmlTOCLayout() to figure out how we should look.
-	xs << html::StartTag("h2", "class='bibliography'");
-	xs << pbegin->layout().labelstring(false);
-	xs << html::EndTag("h2");
-	xs.cr();
-	xs << html::StartTag("div", "class='bibliography'");
-	xs.cr();
+	xs << xml::StartTag("h2", "class='bibliography'")
+	   << pbegin->layout().labelstring(false)
+	   << xml::EndTag("h2")
+	   << xml::CR()
+	   << xml::StartTag("div", "class='bibliography'")
+	   << xml::CR();
 	makeParagraphs(buf, xs, runparams, text, pbegin, pend);
-	xs << html::EndTag("div");
+	xs << xml::EndTag("div");
 	return pend;
 }
 
@@ -654,13 +400,13 @@ bool isNormalEnv(Layout const & lay)
 	    || lay.latextype == LATEX_BIB_ENVIRONMENT;
 }
 
-	
-ParagraphList::const_iterator makeEnvironmentHtml(Buffer const & buf,
-					      XHTMLStream & xs,
+
+ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
+					      XMLStream & xs,
 					      OutputParams const & runparams,
 					      Text const & text,
 					      ParagraphList::const_iterator const & pbegin,
-					      ParagraphList::const_iterator const & pend) 
+					      ParagraphList::const_iterator const & pend)
 {
 	ParagraphList::const_iterator const begin = text.paragraphs().begin();
 	ParagraphList::const_iterator par = pbegin;
@@ -668,11 +414,46 @@ ParagraphList::const_iterator makeEnvironmentHtml(Buffer const & buf,
 	depth_type const origdepth = pbegin->params().depth();
 
 	// open tag for this environment
-	openTag(xs, bstyle);
-	xs.cr();
+	if ((bstyle.labeltype == LABEL_ENUMERATE || bstyle.labeltype == LABEL_ITEMIZE)
+		&& bstyle.htmlclass().empty()) {
+		// In this case, we have to calculate the CSS class ourselves, each time
+		// through
+		// FIXME We assume in these cases that the standard counters are being used.
+		// (We also do not deal with 'resume' counters, though I'm not sure that can
+		// be done at all in HTML.)
+
+		// Code adapated from Buffer::Impl::setLabel
+		bool const isenum = bstyle.labeltype == LABEL_ENUMERATE;
+		docstring enumcounter = bstyle.counter.empty() ?
+					( isenum ? from_ascii("enum") : from_ascii("lyxitem") ) :
+					bstyle.counter;
+		switch (par->itemdepth) {
+		case 2:
+			enumcounter += 'i';
+			// fall through
+		case 1:
+			enumcounter += 'i';
+			// fall through
+		case 0:
+			enumcounter += 'i';
+			break;
+		case 3:
+			enumcounter += "iv";
+			break;
+		default:
+			// not a valid enumdepth...
+			break;
+		}
+		openParTag(xs, bstyle,
+				   string( isenum ? "lyxenum" : "lyxitem" ) + " "
+					+ to_utf8(enumcounter), pbegin->magicLabel());
+	}
+	else
+		openParTag(xs, bstyle, pbegin->magicLabel());
+	xs << xml::CR();
 
 	// we will on occasion need to remember a layout from before.
-	Layout const * lastlay = 0;
+	Layout const * lastlay = nullptr;
 
 	while (par != pend) {
 		Layout const & style = par->layout();
@@ -682,78 +463,82 @@ ParagraphList::const_iterator makeEnvironmentHtml(Buffer const & buf,
 		// FIXME There may be a bug here about user defined enumeration
 		// types. If so, then we'll need to take the counter and add "i",
 		// "ii", etc, as with enum.
-		Counters & cnts = buf.params().documentClass().counters();
+		Counters & cnts = buf.masterBuffer()->params().documentClass().counters();
 		docstring const & cntr = style.counter;
-		if (!style.counter.empty() 
-		    && (par == pbegin || !isNormalEnv(style)) 
+		if (!style.counter.empty()
+		    && (par == pbegin || !isNormalEnv(style))
 				&& cnts.hasCounter(cntr)
-		)
+			)
 			cnts.step(cntr, OutputUpdate);
 		ParagraphList::const_iterator send;
-		// this will be positive, if we want to skip the initial word
-		// (if it's been taken for the label).
-		pos_type sep = 0;
 
 		switch (style.latextype) {
 		case LATEX_ENVIRONMENT:
 		case LATEX_LIST_ENVIRONMENT:
 		case LATEX_ITEM_ENVIRONMENT: {
-			// There are two possiblities in this case. 
-			// One is that we are still in the environment in which we 
+			// 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) {
-				LASSERT(bstyle == style, /* */);
-				if (lastlay != 0) {
+				LATTEST(bstyle == style);
+				if (lastlay != nullptr) {
 					closeItemTag(xs, *lastlay);
-					lastlay = 0;
+					lastlay = nullptr;
 				}
-				
+
+				// this will be positive, if we want to skip the
+				// initial word (if it's been taken for the label).
+				pos_type sep = 0;
 				bool const labelfirst = style.htmllabelfirst();
 				if (!labelfirst)
-					openItemTag(xs, style);
-				
+					openItemTag(xs, style, par->params());
+
 				// label output
-				if (style.labeltype != LABEL_NO_LABEL && 
+				if (style.labeltype != LABEL_NO_LABEL &&
 				    style.htmllabeltag() != "NONE") {
 					if (isNormalEnv(style)) {
-						// in this case, we print the label only for the first 
+						// in this case, we print the label only for the first
 						// paragraph (as in a theorem).
 						if (par == pbegin) {
-							docstring const lbl = 
+							docstring const lbl =
 									pbegin->params().labelString();
 							if (!lbl.empty()) {
 								openLabelTag(xs, style);
 								xs << lbl;
 								closeLabelTag(xs, style);
 							}
-							xs.cr();
+							xs << xml::CR();
 						}
-					}	else { // some kind of list
+					} else { // some kind of list
 						if (style.labeltype == LABEL_MANUAL) {
 							openLabelTag(xs, style);
 							sep = par->firstWordLyXHTML(xs, runparams);
 							closeLabelTag(xs, style);
-							xs.cr();
+							xs << xml::CR();
 						}
 						else {
-							openLabelTag(xs, style);
-							xs << par->params().labelString();
-							closeLabelTag(xs, style);
-							xs.cr();
+							docstring const & ls = par->params().labelString();
+							if (!ls.empty()) {
+								openLabelTag(xs, style);
+								xs << ls;
+								closeLabelTag(xs, style);
+								xs << xml::CR();
+							}
 						}
 					}
 				} // end label output
 
 				if (labelfirst)
-					openItemTag(xs, style);
+					openItemTag(xs, style, par->params());
 
-				par->simpleLyXHTMLOnePar(buf, xs, runparams, 
-					text.outerFont(distance(begin, par)), sep);
+				docstring deferred = par->simpleLyXHTMLOnePar(buf, xs, runparams,
+					text.outerFont(distance(begin, par)), true, true, sep);
+				xs << XMLStream::ESCAPE_NONE << deferred;
 				++par;
 
 				// We may not want to close the tag yet, in particular:
 				// If we're not at the end...
-				if (par != pend 
+				if (par != pend
 					//  and are doing items...
 					 && !isNormalEnv(style)
 					 // and if the depth has changed...
@@ -763,18 +548,18 @@ ParagraphList::const_iterator makeEnvironmentHtml(Buffer const & buf,
 					lastlay = &style;
 				} else
 					closeItemTag(xs, style);
-				xs.cr();
+				xs << xml::CR();
 			}
 			// The other possibility is that the depth has increased, in which
 			// case we need to recurse.
 			else {
-				send = searchEnvironmentHtml(par, pend);
-				par = makeEnvironmentHtml(buf, xs, runparams, text, par, send);
+				send = findEndOfEnvironment(par, pend);
+				par = makeEnvironment(buf, xs, runparams, text, par, send);
 			}
 			break;
 		}
 		case LATEX_PARAGRAPH:
-			send = searchParagraphHtml(par, pend);
+			send = findLastParagraph(par, pend);
 			par = makeParagraphs(buf, xs, runparams, text, par, send);
 			break;
 		// Shouldn't happen
@@ -790,28 +575,33 @@ ParagraphList::const_iterator makeEnvironmentHtml(Buffer const & buf,
 		}
 	}
 
-	if (lastlay != 0)
+	if (lastlay != nullptr)
 		closeItemTag(xs, *lastlay);
 	closeTag(xs, bstyle);
-	xs.cr();
+	xs << xml::CR();
 	return pend;
 }
 
 
 void makeCommand(Buffer const & buf,
-					  XHTMLStream & xs,
-					  OutputParams const & runparams,
-					  Text const & text,
-					  ParagraphList::const_iterator const & pbegin)
+		 XMLStream & xs,
+		 OutputParams const & runparams,
+		 Text const & text,
+		 ParagraphList::const_iterator const & pbegin)
 {
 	Layout const & style = pbegin->layout();
 	if (!style.counter.empty())
-		buf.params().documentClass().counters().step(style.counter, OutputUpdate);
+		buf.masterBuffer()->params().
+		    documentClass().counters().step(style.counter, OutputUpdate);
 
-	openTag(xs, style);
+	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
+	// FIXME Probably also need now to account for labels ABOVE and CENTERED.
 	if (style.labeltype != LABEL_NO_LABEL) {
 		openLabelTag(xs, style);
 		xs << pbegin->params().labelString();
@@ -824,7 +614,7 @@ void makeCommand(Buffer const & buf,
 	pbegin->simpleLyXHTMLOnePar(buf, xs, runparams,
 			text.outerFont(distance(begin, pbegin)));
 	closeTag(xs, style);
-	xs.cr();
+	xs << xml::CR();
 }
 
 } // end anonymous namespace
@@ -832,31 +622,76 @@ void makeCommand(Buffer const & buf,
 
 void xhtmlParagraphs(Text const & text,
 		       Buffer const & buf,
-		       XHTMLStream & xs,
+		       XMLStream & xs,
 		       OutputParams const & runparams)
 {
 	ParagraphList const & paragraphs = text.paragraphs();
-	ParagraphList::const_iterator par = paragraphs.begin();
-	ParagraphList::const_iterator pend = paragraphs.end();
+	if (runparams.par_begin == runparams.par_end) {
+		runparams.par_begin = 0;
+		runparams.par_end = paragraphs.size();
+	}
+	pit_type bpit = runparams.par_begin;
+	pit_type const epit = runparams.par_end;
+	LASSERT(bpit < epit,
+		{ xs << XMLStream::ESCAPE_NONE << "<!-- XHTML output error! -->\n"; return; });
 
 	OutputParams ourparams = runparams;
-	while (par != pend) {
+	ParagraphList::const_iterator const pend =
+		(epit == (int) paragraphs.size()) ?
+			paragraphs.end() : paragraphs.iterator_at(epit);
+	std::stack<int> headerLevels;
+
+	while (bpit < epit) {
+		ParagraphList::const_iterator par = paragraphs.iterator_at(bpit);
 		if (par->params().startOfAppendix()) {
-			// FIXME: only the counter corresponding to toplevel
-			// sectioning should be reset
-			Counters & cnts = buf.masterBuffer()->params().documentClass().counters();
-			cnts.reset();
-			cnts.appendix(true);
+			// We want to reset the counter corresponding to toplevel sectioning
+			Layout const & lay =
+				buf.masterBuffer()->params().documentClass().getTOCLayout();
+			docstring const cnt = lay.counter;
+			if (!cnt.empty()) {
+				Counters & cnts =
+					buf.masterBuffer()->params().documentClass().counters();
+				cnts.reset(cnt);
+			}
 		}
 		Layout const & style = par->layout();
-		ParagraphList::const_iterator lastpar = par;
+		ParagraphList::const_iterator const lastpar = par;
 		ParagraphList::const_iterator send;
 
+		// Think about adding <section> and/or </section>s.
+		// Document title is not in Sectioning, but rather in FrontMatter, so that it does not need to be taken
+		// into account.
+		if (style.category() == from_utf8("Sectioning")) {
+			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> after a <h2>, <h3>, <h4>, <h5> or <h6>). More examples:
+			//   - current: h2; back: h1; do not close any <section>
+			//   - current: h1; back: h2; close two <section> (first the <h2>, then the <h1>, so a new <h1> can come)
+			while (!headerLevels.empty() && level <= headerLevels.top()) {
+				// Output the tag only if it corresponds to a legit section.
+				int stackLevel = headerLevels.top();
+				if (stackLevel != Layout::NOT_IN_TOC) {
+					xs << xml::EndTag("section");
+					xs << xml::CR();
+				}
+				headerLevels.pop();
+			}
+
+			// Open the new section: first push it onto the stack, then output it in XHTML.
+			headerLevels.push(level);
+			// Some sectioning-like elements should not be output (such as FrontMatter).
+			if (level != Layout::NOT_IN_TOC ) {
+				xs << xml::StartTag("section");
+				xs << xml::CR();
+			}
+		}
+
 		switch (style.latextype) {
 		case LATEX_COMMAND: {
 			// The files with which we are working never have more than
 			// one paragraph in a command structure.
-			// FIXME 
+			// FIXME
 			// if (ourparams.html_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
@@ -871,30 +706,36 @@ void xhtmlParagraphs(Text const & text,
 		case LATEX_LIST_ENVIRONMENT:
 		case LATEX_ITEM_ENVIRONMENT: {
 			// FIXME Same fix here.
-			send = searchEnvironmentHtml(par, pend);
-			par = makeEnvironmentHtml(buf, xs, ourparams, text, par, send);
+			send = findEndOfEnvironment(par, pend);
+			par = makeEnvironment(buf, xs, ourparams, text, par, send);
 			break;
 		}
 		case LATEX_BIB_ENVIRONMENT: {
 			// FIXME Same fix here.
-			send = searchEnvironmentHtml(par, pend);
+			send = findEndOfEnvironment(par, pend);
 			par = makeBibliography(buf, xs, ourparams, text, par, send);
 			break;
 		}
 		case LATEX_PARAGRAPH:
-			send = searchParagraphHtml(par, pend);
+			send = findLastParagraph(par, pend);
 			par = makeParagraphs(buf, xs, ourparams, text, par, send);
 			break;
 		}
-		// FIXME??
-		// makeEnvironment may process more than one paragraphs and bypass pend
-		if (distance(lastpar, par) >= distance(lastpar, pend))
-			break;
+		bpit += distance(lastpar, par);
+	}
+
+	// If need be, close <section>s, but only at the end of the document (otherwise, dealt with at the beginning
+	// of the loop).
+	while (!headerLevels.empty() && headerLevels.top() != Layout::NOT_IN_TOC) {
+		headerLevels.pop();
+		xs << xml::EndTag("section");
+		xs << xml::CR();
 	}
 }
 
 
-string alignmentToCSS(LyXAlignment align) {
+string alignmentToCSS(LyXAlignment align)
+{
 	switch (align) {
 	case LYX_ALIGN_BLOCK:
 		// we are NOT going to use text-align: justify!!