Update Win installer for new dictionary links. Untested.

[lyx.git] / src / output_xhtml.cpp

diff --git a/src/output_xhtml.cpp b/src/output_xhtml.cpp
index d428761b10a1f1fe84267e0b0338361631117290..f01b0b8e62d04692277661fbba77f8df7b958767 100644 (file)
--- a/src/output_xhtml.cpp
+++ b/src/output_xhtml.cpp
@@ -3,7 +3,7 @@
  * 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
  *
@@ -15,12 +15,11 @@
 #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"
@@ -28,11 +27,7 @@
 #include "Text.h"
 #include "TextClass.h"
 
-#include "support/convert.h"
-#include "support/debug.h"
 #include "support/lassert.h"
-#include "support/lstrings.h"
-#include "support/textutils.h"
 
 #include <stack>
 #include <iostream>
@@ -162,18 +157,27 @@ namespace {
 // convenience functions
 
 inline void openParTag(XMLStream & xs, Layout const & lay,
-                       const std::string & parlabel)
+                       std::string const & parlabel)
 {
-       string attrs = lay.htmlattr();
+       string attrs = lay.htmlGetAttrString();
        if (!parlabel.empty())
                attrs += " id='" + parlabel + "'";
        xs << xml::ParTag(lay.htmltag(), attrs);
 }
 
 
+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 openParTag(XMLStream & xs, Layout const & lay,
                 ParagraphParameters const & params,
-                const std::string & parlabel)
+                std::string const & parlabel)
 {
        // FIXME Are there other things we should handle here?
        string const align = alignmentToCSS(params.align());
@@ -181,7 +185,7 @@ void openParTag(XMLStream & xs, Layout const & lay,
                openParTag(xs, lay, parlabel);
                return;
        }
-       string attrs = lay.htmlattr() + " style='text-align: " + align + ";'";
+       string attrs = lay.htmlGetAttrString() + " style='text-align: " + align + ";'";
        if (!parlabel.empty())
                attrs += " id='" + parlabel + "'";
        xs << xml::ParTag(lay.htmltag(), attrs);
@@ -208,27 +212,33 @@ inline void closeLabelTag(XMLStream & xs, Layout const & lay)
 
 inline void openItemTag(XMLStream & xs, Layout const & lay)
 {
-       xs << xml::StartTag(lay.htmlitemtag(), lay.htmlitemattr(), true);
+       if (lay.htmlitemtag() != "NONE") {
+               xs << xml::StartTag(lay.htmlitemtag(), lay.htmlitemattr(), true);
+       }
 }
 
 
 void openItemTag(XMLStream & xs, Layout const & lay,
              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;
+       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;
+               }
+               string attrs = lay.htmlGetAttrString() + " style='text-align: " + align + ";'";
+               xs << xml::StartTag(lay.htmlitemtag(), attrs);
        }
-       string attrs = lay.htmlattr() + " style='text-align: " + align + ";'";
-       xs << xml::StartTag(lay.htmlitemtag(), attrs);
 }
 
 
 inline void closeItemTag(XMLStream & xs, Layout const & lay)
 {
-       xs << xml::EndTag(lay.htmlitemtag());
+       if (lay.htmlitemtag() != "NONE") {
+               xs << xml::EndTag(lay.htmlitemtag());
+       }
 }
 
 // end of convenience functions
@@ -404,7 +414,42 @@ ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
        depth_type const origdepth = pbegin->params().depth();
 
        // open tag for this environment
-       openParTag(xs, bstyle, pbegin->magicLabel());
+       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.
@@ -423,7 +468,7 @@ ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
                if (!style.counter.empty()
                    && (par == pbegin || !isNormalEnv(style))
                                && cnts.hasCounter(cntr)
-               )
+                       )
                        cnts.step(cntr, OutputUpdate);
                ParagraphList::const_iterator send;
 
@@ -472,10 +517,13 @@ ParagraphList::const_iterator makeEnvironment(Buffer const & buf,
                                                        xs << xml::CR();
                                                }
                                                else {
-                                                       openLabelTag(xs, style);
-                                                       xs << par->params().labelString();
-                                                       closeLabelTag(xs, style);
-                                                       xs << xml::CR();
+                                                       docstring const & ls = par->params().labelString();
+                                                       if (!ls.empty()) {
+                                                               openLabelTag(xs, style);
+                                                               xs << ls;
+                                                               closeLabelTag(xs, style);
+                                                               xs << xml::CR();
+                                                       }
                                                }
                                        }
                                } // end label output