}
+// FIXME do something here.
+docstring htmlize(docstring const & str) {
+ return str;
+}
+
// FIXME This needs to be protected somehow.
static vector<string> taglist;
-void openTag(odocstream & os, string tag, string attr)
+bool openTag(odocstream & os, string const & tag, string const & attr)
{
if (tag.empty())
- return;
+ return false;
// FIXME This is completely primitive. We need something
// a lot better.
// Now do some checks on nesting of tags.
if (tag == "p")
if (find(taglist.begin(), taglist.end(), "p") != taglist.end())
- return;
- if (!attr.empty())
- attr = ' ' + attr;
- os << from_ascii("<" + tag + attr + ">");
+ return false;
+ os << from_ascii("<" + tag + (attr.empty() ? "" : " " + attr) + ">");
taglist.push_back(tag);
+ return true;
}
-void closeTag(odocstream & os, string tag)
+bool closeTag(odocstream & os, string const & tag)
{
if (tag.empty())
- return;
+ return false;
// FIXME Check for proper nesting
+ if (taglist.empty()){
+ LYXERR0("Last tag not found when closing `" << tag << "'!");
+ return false;
+ }
string const & lasttag = taglist.back();
if (lasttag != tag) {
LYXERR0("Last tag was `" << lasttag << "' when closing `" << tag << "'!");
- return;
+ return false;
}
taglist.pop_back();
os << from_ascii("</" + tag + ">");
+ return true;
}
namespace {
-void openTag(odocstream & os, Layout const & lay)
+bool openTag(odocstream & os, Layout const & lay)
{
- html::openTag(os, lay.htmltag(), lay.htmlattr());
+ return html::openTag(os, lay.htmltag(), lay.htmlattr());
}
-void closeTag(odocstream & os, Layout const & lay)
+bool closeTag(odocstream & os, Layout const & lay)
{
- html::closeTag(os, lay.htmltag());
+ return html::closeTag(os, lay.htmltag());
}
-void openLabelTag(odocstream & os, Layout const & lay)
+bool openLabelTag(odocstream & os, Layout const & lay)
{
- html::openTag(os, lay.htmllabel(), lay.htmllabelattr());
+ return html::openTag(os, lay.htmllabel(), lay.htmllabelattr());
}
-void closeLabelTag(odocstream & os, Layout const & lay)
+bool closeLabelTag(odocstream & os, Layout const & lay)
{
- html::closeTag(os, lay.htmllabel());
+ return html::closeTag(os, lay.htmllabel());
}
-void openItemTag(odocstream & os, Layout const & lay)
+bool openItemTag(odocstream & os, Layout const & lay)
{
- html::openTag(os, lay.htmlitem(), lay.htmlitemattr());
+ return html::openTag(os, lay.htmlitem(), lay.htmlitemattr());
}
-void closeItemTag(odocstream & os, Layout const & lay)
+bool closeItemTag(odocstream & os, Layout const & lay)
{
- html::closeTag(os, lay.htmlitem());
+ return html::closeTag(os, lay.htmlitem());
}
ParagraphList::const_iterator searchParagraph(
}
-ParagraphList::const_iterator makeParagraph(Buffer const & buf,
+ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
odocstream & os,
OutputParams const & runparams,
ParagraphList const & paragraphs,
ParagraphList::const_iterator par = pbegin;
for (; par != pend; ++par) {
Layout const & lay = par->layout();
+ if (!lay.counter.empty())
+ buf.params().documentClass().counters().step(lay.counter);
+ // FIXME We should see if there's a label to be output and
+ // do something with it.
if (par != pbegin)
os << '\n';
- openTag(os, lay);
- par->simpleLyXHTMLOnePar(buf, os, runparams,
+ bool const opened = openTag(os, lay);
+ docstring const deferred = par->simpleLyXHTMLOnePar(buf, os, runparams,
outerFont(distance(paragraphs.begin(), par), paragraphs));
- closeTag(os, lay);
- os << '\n';
+ if (opened) {
+ closeTag(os, lay);
+ os << '\n';
+ }
+ if (!deferred.empty())
+ os << deferred << '\n';
}
return pend;
}
+
+ParagraphList::const_iterator makeBibliography(Buffer const & buf,
+ odocstream & os,
+ OutputParams const & runparams,
+ ParagraphList const & paragraphs,
+ ParagraphList::const_iterator const & pbegin,
+ ParagraphList::const_iterator const & pend)
+{
+ os << "<h2 class='bibliography'>"
+ << pbegin->layout().labelstring()
+ << "</h2>\n"
+ << "<div class='bibliography'>\n";
+ makeParagraphs(buf, os, runparams, paragraphs, pbegin, pend);
+ os << "</div>";
+ return pend;
+}
+
+
ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
odocstream & os,
OutputParams const & runparams,
ParagraphList const & paragraphs,
ParagraphList::const_iterator const & pbegin,
- ParagraphList::const_iterator const & pend) {
-
+ ParagraphList::const_iterator const & pend)
+{
ParagraphList::const_iterator par = pbegin;
Layout const & bstyle = par->layout();
depth_type const origdepth = pbegin->params().depth();
// Open tag for this environment
- openTag(os, bstyle);
+ bool const main_tag_opened = openTag(os, bstyle);
os << '\n';
// we will on occasion need to remember a layout from before.
while (par != pend) {
Layout const & style = par->layout();
+ if (!style.counter.empty())
+ buf.params().documentClass().counters().step(style.counter);
ParagraphList::const_iterator send;
// this will be positive, if we want to skip the initial word
// (if it's been taken for the label).
switch (style.latextype) {
case LATEX_ENVIRONMENT:
- // case LATEX_LIST_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
// started---which we will be if the depth is the same.
if (par->params().depth() == origdepth) {
+ Layout const & cstyle = par->layout();
if (lastlay != 0) {
closeItemTag(os, *lastlay);
lastlay = 0;
}
- Layout const & cstyle = par->layout();
+ bool const labelfirst = cstyle.htmllabelfirst();
+ bool item_tag_opened = false;
+ if (!labelfirst)
+ item_tag_opened = openItemTag(os, cstyle);
if (cstyle.labeltype == LABEL_MANUAL) {
- openLabelTag(os, cstyle);
+ bool const label_tag_opened = openLabelTag(os, cstyle);
sep = par->firstWordLyXHTML(os, runparams);
- closeLabelTag(os, cstyle);
+ if (label_tag_opened)
+ closeLabelTag(os, cstyle);
os << '\n';
- } else if (style.latextype == LATEX_ENVIRONMENT
+ }
+ // FIXME Why did I put that first condition??
+ else if (style.latextype == LATEX_ENVIRONMENT
&& style.labeltype != LABEL_NO_LABEL) {
- openLabelTag(os, cstyle);
- if (!style.counter.empty())
- buf.params().documentClass().counters().step(cstyle.counter);
+ bool const label_tag_opened = openLabelTag(os, cstyle);
os << pbegin->expandLabel(style, buf.params(), false);
- closeLabelTag(os, cstyle);
+ if (label_tag_opened)
+ closeLabelTag(os, cstyle);
os << '\n';
}
-
- openItemTag(os, cstyle);
+ if (labelfirst)
+ item_tag_opened = openItemTag(os, cstyle);
+ else
+ os << "<span class='item'>";
par->simpleLyXHTMLOnePar(buf, os, runparams,
outerFont(distance(paragraphs.begin(), par), paragraphs), sep);
+ if (!labelfirst)
+ os << "</span>";
++par;
- // We may not want to close the tag yet, in particular,
- // if we're not at the end and are doing items...
- if (par != pend && style.latextype == LATEX_ITEM_ENVIRONMENT
- // 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.
+ if (item_tag_opened) {
+ // We may not want to close the tag yet, in particular,
+ // if we're not at the end...
+ if (par != pend
+ // and are doing items...
+ && style.latextype == LATEX_ITEM_ENVIRONMENT
+ // 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 = &cstyle;
- } else {
- closeItemTag(os, cstyle); // FIXME
+ } else {
+ closeItemTag(os, cstyle);
+ }
os << '\n';
}
- }
+ }
// The other possibility is that the depth has increased, in which
// case we need to recurse.
else {
}
case LATEX_PARAGRAPH:
send = searchParagraph(par, pend);
- par = makeParagraph(buf, os, runparams, paragraphs, par, send);
+ par = makeParagraphs(buf, os, runparams, paragraphs, par, send);
break;
- // FIXME
+ // Shouldn't happen
case LATEX_BIB_ENVIRONMENT:
+ send = par;
+ ++send;
+ par = makeParagraphs(buf, os, runparams, paragraphs, par, send);
+ break;
+ // Shouldn't happen
case LATEX_COMMAND:
+ ++par;
break;
}
}
if (lastlay != 0)
closeItemTag(os, *lastlay);
- closeTag(os, bstyle);
+ if (main_tag_opened)
+ closeTag(os, bstyle);
os << '\n';
return pend;
}
ParagraphList::const_iterator const & pbegin)
{
Layout const & style = pbegin->layout();
+ if (!style.counter.empty())
+ buf.params().documentClass().counters().step(style.counter);
- openTag(os, style);
+ bool const main_tag_opened = openTag(os, style);
// Label around sectioning number:
+ // FIXME Probably need to account for LABEL_MANUAL
if (style.labeltype != LABEL_NO_LABEL) {
- openLabelTag(os, style);
- if (!style.counter.empty())
- buf.params().documentClass().counters().step(style.counter);
+ bool const label_tag_opened = openLabelTag(os, style);
os << pbegin->expandLabel(style, buf.params(), false);
- closeLabelTag(os, style);
+ if (label_tag_opened)
+ closeLabelTag(os, style);
// Otherwise the label might run together with the text
os << ' ';
}
pbegin->simpleLyXHTMLOnePar(buf, os, runparams,
outerFont(distance(paragraphs.begin(), pbegin), paragraphs));
- closeTag(os, style);
+ if (main_tag_opened)
+ closeTag(os, style);
+ os << '\n';
}
} // end anonymous namespace
break;
}
case LATEX_ENVIRONMENT:
+ case LATEX_LIST_ENVIRONMENT:
case LATEX_ITEM_ENVIRONMENT: {
send = searchEnvironment(par, pend);
- par = makeEnvironment(buf, os, runparams, paragraphs, par,send);
+ par = makeEnvironment(buf, os, runparams, paragraphs, par, send);
+ break;
+ }
+ case LATEX_BIB_ENVIRONMENT: {
+ send = searchEnvironment(par, pend);
+ par = makeBibliography(buf, os, runparams, paragraphs, par, send);
break;
}
case LATEX_PARAGRAPH:
send = searchParagraph(par, pend);
- par = makeParagraph(buf, os, runparams, paragraphs, par,send);
- break;
- default:
+ par = makeParagraphs(buf, os, runparams, paragraphs, par, send);
break;
}
- os << '\n';
+ // FIXME??
// makeEnvironment may process more than one paragraphs and bypass pend
if (distance(lastpar, par) >= distance(lastpar, pend))
break;
projects / lyx.git / blobdiff