2009-06-05 17:49:10 +00:00
|
|
|
/**
|
|
|
|
* \file output_xhtml.cpp
|
|
|
|
* This file is part of LyX, the document processor.
|
|
|
|
* Licence details can be found in the file COPYING.
|
|
|
|
*
|
|
|
|
* \author Richard Heck
|
2015-05-17 15:27:12 +00:00
|
|
|
*
|
2009-06-05 17:49:10 +00:00
|
|
|
* This code is based upon output_docbook.cpp
|
|
|
|
*
|
|
|
|
* Full author contact details are available in file CREDITS.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
|
|
|
#include "output_xhtml.h"
|
|
|
|
|
|
|
|
#include "Buffer.h"
|
|
|
|
#include "buffer_funcs.h"
|
|
|
|
#include "BufferParams.h"
|
|
|
|
#include "Counters.h"
|
2010-03-31 19:38:05 +00:00
|
|
|
#include "Font.h"
|
2009-06-05 17:49:10 +00:00
|
|
|
#include "Layout.h"
|
|
|
|
#include "OutputParams.h"
|
|
|
|
#include "Paragraph.h"
|
|
|
|
#include "ParagraphList.h"
|
|
|
|
#include "ParagraphParameters.h"
|
|
|
|
#include "sgml.h"
|
2009-08-09 17:30:41 +00:00
|
|
|
#include "Text.h"
|
2009-06-05 17:49:10 +00:00
|
|
|
#include "TextClass.h"
|
|
|
|
|
2010-01-12 21:06:55 +00:00
|
|
|
#include "support/convert.h"
|
2009-06-05 17:49:10 +00:00
|
|
|
#include "support/debug.h"
|
2010-01-12 21:06:55 +00:00
|
|
|
#include "support/lassert.h"
|
2009-06-05 17:49:10 +00:00
|
|
|
#include "support/lstrings.h"
|
2010-11-17 22:17:53 +00:00
|
|
|
#include "support/textutils.h"
|
2009-06-05 17:49:10 +00:00
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
|
2013-05-07 04:19:34 +00:00
|
|
|
// Uncomment to activate debugging code.
|
|
|
|
// #define XHTML_DEBUG
|
|
|
|
|
2009-06-05 17:49:10 +00:00
|
|
|
using namespace std;
|
|
|
|
using namespace lyx::support;
|
|
|
|
|
|
|
|
namespace lyx {
|
|
|
|
|
|
|
|
namespace html {
|
|
|
|
|
2010-11-24 15:27:36 +00:00
|
|
|
docstring escapeChar(char_type c, XHTMLStream::EscapeSettings e)
|
2009-06-05 17:49:10 +00:00
|
|
|
{
|
|
|
|
docstring str;
|
2010-11-24 15:27:36 +00:00
|
|
|
switch (e) {
|
|
|
|
case XHTMLStream::ESCAPE_NONE:
|
2009-06-05 17:49:10 +00:00
|
|
|
str += c;
|
|
|
|
break;
|
2010-11-24 15:27:36 +00:00
|
|
|
case XHTMLStream::ESCAPE_ALL:
|
|
|
|
if (c == '<') {
|
|
|
|
str += "<";
|
|
|
|
break;
|
|
|
|
} else if (c == '>') {
|
|
|
|
str += ">";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// fall through
|
|
|
|
case XHTMLStream::ESCAPE_AND:
|
|
|
|
if (c == '&')
|
|
|
|
str += "&";
|
|
|
|
else
|
|
|
|
str +=c ;
|
|
|
|
break;
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-14 14:16:15 +00:00
|
|
|
// escape what needs escaping
|
2012-10-27 13:45:27 +00:00
|
|
|
docstring htmlize(docstring const & str, XHTMLStream::EscapeSettings e)
|
|
|
|
{
|
2009-11-14 14:16:15 +00:00
|
|
|
odocstringstream d;
|
|
|
|
docstring::const_iterator it = str.begin();
|
|
|
|
docstring::const_iterator en = str.end();
|
|
|
|
for (; it != en; ++it)
|
2010-11-24 15:27:36 +00:00
|
|
|
d << escapeChar(*it, e);
|
2009-11-14 14:16:15 +00:00
|
|
|
return d.str();
|
2009-06-11 20:08:39 +00:00
|
|
|
}
|
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
|
2015-10-15 18:52:28 +00:00
|
|
|
docstring escapeChar(char c, XHTMLStream::EscapeSettings e)
|
2009-11-25 22:18:47 +00:00
|
|
|
{
|
2015-10-15 18:52:28 +00:00
|
|
|
LATTEST(static_cast<unsigned char>(c) < 0x80);
|
|
|
|
return escapeChar(static_cast<char_type>(c), e);
|
2009-11-28 21:37:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
docstring cleanAttr(docstring const & str)
|
|
|
|
{
|
|
|
|
docstring newname;
|
|
|
|
docstring::const_iterator it = str.begin();
|
|
|
|
docstring::const_iterator en = str.end();
|
2010-11-17 21:19:01 +00:00
|
|
|
for (; it != en; ++it) {
|
|
|
|
char_type const c = *it;
|
2010-11-17 22:17:53 +00:00
|
|
|
newname += isAlnumASCII(c) ? c : char_type('_');
|
2010-11-17 21:19:01 +00:00
|
|
|
}
|
2015-05-17 15:27:12 +00:00
|
|
|
return newname;
|
2009-11-28 21:37:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-07 06:34:15 +00:00
|
|
|
docstring StartTag::writeTag() const
|
2009-11-19 17:51:06 +00:00
|
|
|
{
|
2015-10-15 18:52:28 +00:00
|
|
|
docstring output = '<' + from_utf8(tag_);
|
2009-11-19 17:51:06 +00:00
|
|
|
if (!attr_.empty())
|
2015-10-15 18:52:28 +00:00
|
|
|
output += ' ' + html::htmlize(from_utf8(attr_), XHTMLStream::ESCAPE_NONE);
|
2009-11-19 17:51:06 +00:00
|
|
|
output += ">";
|
2015-10-15 18:52:28 +00:00
|
|
|
return output;
|
2009-11-19 17:51:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-07 06:34:15 +00:00
|
|
|
docstring StartTag::writeEndTag() const
|
2009-11-19 17:51:06 +00:00
|
|
|
{
|
|
|
|
string output = "</" + tag_ + ">";
|
|
|
|
return from_utf8(output);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-07 06:34:15 +00:00
|
|
|
bool StartTag::operator==(FontTag const & rhs) const
|
|
|
|
{
|
|
|
|
return rhs == *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
docstring EndTag::writeEndTag() const
|
2013-05-07 06:30:26 +00:00
|
|
|
{
|
|
|
|
string output = "</" + tag_ + ">";
|
|
|
|
return from_utf8(output);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-07-08 20:38:37 +00:00
|
|
|
ParTag::ParTag(std::string const & tag, std::string attr,
|
|
|
|
std::string const & parid)
|
|
|
|
: StartTag(tag)
|
2013-05-07 05:16:14 +00:00
|
|
|
{
|
2016-07-08 20:38:37 +00:00
|
|
|
if (!parid.empty())
|
|
|
|
attr += " id='" + parid + "'";
|
|
|
|
attr_ = attr;
|
2013-05-07 05:16:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-07 06:34:15 +00:00
|
|
|
docstring CompTag::writeTag() const
|
2009-11-19 17:51:06 +00:00
|
|
|
{
|
2015-10-15 18:52:28 +00:00
|
|
|
docstring output = '<' + from_utf8(tag_);
|
2009-11-19 17:51:06 +00:00
|
|
|
if (!attr_.empty())
|
2015-10-15 18:52:28 +00:00
|
|
|
output += ' ' + html::htmlize(from_utf8(attr_), XHTMLStream::ESCAPE_NONE);
|
2009-11-19 17:51:06 +00:00
|
|
|
output += " />";
|
2015-10-15 18:52:28 +00:00
|
|
|
return output;
|
2009-11-19 16:35:58 +00:00
|
|
|
}
|
2009-11-19 16:29:57 +00:00
|
|
|
|
2013-05-07 06:34:15 +00:00
|
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
string fontToTag(html::FontTypes type)
|
2015-09-13 08:04:16 +00:00
|
|
|
{
|
2013-05-07 06:34:15 +00:00
|
|
|
switch(type) {
|
|
|
|
case FT_EMPH:
|
|
|
|
return "em";
|
|
|
|
case FT_BOLD:
|
|
|
|
return "b";
|
|
|
|
case FT_NOUN:
|
|
|
|
return "dfn";
|
|
|
|
case FT_UBAR:
|
|
|
|
case FT_WAVE:
|
|
|
|
case FT_DBAR:
|
|
|
|
return "u";
|
|
|
|
case FT_SOUT:
|
2017-04-04 22:01:19 +00:00
|
|
|
case FT_XOUT:
|
2013-05-07 06:34:15 +00:00
|
|
|
return "del";
|
|
|
|
case FT_ITALIC:
|
|
|
|
return "i";
|
2013-05-10 20:58:38 +00:00
|
|
|
case FT_UPRIGHT:
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_SLANTED:
|
|
|
|
case FT_SMALLCAPS:
|
|
|
|
case FT_ROMAN:
|
|
|
|
case FT_SANS:
|
2013-05-10 20:58:38 +00:00
|
|
|
case FT_TYPE:
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_TINY:
|
|
|
|
case FT_SIZE_SCRIPT:
|
|
|
|
case FT_SIZE_FOOTNOTE:
|
|
|
|
case FT_SIZE_SMALL:
|
|
|
|
case FT_SIZE_NORMAL:
|
|
|
|
case FT_SIZE_LARGE:
|
|
|
|
case FT_SIZE_LARGER:
|
|
|
|
case FT_SIZE_LARGEST:
|
|
|
|
case FT_SIZE_HUGE:
|
|
|
|
case FT_SIZE_HUGER:
|
|
|
|
case FT_SIZE_INCREASE:
|
|
|
|
case FT_SIZE_DECREASE:
|
2013-05-07 06:34:15 +00:00
|
|
|
return "span";
|
|
|
|
}
|
|
|
|
// kill warning
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2015-09-13 08:04:16 +00:00
|
|
|
string fontToAttribute(html::FontTypes type)
|
|
|
|
{
|
2013-05-07 06:34:15 +00:00
|
|
|
switch(type) {
|
|
|
|
case FT_EMPH:
|
|
|
|
case FT_BOLD:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_NOUN:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "class='lyxnoun'";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_UBAR:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_DBAR:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "class='dline'";
|
2017-04-04 22:01:19 +00:00
|
|
|
case FT_XOUT:
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_SOUT:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "class='strikeout'";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_WAVE:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "class='wline'";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_ITALIC:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "";
|
2013-05-10 20:58:38 +00:00
|
|
|
case FT_UPRIGHT:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-style:normal;'";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_SLANTED:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-style:oblique;'";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_SMALLCAPS:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-variant:small-caps;'";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_ROMAN:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-family:serif;'";
|
2013-05-07 06:34:15 +00:00
|
|
|
case FT_SANS:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-family:sans-serif;'";
|
2013-05-10 20:58:38 +00:00
|
|
|
case FT_TYPE:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-family:monospace;'";
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_TINY:
|
|
|
|
case FT_SIZE_SCRIPT:
|
|
|
|
case FT_SIZE_FOOTNOTE:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-size:x-small;'";
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_SMALL:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-size:small;'";
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_NORMAL:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-size:normal;'";
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_LARGE:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-size:large;'";
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_LARGER:
|
|
|
|
case FT_SIZE_LARGEST:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-size:x-large;'";
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_HUGE:
|
|
|
|
case FT_SIZE_HUGER:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-size:xx-large;'";
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_INCREASE:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-size:larger;'";
|
2013-05-13 16:22:41 +00:00
|
|
|
case FT_SIZE_DECREASE:
|
2015-09-13 08:04:16 +00:00
|
|
|
return "style='font-size:smaller;'";
|
2013-05-07 06:34:15 +00:00
|
|
|
}
|
|
|
|
// kill warning
|
2015-09-13 08:04:16 +00:00
|
|
|
return "";
|
2013-05-07 06:34:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
|
|
|
|
FontTag::FontTag(FontTypes type)
|
2015-09-13 08:04:16 +00:00
|
|
|
: StartTag(fontToTag(type), fontToAttribute(type)), font_type_(type)
|
2013-05-07 06:34:15 +00:00
|
|
|
{}
|
|
|
|
|
|
|
|
|
|
|
|
bool FontTag::operator==(StartTag const & tag) const
|
|
|
|
{
|
|
|
|
FontTag const * const ftag = tag.asFontTag();
|
|
|
|
if (!ftag)
|
|
|
|
return false;
|
|
|
|
return (font_type_ == ftag->font_type_);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
EndFontTag::EndFontTag(FontTypes type)
|
|
|
|
: EndTag(fontToTag(type)), font_type_(type)
|
|
|
|
{}
|
|
|
|
|
2010-01-19 22:08:04 +00:00
|
|
|
} // namespace html
|
|
|
|
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
///
|
|
|
|
/// XHTMLStream
|
|
|
|
///
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
|
2013-05-07 04:19:34 +00:00
|
|
|
XHTMLStream::XHTMLStream(odocstream & os)
|
|
|
|
: os_(os), escape_(ESCAPE_ALL)
|
2009-11-19 16:29:57 +00:00
|
|
|
{}
|
|
|
|
|
|
|
|
|
2013-05-07 04:19:34 +00:00
|
|
|
#ifdef XHTML_DEBUG
|
2016-07-09 18:28:27 +00:00
|
|
|
void XHTMLStream::dumpTagStack(string const & msg)
|
2012-04-08 13:59:57 +00:00
|
|
|
{
|
2016-07-09 18:28:27 +00:00
|
|
|
*this << html::CR();
|
|
|
|
writeError(msg);
|
|
|
|
*this << html::CR();
|
|
|
|
writeError("Tag Stack");
|
|
|
|
TagDeque::const_reverse_iterator it = tag_stack_.rbegin();
|
|
|
|
TagDeque::const_reverse_iterator en = tag_stack_.rend();
|
2012-04-08 13:59:57 +00:00
|
|
|
for (; it != en; ++it) {
|
2016-07-09 18:28:27 +00:00
|
|
|
writeError(it->get()->tag_);
|
2012-04-08 13:59:57 +00:00
|
|
|
}
|
2016-07-09 18:28:27 +00:00
|
|
|
writeError("End Tag Stack");
|
|
|
|
*this << html::CR();
|
2012-04-08 13:59:57 +00:00
|
|
|
writeError("Pending Tags");
|
|
|
|
it = pending_tags_.rbegin();
|
|
|
|
en = pending_tags_.rend();
|
|
|
|
for (; it != en; ++it) {
|
2016-07-09 18:28:27 +00:00
|
|
|
writeError(it->get()->tag_);
|
2012-04-08 13:59:57 +00:00
|
|
|
}
|
2016-07-09 18:28:27 +00:00
|
|
|
writeError("End Pending Tags");
|
|
|
|
*this << html::CR();
|
2012-04-08 13:59:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
void XHTMLStream::writeError(std::string const & s) const
|
2009-11-19 21:50:02 +00:00
|
|
|
{
|
|
|
|
LYXERR0(s);
|
2012-04-03 22:13:59 +00:00
|
|
|
os_ << from_utf8("<!-- Output Error: " + s + " -->\n");
|
2009-11-19 21:50:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-03 01:56:20 +00:00
|
|
|
namespace {
|
|
|
|
// an illegal tag for internal use
|
2013-05-07 06:30:26 +00:00
|
|
|
static html::StartTag const parsep_tag("&LyX_parsep_tag&");
|
2017-07-23 11:11:54 +00:00
|
|
|
} // namespace
|
2011-04-03 01:56:20 +00:00
|
|
|
|
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
bool XHTMLStream::closeFontTags()
|
|
|
|
{
|
2012-04-08 14:02:40 +00:00
|
|
|
if (isTagPending(parsep_tag))
|
|
|
|
// we haven't had any content
|
|
|
|
return true;
|
|
|
|
|
2016-08-05 02:00:24 +00:00
|
|
|
#ifdef XHTML_DEBUG
|
|
|
|
dumpTagStack("Beging Close Font Tags");
|
|
|
|
#endif
|
|
|
|
|
2012-04-08 14:02:40 +00:00
|
|
|
// this may be a useless check, since we ought at least to have
|
|
|
|
// the parsep_tag. but it can't hurt too much to be careful.
|
2009-11-19 21:56:08 +00:00
|
|
|
if (tag_stack_.empty())
|
|
|
|
return true;
|
2012-04-08 14:02:40 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// first, we close any open font tags we can close
|
2013-05-07 04:19:34 +00:00
|
|
|
TagPtr curtag = tag_stack_.back();
|
2013-05-07 06:34:15 +00:00
|
|
|
while (curtag->asFontTag()) {
|
|
|
|
os_ << curtag->writeEndTag();
|
2009-11-19 16:29:57 +00:00
|
|
|
tag_stack_.pop_back();
|
2013-05-07 04:19:34 +00:00
|
|
|
// this shouldn't happen, since then the font tags
|
|
|
|
// weren't in any other tag.
|
2016-08-05 01:57:13 +00:00
|
|
|
LASSERT(!tag_stack_.empty(), return true);
|
2009-11-19 16:29:57 +00:00
|
|
|
curtag = tag_stack_.back();
|
|
|
|
}
|
2015-05-17 15:27:12 +00:00
|
|
|
|
2016-08-05 02:00:24 +00:00
|
|
|
#ifdef XHTML_DEBUG
|
|
|
|
dumpTagStack("End Close Font Tags");
|
|
|
|
#endif
|
2017-07-03 17:53:14 +00:00
|
|
|
|
2013-05-07 06:30:26 +00:00
|
|
|
if (*curtag == parsep_tag)
|
2011-04-03 01:56:20 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
// so we've hit a non-font tag.
|
|
|
|
writeError("Tags still open in closeFontTags(). Probably not a problem,\n"
|
|
|
|
"but you might want to check these tags:");
|
2013-05-07 04:19:34 +00:00
|
|
|
TagDeque::const_reverse_iterator it = tag_stack_.rbegin();
|
|
|
|
TagDeque::const_reverse_iterator const en = tag_stack_.rend();
|
2009-11-19 16:29:57 +00:00
|
|
|
for (; it != en; ++it) {
|
2013-05-07 06:30:26 +00:00
|
|
|
if (**it == parsep_tag)
|
2011-04-03 01:56:20 +00:00
|
|
|
break;
|
2013-05-07 04:19:34 +00:00
|
|
|
writeError((*it)->tag_);
|
2009-11-19 16:29:57 +00:00
|
|
|
}
|
2011-04-03 01:56:20 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-07-10 03:53:18 +00:00
|
|
|
void XHTMLStream::startDivision(bool keep_empty)
|
2011-04-03 01:56:20 +00:00
|
|
|
{
|
2013-05-07 04:19:34 +00:00
|
|
|
pending_tags_.push_back(makeTagPtr(html::StartTag(parsep_tag)));
|
2011-06-20 15:55:41 +00:00
|
|
|
if (keep_empty)
|
|
|
|
clearTagDeque();
|
2016-08-05 02:00:24 +00:00
|
|
|
#ifdef XHTML_DEBUG
|
|
|
|
dumpTagStack("StartDivision");
|
|
|
|
#endif
|
2011-04-03 01:56:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-07-10 03:53:18 +00:00
|
|
|
void XHTMLStream::endDivision()
|
2011-04-03 01:56:20 +00:00
|
|
|
{
|
2012-04-08 14:03:23 +00:00
|
|
|
if (isTagPending(parsep_tag)) {
|
|
|
|
// this case is normal. it just means we didn't have content,
|
|
|
|
// so the parsep_tag never got moved onto the tag stack.
|
2011-04-03 01:56:20 +00:00
|
|
|
while (!pending_tags_.empty()) {
|
|
|
|
// clear all pending tags up to and including the parsep tag.
|
|
|
|
// note that we work from the back, because we want to get rid
|
2012-04-08 14:03:23 +00:00
|
|
|
// of everything that hasn't been used.
|
2013-05-07 04:19:34 +00:00
|
|
|
TagPtr const cur_tag = pending_tags_.back();
|
2012-04-08 14:03:23 +00:00
|
|
|
pending_tags_.pop_back();
|
2013-05-07 06:30:26 +00:00
|
|
|
if (*cur_tag == parsep_tag)
|
2011-04-03 01:56:20 +00:00
|
|
|
break;
|
|
|
|
}
|
2016-08-05 02:00:24 +00:00
|
|
|
|
|
|
|
#ifdef XHTML_DEBUG
|
|
|
|
dumpTagStack("EndDivision");
|
|
|
|
#endif
|
2017-07-03 17:53:14 +00:00
|
|
|
|
2011-04-03 01:56:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-04-08 14:03:23 +00:00
|
|
|
if (!isTagOpen(parsep_tag)) {
|
2016-07-10 03:53:18 +00:00
|
|
|
writeError("No division separation tag found in endDivision().");
|
2012-04-08 14:03:23 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-05-17 15:27:12 +00:00
|
|
|
// this case is also normal, if the parsep tag is the last one
|
2011-04-03 01:56:20 +00:00
|
|
|
// on the stack. otherwise, it's an error.
|
|
|
|
while (!tag_stack_.empty()) {
|
2013-05-07 04:19:34 +00:00
|
|
|
TagPtr const cur_tag = tag_stack_.back();
|
2011-04-03 01:56:20 +00:00
|
|
|
tag_stack_.pop_back();
|
2013-05-07 06:30:26 +00:00
|
|
|
if (*cur_tag == parsep_tag)
|
2011-04-03 01:56:20 +00:00
|
|
|
break;
|
2013-05-07 04:19:34 +00:00
|
|
|
writeError("Tag `" + cur_tag->tag_ + "' still open at end of paragraph. Closing.");
|
2013-05-07 06:34:15 +00:00
|
|
|
os_ << cur_tag->writeEndTag();
|
2011-04-03 01:56:20 +00:00
|
|
|
}
|
2016-08-05 02:00:24 +00:00
|
|
|
|
|
|
|
#ifdef XHTML_DEBUG
|
|
|
|
dumpTagStack("EndDivision");
|
|
|
|
#endif
|
2009-11-19 16:29:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void XHTMLStream::clearTagDeque()
|
|
|
|
{
|
|
|
|
while (!pending_tags_.empty()) {
|
2013-05-07 04:19:34 +00:00
|
|
|
TagPtr const tag = pending_tags_.front();
|
2013-05-07 06:30:26 +00:00
|
|
|
if (*tag != parsep_tag)
|
2011-04-03 01:56:20 +00:00
|
|
|
// tabs?
|
2013-05-07 06:34:15 +00:00
|
|
|
os_ << tag->writeTag();
|
2009-11-19 16:29:57 +00:00
|
|
|
tag_stack_.push_back(tag);
|
|
|
|
pending_tags_.pop_front();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-19 20:22:04 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(docstring const & d)
|
|
|
|
{
|
|
|
|
clearTagDeque();
|
2010-11-24 15:27:36 +00:00
|
|
|
os_ << html::htmlize(d, escape_);
|
|
|
|
escape_ = ESCAPE_ALL;
|
2009-11-19 16:29:57 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 20:22:04 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(const char * s)
|
|
|
|
{
|
|
|
|
clearTagDeque();
|
2009-11-19 23:29:07 +00:00
|
|
|
docstring const d = from_ascii(s);
|
2010-11-24 15:27:36 +00:00
|
|
|
os_ << html::htmlize(d, escape_);
|
|
|
|
escape_ = ESCAPE_ALL;
|
2009-11-19 20:22:04 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(char_type c)
|
|
|
|
{
|
|
|
|
clearTagDeque();
|
2010-11-24 15:27:36 +00:00
|
|
|
os_ << html::escapeChar(c, escape_);
|
|
|
|
escape_ = ESCAPE_ALL;
|
2009-11-19 23:29:07 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-09-15 17:19:29 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(char c)
|
|
|
|
{
|
|
|
|
clearTagDeque();
|
2015-09-20 18:47:33 +00:00
|
|
|
os_ << html::escapeChar(c, escape_);
|
2010-11-24 15:27:36 +00:00
|
|
|
escape_ = ESCAPE_ALL;
|
2010-09-15 17:19:29 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-12 21:06:55 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(int i)
|
|
|
|
{
|
|
|
|
clearTagDeque();
|
|
|
|
os_ << i;
|
2010-11-24 15:27:36 +00:00
|
|
|
escape_ = ESCAPE_ALL;
|
2010-01-12 21:06:55 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-24 15:27:36 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(EscapeSettings e)
|
2015-05-17 15:27:12 +00:00
|
|
|
{
|
2010-11-24 15:27:36 +00:00
|
|
|
escape_ = e;
|
2009-11-19 16:29:57 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-17 15:27:12 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(html::StartTag const & tag)
|
2009-11-19 16:29:57 +00:00
|
|
|
{
|
2009-11-19 20:39:07 +00:00
|
|
|
if (tag.tag_.empty())
|
|
|
|
return *this;
|
2013-05-07 04:19:34 +00:00
|
|
|
pending_tags_.push_back(makeTagPtr(tag));
|
2009-11-19 16:29:57 +00:00
|
|
|
if (tag.keepempty_)
|
|
|
|
clearTagDeque();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-07 05:16:14 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(html::ParTag const & tag)
|
|
|
|
{
|
|
|
|
if (tag.tag_.empty())
|
|
|
|
return *this;
|
|
|
|
pending_tags_.push_back(makeTagPtr(tag));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-17 15:27:12 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(html::CompTag const & tag)
|
2009-11-19 16:29:57 +00:00
|
|
|
{
|
2009-11-19 20:39:07 +00:00
|
|
|
if (tag.tag_.empty())
|
|
|
|
return *this;
|
2009-11-19 16:29:57 +00:00
|
|
|
clearTagDeque();
|
2013-05-07 06:34:15 +00:00
|
|
|
os_ << tag.writeTag();
|
2011-04-01 19:18:25 +00:00
|
|
|
*this << html::CR();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-07 06:34:15 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(html::FontTag const & tag)
|
|
|
|
{
|
|
|
|
if (tag.tag_.empty())
|
|
|
|
return *this;
|
|
|
|
pending_tags_.push_back(makeTagPtr(tag));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-01 19:18:25 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(html::CR const &)
|
|
|
|
{
|
|
|
|
// tabs?
|
|
|
|
os_ << from_ascii("\n");
|
2009-11-19 16:29:57 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-07 06:30:26 +00:00
|
|
|
bool XHTMLStream::isTagOpen(html::StartTag const & stag) const
|
|
|
|
{
|
|
|
|
TagDeque::const_iterator sit = tag_stack_.begin();
|
|
|
|
TagDeque::const_iterator const sen = tag_stack_.end();
|
|
|
|
for (; sit != sen; ++sit)
|
|
|
|
if (**sit == stag)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool XHTMLStream::isTagOpen(html::EndTag const & etag) const
|
2009-11-19 16:29:57 +00:00
|
|
|
{
|
2013-05-07 04:19:34 +00:00
|
|
|
TagDeque::const_iterator sit = tag_stack_.begin();
|
|
|
|
TagDeque::const_iterator const sen = tag_stack_.end();
|
2009-11-19 16:29:57 +00:00
|
|
|
for (; sit != sen; ++sit)
|
2013-05-07 06:30:26 +00:00
|
|
|
if (etag == **sit)
|
2009-11-19 16:29:57 +00:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-07 06:30:26 +00:00
|
|
|
bool XHTMLStream::isTagPending(html::StartTag const & stag) const
|
2012-04-08 14:02:40 +00:00
|
|
|
{
|
2013-05-07 04:19:34 +00:00
|
|
|
TagDeque::const_iterator sit = pending_tags_.begin();
|
|
|
|
TagDeque::const_iterator const sen = pending_tags_.end();
|
2012-04-08 14:02:40 +00:00
|
|
|
for (; sit != sen; ++sit)
|
2013-05-07 06:30:26 +00:00
|
|
|
if (**sit == stag)
|
2012-04-08 14:02:40 +00:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// this is complicated, because we want to make sure that
|
2015-05-17 15:27:12 +00:00
|
|
|
// everything is properly nested. the code ought to make
|
2009-11-19 16:29:57 +00:00
|
|
|
// 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.
|
2010-01-19 22:08:04 +00:00
|
|
|
XHTMLStream & XHTMLStream::operator<<(html::EndTag const & etag)
|
2009-11-19 16:29:57 +00:00
|
|
|
{
|
2009-11-19 20:39:07 +00:00
|
|
|
if (etag.tag_.empty())
|
|
|
|
return *this;
|
2010-01-14 17:10:40 +00:00
|
|
|
|
2013-05-07 04:19:34 +00:00
|
|
|
// if this tag is pending, we can simply discard it.
|
2009-11-19 16:29:57 +00:00
|
|
|
if (!pending_tags_.empty()) {
|
2013-05-07 04:19:34 +00:00
|
|
|
|
2013-05-07 06:30:26 +00:00
|
|
|
if (etag == *pending_tags_.back()) {
|
2015-05-17 15:27:12 +00:00
|
|
|
// we have <tag></tag>, so we discard it and remove it
|
2009-11-19 16:29:57 +00:00
|
|
|
// from the pending_tags_.
|
|
|
|
pending_tags_.pop_back();
|
|
|
|
return *this;
|
|
|
|
}
|
2013-05-07 04:19:34 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// there is a pending tag that isn't the one we are trying
|
2015-05-17 15:27:12 +00:00
|
|
|
// to close.
|
2013-05-07 04:19:34 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// is this tag itself pending?
|
|
|
|
// non-const iterators because we may call erase().
|
2013-05-07 04:19:34 +00:00
|
|
|
TagDeque::iterator dit = pending_tags_.begin();
|
|
|
|
TagDeque::iterator const den = pending_tags_.end();
|
2009-11-19 16:29:57 +00:00
|
|
|
for (; dit != den; ++dit) {
|
2013-05-07 06:30:26 +00:00
|
|
|
if (etag == **dit) {
|
2009-11-19 16:29:57 +00:00
|
|
|
// it was pending, so we just erase it
|
2015-05-17 15:27:12 +00:00
|
|
|
writeError("Tried to close pending tag `" + etag.tag_
|
2009-12-10 18:30:48 +00:00
|
|
|
+ "' when other tags were pending. Last pending tag is `"
|
2015-05-17 15:27:12 +00:00
|
|
|
+ to_utf8(pending_tags_.back()->writeTag())
|
2013-05-13 15:58:52 +00:00
|
|
|
+ "'. Tag discarded.");
|
2009-11-19 16:29:57 +00:00
|
|
|
pending_tags_.erase(dit);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// so etag isn't itself pending. is it even open?
|
2013-05-07 06:30:26 +00:00
|
|
|
if (!isTagOpen(etag)) {
|
2015-05-17 15:27:12 +00:00
|
|
|
writeError("Tried to close `" + etag.tag_
|
2009-11-19 21:50:02 +00:00
|
|
|
+ "' when tag was not open. Tag discarded.");
|
2009-11-19 16:29:57 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
// ok, so etag is open.
|
2015-05-17 15:27:12 +00:00
|
|
|
// our strategy will be as below: we will do what we need to
|
2009-11-19 16:29:57 +00:00
|
|
|
// do to close this tag.
|
2015-05-17 15:27:12 +00:00
|
|
|
string estr = "Closing tag `" + etag.tag_
|
2009-11-19 21:50:02 +00:00
|
|
|
+ "' when other tags are pending. Discarded pending tags:\n";
|
2009-11-19 16:29:57 +00:00
|
|
|
for (dit = pending_tags_.begin(); dit != den; ++dit)
|
2013-05-13 15:58:52 +00:00
|
|
|
estr += to_utf8(html::htmlize((*dit)->writeTag(), XHTMLStream::ESCAPE_ALL)) + "\n";
|
2009-11-19 21:50:02 +00:00
|
|
|
writeError(estr);
|
2009-11-19 16:29:57 +00:00
|
|
|
// clear the pending tags...
|
|
|
|
pending_tags_.clear();
|
|
|
|
// ...and then just fall through.
|
|
|
|
}
|
|
|
|
|
2013-05-07 04:19:34 +00:00
|
|
|
// make sure there are tags to be closed
|
|
|
|
if (tag_stack_.empty()) {
|
|
|
|
writeError("Tried to close `" + etag.tag_
|
|
|
|
+ "' when no tags were open!");
|
2015-05-17 15:27:12 +00:00
|
|
|
return *this;
|
2013-05-07 04:19:34 +00:00
|
|
|
}
|
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// is the tag we are closing the last one we opened?
|
2013-05-07 06:30:26 +00:00
|
|
|
if (etag == *tag_stack_.back()) {
|
2009-11-19 16:29:57 +00:00
|
|
|
// output it...
|
2013-05-07 06:34:15 +00:00
|
|
|
os_ << etag.writeEndTag();
|
2009-11-19 16:29:57 +00:00
|
|
|
// ...and forget about it
|
|
|
|
tag_stack_.pop_back();
|
|
|
|
return *this;
|
2015-05-17 15:27:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// we are trying to close a tag other than the one last opened.
|
2009-11-19 16:29:57 +00:00
|
|
|
// let's first see if this particular tag is still open somehow.
|
2013-05-07 06:30:26 +00:00
|
|
|
if (!isTagOpen(etag)) {
|
2015-05-17 15:27:12 +00:00
|
|
|
writeError("Tried to close `" + etag.tag_
|
2009-11-19 21:50:02 +00:00
|
|
|
+ "' when tag was not open. Tag discarded.");
|
2009-11-19 16:29:57 +00:00
|
|
|
return *this;
|
|
|
|
}
|
2015-05-17 15:27:12 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// so the tag was opened, but other tags have been opened since
|
|
|
|
// and not yet closed.
|
|
|
|
// if it's a font tag, though...
|
2013-05-07 06:34:15 +00:00
|
|
|
if (etag.asFontTag()) {
|
2009-11-19 16:29:57 +00:00
|
|
|
// it won't be a problem if the other tags open since this one
|
|
|
|
// are also font tags.
|
2013-05-07 04:19:34 +00:00
|
|
|
TagDeque::const_reverse_iterator rit = tag_stack_.rbegin();
|
|
|
|
TagDeque::const_reverse_iterator ren = tag_stack_.rend();
|
2009-11-19 16:29:57 +00:00
|
|
|
for (; rit != ren; ++rit) {
|
2013-05-07 06:30:26 +00:00
|
|
|
if (etag == **rit)
|
2009-11-19 18:24:19 +00:00
|
|
|
break;
|
2013-05-07 06:34:15 +00:00
|
|
|
if (!(*rit)->asFontTag()) {
|
2009-11-19 16:29:57 +00:00
|
|
|
// we'll just leave it and, presumably, have to close it later.
|
2015-05-17 15:27:12 +00:00
|
|
|
writeError("Unable to close font tag `" + etag.tag_
|
2013-05-07 04:19:34 +00:00
|
|
|
+ "' due to open non-font tag `" + (*rit)->tag_ + "'.");
|
2009-11-19 16:29:57 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
}
|
2015-05-17 15:27:12 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// 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...
|
2013-05-07 04:19:34 +00:00
|
|
|
TagPtr curtag = tag_stack_.back();
|
2009-11-19 16:29:57 +00:00
|
|
|
// ...remembering them in a stack.
|
2013-05-07 04:19:34 +00:00
|
|
|
TagDeque fontstack;
|
2013-05-07 06:30:26 +00:00
|
|
|
while (etag != *curtag) {
|
2013-05-07 06:34:15 +00:00
|
|
|
os_ << curtag->writeEndTag();
|
2009-11-19 16:29:57 +00:00
|
|
|
fontstack.push_back(curtag);
|
|
|
|
tag_stack_.pop_back();
|
|
|
|
curtag = tag_stack_.back();
|
|
|
|
}
|
2015-05-17 15:27:12 +00:00
|
|
|
os_ << etag.writeEndTag();
|
2009-11-19 21:04:40 +00:00
|
|
|
tag_stack_.pop_back();
|
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// ...and restore the other tags.
|
|
|
|
rit = fontstack.rbegin();
|
|
|
|
ren = fontstack.rend();
|
|
|
|
for (; rit != ren; ++rit)
|
|
|
|
pending_tags_.push_back(*rit);
|
|
|
|
return *this;
|
|
|
|
}
|
2015-05-17 15:27:12 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
// it wasn't a font tag.
|
2015-05-17 15:27:12 +00:00
|
|
|
// 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
|
2009-11-19 16:29:57 +00:00
|
|
|
// at least guarantees proper nesting.
|
2015-05-17 15:27:12 +00:00
|
|
|
writeError("Closing tag `" + etag.tag_
|
2009-11-19 21:50:02 +00:00
|
|
|
+ "' when other tags are open, namely:");
|
2013-05-07 04:19:34 +00:00
|
|
|
TagPtr curtag = tag_stack_.back();
|
2013-05-07 06:30:26 +00:00
|
|
|
while (etag != *curtag) {
|
2013-05-07 04:19:34 +00:00
|
|
|
writeError(curtag->tag_);
|
2013-05-07 06:30:26 +00:00
|
|
|
if (*curtag != parsep_tag)
|
2013-05-07 06:34:15 +00:00
|
|
|
os_ << curtag->writeEndTag();
|
2009-11-19 16:29:57 +00:00
|
|
|
tag_stack_.pop_back();
|
|
|
|
curtag = tag_stack_.back();
|
|
|
|
}
|
|
|
|
// curtag is now the one we actually want.
|
2013-05-07 06:34:15 +00:00
|
|
|
os_ << curtag->writeEndTag();
|
2009-11-19 16:29:57 +00:00
|
|
|
tag_stack_.pop_back();
|
2014-04-21 14:50:56 +00:00
|
|
|
|
2009-11-19 16:29:57 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
// End code for XHTMLStream
|
2009-06-05 18:18:44 +00:00
|
|
|
|
|
|
|
namespace {
|
2010-09-15 14:42:50 +00:00
|
|
|
|
2014-04-21 14:50:56 +00:00
|
|
|
// convenience functions
|
2010-09-15 14:42:50 +00:00
|
|
|
|
2013-05-07 05:16:14 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
inline void closeTag(XHTMLStream & xs, Layout const & lay)
|
2009-06-05 18:18:44 +00:00
|
|
|
{
|
2010-01-19 22:08:04 +00:00
|
|
|
xs << html::EndTag(lay.htmltag());
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
inline void openLabelTag(XHTMLStream & xs, Layout const & lay)
|
2009-06-05 17:49:10 +00:00
|
|
|
{
|
2010-01-19 22:08:04 +00:00
|
|
|
xs << html::StartTag(lay.htmllabeltag(), lay.htmllabelattr());
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
inline void closeLabelTag(XHTMLStream & xs, Layout const & lay)
|
2009-06-05 17:49:10 +00:00
|
|
|
{
|
2010-01-19 22:08:04 +00:00
|
|
|
xs << html::EndTag(lay.htmllabeltag());
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
inline void openItemTag(XHTMLStream & xs, Layout const & lay)
|
2009-06-05 17:49:10 +00:00
|
|
|
{
|
2010-01-19 22:08:04 +00:00
|
|
|
xs << html::StartTag(lay.htmlitemtag(), lay.htmlitemattr(), true);
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-17 15:27:12 +00:00
|
|
|
void openItemTag(XHTMLStream & xs, Layout const & lay,
|
2010-09-15 17:29:51 +00:00
|
|
|
ParagraphParameters const & params)
|
|
|
|
{
|
|
|
|
// FIXME Are there other things we should handle here?
|
|
|
|
string const align = alignmentToCSS(params.align());
|
|
|
|
if (align.empty()) {
|
|
|
|
openItemTag(xs, lay);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
string attrs = lay.htmlattr() + " style='text-align: " + align + ";'";
|
|
|
|
xs << html::StartTag(lay.htmlitemtag(), attrs);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
inline void closeItemTag(XHTMLStream & xs, Layout const & lay)
|
2009-06-05 17:49:10 +00:00
|
|
|
{
|
2010-01-19 22:08:04 +00:00
|
|
|
xs << html::EndTag(lay.htmlitemtag());
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
// end of convenience functions
|
2009-11-19 16:29:57 +00:00
|
|
|
|
2013-05-02 19:20:50 +00:00
|
|
|
ParagraphList::const_iterator findLastParagraph(
|
2009-06-05 17:49:10 +00:00
|
|
|
ParagraphList::const_iterator p,
|
2009-10-26 20:45:29 +00:00
|
|
|
ParagraphList::const_iterator const & pend)
|
2009-06-05 17:49:10 +00:00
|
|
|
{
|
|
|
|
for (++p; p != pend && p->layout().latextype == LATEX_PARAGRAPH; ++p)
|
|
|
|
;
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-05-02 19:20:50 +00:00
|
|
|
ParagraphList::const_iterator findEndOfEnvironment(
|
2014-07-05 17:13:10 +00:00
|
|
|
ParagraphList::const_iterator const & pstart,
|
2009-06-05 17:49:10 +00:00
|
|
|
ParagraphList::const_iterator const & pend)
|
|
|
|
{
|
2009-10-26 02:21:59 +00:00
|
|
|
ParagraphList::const_iterator p = pstart;
|
2009-06-05 17:49:10 +00:00
|
|
|
Layout const & bstyle = p->layout();
|
|
|
|
size_t const depth = p->params().depth();
|
|
|
|
for (++p; p != pend; ++p) {
|
|
|
|
Layout const & style = p->layout();
|
|
|
|
// It shouldn't happen that e.g. a section command occurs inside
|
|
|
|
// a quotation environment, at a higher depth, but as of 6/2009,
|
|
|
|
// it can happen. We pretend that it's just at lowest depth.
|
|
|
|
if (style.latextype == LATEX_COMMAND)
|
|
|
|
return p;
|
2013-07-17 13:14:39 +00:00
|
|
|
|
2009-06-05 17:49:10 +00:00
|
|
|
// If depth is down, we're done
|
|
|
|
if (p->params().depth() < depth)
|
|
|
|
return p;
|
2013-07-17 13:14:39 +00:00
|
|
|
|
2009-06-05 17:49:10 +00:00
|
|
|
// If depth is up, we're not done
|
|
|
|
if (p->params().depth() > depth)
|
|
|
|
continue;
|
2013-07-17 13:14:39 +00:00
|
|
|
|
|
|
|
// FIXME I am not sure about the first check.
|
|
|
|
// Surely we *could* have different layouts that count as
|
2015-05-17 15:27:12 +00:00
|
|
|
// LATEX_PARAGRAPH, right?
|
2013-07-17 13:14:39 +00:00
|
|
|
if (style.latextype == LATEX_PARAGRAPH || style != bstyle)
|
2009-06-05 17:49:10 +00:00
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return pend;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-05 18:45:23 +00:00
|
|
|
ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
|
2009-11-19 17:51:06 +00:00
|
|
|
XHTMLStream & xs,
|
2009-06-05 17:49:10 +00:00
|
|
|
OutputParams const & runparams,
|
2009-08-09 18:35:39 +00:00
|
|
|
Text const & text,
|
2009-06-05 17:49:10 +00:00
|
|
|
ParagraphList::const_iterator const & pbegin,
|
|
|
|
ParagraphList::const_iterator const & pend)
|
|
|
|
{
|
2009-08-09 18:35:39 +00:00
|
|
|
ParagraphList::const_iterator const begin = text.paragraphs().begin();
|
2009-06-05 17:49:10 +00:00
|
|
|
ParagraphList::const_iterator par = pbegin;
|
|
|
|
for (; par != pend; ++par) {
|
|
|
|
Layout const & lay = par->layout();
|
2009-06-06 03:22:55 +00:00
|
|
|
if (!lay.counter.empty())
|
2013-03-18 22:45:09 +00:00
|
|
|
buf.masterBuffer()->params().
|
|
|
|
documentClass().counters().step(lay.counter, OutputUpdate);
|
2016-07-10 03:12:32 +00:00
|
|
|
|
2009-06-06 03:32:55 +00:00
|
|
|
// FIXME We should see if there's a label to be output and
|
|
|
|
// do something with it.
|
2009-06-05 17:49:10 +00:00
|
|
|
if (par != pbegin)
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::CR();
|
2009-10-26 20:53:46 +00:00
|
|
|
|
2016-07-10 03:12:32 +00:00
|
|
|
// 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
|
2016-08-05 02:43:17 +00:00
|
|
|
//
|
|
|
|
// 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
|
2017-07-03 17:53:14 +00:00
|
|
|
// only one item, and that item is "inline", i.e., not HTMLIsBlock (such
|
2016-08-05 02:43:17 +00:00
|
|
|
// 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;
|
2016-07-10 03:12:32 +00:00
|
|
|
Inset const * specinset = par->size() == 1 ? par->getInset(0) : 0;
|
2016-08-05 02:43:17 +00:00
|
|
|
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;
|
|
|
|
}
|
2016-07-10 03:12:32 +00:00
|
|
|
|
2016-07-10 03:53:18 +00:00
|
|
|
bool const open_par = runparams.html_make_pars
|
2016-07-10 03:12:32 +00:00
|
|
|
&& (!runparams.html_in_par || par != pbegin)
|
|
|
|
&& !special_case;
|
2009-10-26 20:53:46 +00:00
|
|
|
|
|
|
|
// 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.
|
2015-05-17 15:27:12 +00:00
|
|
|
// (ii) We didn't open it and html_in_par is true,
|
2009-10-26 20:53:46 +00:00
|
|
|
// but we are in the first par, and there is a next par.
|
|
|
|
ParagraphList::const_iterator nextpar = par;
|
2012-05-28 20:41:32 +00:00
|
|
|
++nextpar;
|
2016-07-10 03:53:18 +00:00
|
|
|
bool const close_par =
|
|
|
|
(open_par && (!runparams.html_in_par || nextpar != pend))
|
|
|
|
|| (!open_par && runparams.html_in_par && par == pbegin && nextpar != pend);
|
2016-07-10 03:12:32 +00:00
|
|
|
|
2016-07-10 03:53:18 +00:00
|
|
|
if (open_par) {
|
2017-07-03 17:53:14 +00:00
|
|
|
// We do not issue the paragraph id if we are doing
|
2016-07-10 03:12:32 +00:00
|
|
|
// this for the TOC (or some similar purpose)
|
|
|
|
openParTag(xs, lay, par->params(),
|
|
|
|
runparams.for_toc ? "" : par->magicLabel());
|
2009-11-19 17:51:06 +00:00
|
|
|
}
|
2016-07-10 03:12:32 +00:00
|
|
|
|
2017-07-03 17:53:14 +00:00
|
|
|
docstring const deferred = par->simpleLyXHTMLOnePar(buf, xs,
|
2016-07-10 03:12:32 +00:00
|
|
|
runparams, text.outerFont(distance(begin, par)),
|
2016-07-10 03:53:18 +00:00
|
|
|
open_par, close_par);
|
2016-07-10 03:12:32 +00:00
|
|
|
|
2016-07-10 03:53:18 +00:00
|
|
|
if (close_par) {
|
2016-07-10 03:12:32 +00:00
|
|
|
closeTag(xs, lay);
|
|
|
|
xs << html::CR();
|
|
|
|
}
|
2016-07-30 05:29:06 +00:00
|
|
|
|
|
|
|
if (!deferred.empty()) {
|
|
|
|
xs << XHTMLStream::ESCAPE_NONE << deferred << html::CR();
|
|
|
|
}
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
return pend;
|
|
|
|
}
|
|
|
|
|
2009-06-06 03:32:55 +00:00
|
|
|
|
2009-06-11 20:08:39 +00:00
|
|
|
ParagraphList::const_iterator makeBibliography(Buffer const & buf,
|
2009-11-19 17:51:06 +00:00
|
|
|
XHTMLStream & xs,
|
2009-06-11 20:08:39 +00:00
|
|
|
OutputParams const & runparams,
|
2009-08-09 18:35:39 +00:00
|
|
|
Text const & text,
|
2009-06-11 20:08:39 +00:00
|
|
|
ParagraphList::const_iterator const & pbegin,
|
2015-05-17 15:27:12 +00:00
|
|
|
ParagraphList::const_iterator const & pend)
|
2009-06-11 20:08:39 +00:00
|
|
|
{
|
2010-01-19 22:51:20 +00:00
|
|
|
// FIXME XHTML
|
|
|
|
// Use TextClass::htmlTOCLayout() to figure out how we should look.
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::StartTag("h2", "class='bibliography'")
|
2011-04-01 19:27:30 +00:00
|
|
|
<< pbegin->layout().labelstring(false)
|
|
|
|
<< html::EndTag("h2")
|
|
|
|
<< html::CR()
|
|
|
|
<< html::StartTag("div", "class='bibliography'")
|
|
|
|
<< html::CR();
|
2009-11-19 17:51:06 +00:00
|
|
|
makeParagraphs(buf, xs, runparams, text, pbegin, pend);
|
2010-01-19 22:08:04 +00:00
|
|
|
xs << html::EndTag("div");
|
2009-06-11 20:08:39 +00:00
|
|
|
return pend;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-19 16:35:58 +00:00
|
|
|
bool isNormalEnv(Layout const & lay)
|
|
|
|
{
|
2009-11-30 23:26:10 +00:00
|
|
|
return lay.latextype == LATEX_ENVIRONMENT
|
|
|
|
|| lay.latextype == LATEX_BIB_ENVIRONMENT;
|
2009-10-26 02:21:59 +00:00
|
|
|
}
|
|
|
|
|
2015-05-17 15:27:12 +00:00
|
|
|
|
2013-04-25 14:28:22 +00:00
|
|
|
ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
|
2009-11-19 17:51:06 +00:00
|
|
|
XHTMLStream & xs,
|
2009-06-05 17:49:10 +00:00
|
|
|
OutputParams const & runparams,
|
2009-08-09 18:35:39 +00:00
|
|
|
Text const & text,
|
2009-06-05 17:49:10 +00:00
|
|
|
ParagraphList::const_iterator const & pbegin,
|
2015-05-17 15:27:12 +00:00
|
|
|
ParagraphList::const_iterator const & pend)
|
2009-06-06 03:32:55 +00:00
|
|
|
{
|
2009-08-09 18:35:39 +00:00
|
|
|
ParagraphList::const_iterator const begin = text.paragraphs().begin();
|
2009-06-05 17:49:10 +00:00
|
|
|
ParagraphList::const_iterator par = pbegin;
|
|
|
|
Layout const & bstyle = par->layout();
|
|
|
|
depth_type const origdepth = pbegin->params().depth();
|
|
|
|
|
2009-11-19 17:51:06 +00:00
|
|
|
// open tag for this environment
|
2013-05-07 05:16:14 +00:00
|
|
|
openParTag(xs, bstyle, pbegin->magicLabel());
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::CR();
|
2009-06-05 17:49:10 +00:00
|
|
|
|
|
|
|
// we will on occasion need to remember a layout from before.
|
|
|
|
Layout const * lastlay = 0;
|
|
|
|
|
|
|
|
while (par != pend) {
|
|
|
|
Layout const & style = par->layout();
|
2009-10-26 02:21:59 +00:00
|
|
|
// the counter only gets stepped if we're in some kind of list,
|
|
|
|
// or if it's the first time through.
|
2009-11-19 21:50:02 +00:00
|
|
|
// note that enum, etc, are handled automatically.
|
|
|
|
// 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.
|
2013-03-18 22:45:09 +00:00
|
|
|
Counters & cnts = buf.masterBuffer()->params().documentClass().counters();
|
2009-12-03 19:35:31 +00:00
|
|
|
docstring const & cntr = style.counter;
|
2015-05-17 15:27:12 +00:00
|
|
|
if (!style.counter.empty()
|
|
|
|
&& (par == pbegin || !isNormalEnv(style))
|
2009-12-03 19:35:31 +00:00
|
|
|
&& cnts.hasCounter(cntr)
|
|
|
|
)
|
2010-01-20 19:42:12 +00:00
|
|
|
cnts.step(cntr, OutputUpdate);
|
2009-06-05 17:49:10 +00:00
|
|
|
ParagraphList::const_iterator send;
|
|
|
|
|
|
|
|
switch (style.latextype) {
|
|
|
|
case LATEX_ENVIRONMENT:
|
2009-06-06 03:22:55 +00:00
|
|
|
case LATEX_LIST_ENVIRONMENT:
|
2009-06-05 17:49:10 +00:00
|
|
|
case LATEX_ITEM_ENVIRONMENT: {
|
2015-05-17 15:27:12 +00:00
|
|
|
// There are two possiblities in this case.
|
|
|
|
// One is that we are still in the environment in which we
|
2009-06-05 17:49:10 +00:00
|
|
|
// started---which we will be if the depth is the same.
|
|
|
|
if (par->params().depth() == origdepth) {
|
2013-04-25 21:27:10 +00:00
|
|
|
LATTEST(bstyle == style);
|
2009-06-05 17:49:10 +00:00
|
|
|
if (lastlay != 0) {
|
2009-11-19 17:51:06 +00:00
|
|
|
closeItemTag(xs, *lastlay);
|
2009-06-05 17:49:10 +00:00
|
|
|
lastlay = 0;
|
|
|
|
}
|
2015-05-17 15:27:12 +00:00
|
|
|
|
2015-09-20 08:42:35 +00:00
|
|
|
// this will be positive, if we want to skip the
|
|
|
|
// initial word (if it's been taken for the label).
|
|
|
|
pos_type sep = 0;
|
2010-09-15 12:08:00 +00:00
|
|
|
bool const labelfirst = style.htmllabelfirst();
|
|
|
|
if (!labelfirst)
|
2010-09-15 17:29:51 +00:00
|
|
|
openItemTag(xs, style, par->params());
|
2015-05-17 15:27:12 +00:00
|
|
|
|
2010-09-15 12:08:00 +00:00
|
|
|
// label output
|
2015-05-17 15:27:12 +00:00
|
|
|
if (style.labeltype != LABEL_NO_LABEL &&
|
2010-09-15 12:08:00 +00:00
|
|
|
style.htmllabeltag() != "NONE") {
|
|
|
|
if (isNormalEnv(style)) {
|
2015-05-17 15:27:12 +00:00
|
|
|
// in this case, we print the label only for the first
|
2010-09-15 12:08:00 +00:00
|
|
|
// paragraph (as in a theorem).
|
|
|
|
if (par == pbegin) {
|
2015-05-17 15:27:12 +00:00
|
|
|
docstring const lbl =
|
2010-09-15 12:08:00 +00:00
|
|
|
pbegin->params().labelString();
|
|
|
|
if (!lbl.empty()) {
|
|
|
|
openLabelTag(xs, style);
|
|
|
|
xs << lbl;
|
|
|
|
closeLabelTag(xs, style);
|
|
|
|
}
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::CR();
|
2010-09-15 12:08:00 +00:00
|
|
|
}
|
2015-09-20 08:42:35 +00:00
|
|
|
} else { // some kind of list
|
2010-09-15 12:08:00 +00:00
|
|
|
if (style.labeltype == LABEL_MANUAL) {
|
2009-11-19 17:51:06 +00:00
|
|
|
openLabelTag(xs, style);
|
2010-09-15 12:08:00 +00:00
|
|
|
sep = par->firstWordLyXHTML(xs, runparams);
|
2009-11-19 17:51:06 +00:00
|
|
|
closeLabelTag(xs, style);
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::CR();
|
2010-09-15 12:08:00 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
openLabelTag(xs, style);
|
|
|
|
xs << par->params().labelString();
|
|
|
|
closeLabelTag(xs, style);
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::CR();
|
2009-10-26 02:37:31 +00:00
|
|
|
}
|
2009-10-26 02:21:59 +00:00
|
|
|
}
|
2010-09-15 12:08:00 +00:00
|
|
|
} // end label output
|
|
|
|
|
|
|
|
if (labelfirst)
|
2010-09-15 17:29:51 +00:00
|
|
|
openItemTag(xs, style, par->params());
|
2010-09-15 12:08:00 +00:00
|
|
|
|
2016-07-31 07:18:32 +00:00
|
|
|
docstring deferred = par->simpleLyXHTMLOnePar(buf, xs, runparams,
|
2016-07-10 03:12:32 +00:00
|
|
|
text.outerFont(distance(begin, par)), true, true, sep);
|
2016-07-31 07:18:32 +00:00
|
|
|
xs << XHTMLStream::ESCAPE_NONE << deferred;
|
2009-06-05 17:49:10 +00:00
|
|
|
++par;
|
2010-09-15 12:08:00 +00:00
|
|
|
|
|
|
|
// We may not want to close the tag yet, in particular:
|
|
|
|
// If we're not at the end...
|
2015-05-17 15:27:12 +00:00
|
|
|
if (par != pend
|
2009-11-19 17:51:06 +00:00
|
|
|
// and are doing items...
|
2009-11-19 22:13:44 +00:00
|
|
|
&& !isNormalEnv(style)
|
2009-11-19 17:51:06 +00:00
|
|
|
// and if the depth has changed...
|
|
|
|
&& par->params().depth() != origdepth) {
|
|
|
|
// then we'll save this layout for later, and close it when
|
|
|
|
// we get another item.
|
|
|
|
lastlay = &style;
|
|
|
|
} else
|
|
|
|
closeItemTag(xs, style);
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::CR();
|
2009-06-06 03:32:55 +00:00
|
|
|
}
|
2009-06-05 17:49:10 +00:00
|
|
|
// The other possibility is that the depth has increased, in which
|
|
|
|
// case we need to recurse.
|
|
|
|
else {
|
2013-05-02 19:20:50 +00:00
|
|
|
send = findEndOfEnvironment(par, pend);
|
2013-04-25 14:28:22 +00:00
|
|
|
par = makeEnvironment(buf, xs, runparams, text, par, send);
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case LATEX_PARAGRAPH:
|
2013-05-02 19:20:50 +00:00
|
|
|
send = findLastParagraph(par, pend);
|
2009-11-19 17:51:06 +00:00
|
|
|
par = makeParagraphs(buf, xs, runparams, text, par, send);
|
2009-06-05 17:49:10 +00:00
|
|
|
break;
|
2009-06-11 20:08:39 +00:00
|
|
|
// Shouldn't happen
|
2009-06-05 17:49:10 +00:00
|
|
|
case LATEX_BIB_ENVIRONMENT:
|
2009-06-11 20:08:39 +00:00
|
|
|
send = par;
|
|
|
|
++send;
|
2009-11-19 17:51:06 +00:00
|
|
|
par = makeParagraphs(buf, xs, runparams, text, par, send);
|
2009-06-11 20:08:39 +00:00
|
|
|
break;
|
|
|
|
// Shouldn't happen
|
2009-06-05 17:49:10 +00:00
|
|
|
case LATEX_COMMAND:
|
2009-06-06 03:22:55 +00:00
|
|
|
++par;
|
2009-06-05 17:49:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lastlay != 0)
|
2009-11-19 17:51:06 +00:00
|
|
|
closeItemTag(xs, *lastlay);
|
|
|
|
closeTag(xs, bstyle);
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::CR();
|
2009-06-05 17:49:10 +00:00
|
|
|
return pend;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void makeCommand(Buffer const & buf,
|
2012-10-27 13:45:27 +00:00
|
|
|
XHTMLStream & xs,
|
|
|
|
OutputParams const & runparams,
|
|
|
|
Text const & text,
|
|
|
|
ParagraphList::const_iterator const & pbegin)
|
2009-06-05 17:49:10 +00:00
|
|
|
{
|
|
|
|
Layout const & style = pbegin->layout();
|
2009-06-06 03:22:55 +00:00
|
|
|
if (!style.counter.empty())
|
2013-03-18 22:45:09 +00:00
|
|
|
buf.masterBuffer()->params().
|
|
|
|
documentClass().counters().step(style.counter, OutputUpdate);
|
2009-06-05 17:49:10 +00:00
|
|
|
|
2013-05-07 05:16:14 +00:00
|
|
|
bool const make_parid = !runparams.for_toc && runparams.html_make_pars;
|
2017-07-03 17:53:14 +00:00
|
|
|
|
2013-05-07 05:16:14 +00:00
|
|
|
openParTag(xs, style, pbegin->params(),
|
|
|
|
make_parid ? pbegin->magicLabel() : "");
|
2009-06-05 17:49:10 +00:00
|
|
|
|
|
|
|
// Label around sectioning number:
|
2009-06-06 03:22:55 +00:00
|
|
|
// FIXME Probably need to account for LABEL_MANUAL
|
2017-10-17 01:36:34 +00:00
|
|
|
// FIXME Probably also need now to account for labels ABOVE and CENTERED.
|
|
|
|
if (style.labeltype != LABEL_NO_LABEL) {
|
2009-11-19 17:51:06 +00:00
|
|
|
openLabelTag(xs, style);
|
2010-01-21 18:55:02 +00:00
|
|
|
xs << pbegin->params().labelString();
|
2009-11-19 17:51:06 +00:00
|
|
|
closeLabelTag(xs, style);
|
2009-06-05 17:49:10 +00:00
|
|
|
// Otherwise the label might run together with the text
|
2010-09-15 20:32:58 +00:00
|
|
|
xs << from_ascii(" ");
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
|
2009-08-09 18:35:39 +00:00
|
|
|
ParagraphList::const_iterator const begin = text.paragraphs().begin();
|
2009-11-19 18:24:19 +00:00
|
|
|
pbegin->simpleLyXHTMLOnePar(buf, xs, runparams,
|
|
|
|
text.outerFont(distance(begin, pbegin)));
|
2009-11-19 17:51:06 +00:00
|
|
|
closeTag(xs, style);
|
2011-04-01 19:18:25 +00:00
|
|
|
xs << html::CR();
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
|
2009-08-09 18:35:39 +00:00
|
|
|
void xhtmlParagraphs(Text const & text,
|
2009-06-05 17:49:10 +00:00
|
|
|
Buffer const & buf,
|
2009-11-19 17:51:06 +00:00
|
|
|
XHTMLStream & xs,
|
2009-06-05 17:49:10 +00:00
|
|
|
OutputParams const & runparams)
|
|
|
|
{
|
2009-08-09 18:35:39 +00:00
|
|
|
ParagraphList const & paragraphs = text.paragraphs();
|
2011-05-03 14:05:42 +00:00
|
|
|
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;
|
2013-04-25 21:27:10 +00:00
|
|
|
LASSERT(bpit < epit,
|
|
|
|
{ xs << XHTMLStream::ESCAPE_NONE << "<!-- XHTML output error! -->\n"; return; });
|
2009-06-05 17:49:10 +00:00
|
|
|
|
2011-04-19 00:50:24 +00:00
|
|
|
OutputParams ourparams = runparams;
|
2011-05-03 14:05:42 +00:00
|
|
|
ParagraphList::const_iterator const pend =
|
|
|
|
(epit == (int) paragraphs.size()) ?
|
|
|
|
paragraphs.end() : paragraphs.constIterator(epit);
|
|
|
|
while (bpit < epit) {
|
|
|
|
ParagraphList::const_iterator par = paragraphs.constIterator(bpit);
|
2010-01-20 21:20:30 +00:00
|
|
|
if (par->params().startOfAppendix()) {
|
2012-07-21 18:14:12 +00:00
|
|
|
// 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()) {
|
2012-07-22 09:45:39 +00:00
|
|
|
Counters & cnts =
|
2012-07-21 18:14:12 +00:00
|
|
|
buf.masterBuffer()->params().documentClass().counters();
|
|
|
|
cnts.reset(cnt);
|
|
|
|
}
|
2010-01-20 21:20:30 +00:00
|
|
|
}
|
2009-06-05 17:49:10 +00:00
|
|
|
Layout const & style = par->layout();
|
2011-05-03 14:05:42 +00:00
|
|
|
ParagraphList::const_iterator const lastpar = par;
|
2009-06-05 17:49:10 +00:00
|
|
|
ParagraphList::const_iterator send;
|
|
|
|
|
|
|
|
switch (style.latextype) {
|
|
|
|
case LATEX_COMMAND: {
|
|
|
|
// The files with which we are working never have more than
|
|
|
|
// one paragraph in a command structure.
|
2015-05-17 15:27:12 +00:00
|
|
|
// FIXME
|
2011-04-19 00:50:24 +00:00
|
|
|
// if (ourparams.html_in_par)
|
2009-10-26 20:53:46 +00:00
|
|
|
// 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
|
|
|
|
// can communicate that back.
|
|
|
|
// FIXME Maybe this fix should be in the routines themselves, in case
|
|
|
|
// they are called from elsewhere.
|
2011-04-19 00:50:24 +00:00
|
|
|
makeCommand(buf, xs, ourparams, text, par);
|
2009-06-05 17:49:10 +00:00
|
|
|
++par;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case LATEX_ENVIRONMENT:
|
2009-06-06 03:22:55 +00:00
|
|
|
case LATEX_LIST_ENVIRONMENT:
|
2009-06-05 17:49:10 +00:00
|
|
|
case LATEX_ITEM_ENVIRONMENT: {
|
2009-10-26 20:53:46 +00:00
|
|
|
// FIXME Same fix here.
|
2013-05-02 19:20:50 +00:00
|
|
|
send = findEndOfEnvironment(par, pend);
|
2013-04-25 14:28:22 +00:00
|
|
|
par = makeEnvironment(buf, xs, ourparams, text, par, send);
|
2009-06-11 20:08:39 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case LATEX_BIB_ENVIRONMENT: {
|
2009-10-26 20:53:46 +00:00
|
|
|
// FIXME Same fix here.
|
2013-05-02 19:20:50 +00:00
|
|
|
send = findEndOfEnvironment(par, pend);
|
2011-04-19 00:50:24 +00:00
|
|
|
par = makeBibliography(buf, xs, ourparams, text, par, send);
|
2009-06-05 17:49:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case LATEX_PARAGRAPH:
|
2013-05-02 19:20:50 +00:00
|
|
|
send = findLastParagraph(par, pend);
|
2011-04-19 00:50:24 +00:00
|
|
|
par = makeParagraphs(buf, xs, ourparams, text, par, send);
|
2009-06-05 17:49:10 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-05-03 14:05:42 +00:00
|
|
|
bpit += distance(lastpar, par);
|
2009-06-05 17:49:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-10-27 13:45:27 +00:00
|
|
|
string alignmentToCSS(LyXAlignment align)
|
|
|
|
{
|
2010-09-15 14:06:36 +00:00
|
|
|
switch (align) {
|
|
|
|
case LYX_ALIGN_BLOCK:
|
|
|
|
// we are NOT going to use text-align: justify!!
|
|
|
|
case LYX_ALIGN_LEFT:
|
|
|
|
return "left";
|
|
|
|
case LYX_ALIGN_RIGHT:
|
|
|
|
return "right";
|
|
|
|
case LYX_ALIGN_CENTER:
|
|
|
|
return "center";
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2009-06-05 17:49:10 +00:00
|
|
|
} // namespace lyx
|