* InsetTabular.cpp:

[lyx.git] / src / output_xhtml.cpp

diff --git a/src/output_xhtml.cpp b/src/output_xhtml.cpp
index 6ee977d6fc3949fe9d420b157f2482c9648648e8..e8f77e3f99ca0fe5673808b9317143ec55c97292 100644 (file)
--- a/src/output_xhtml.cpp
+++ b/src/output_xhtml.cpp
@@ -32,6 +32,7 @@
 #include "support/debug.h"
 #include "support/lassert.h"
 #include "support/lstrings.h"
+#include "support/textutils.h"
 
 #include <vector>
 
@@ -42,72 +43,78 @@ namespace lyx {
 
 namespace html {
 
-docstring escapeChar(char_type c)
+docstring escapeChar(char_type c, XHTMLStream::EscapeSettings e)
 {
        docstring str;
-       switch (c) {
-       case ' ':
-               str += " ";
-               break;
-       case '&':
-               str += "&amp;";
-               break;
-       case '<':
-               str += "&lt;";
-               break;
-       case '>':
-               str += "&gt;";
-               break;
-       default:
+       switch (e) {
+       case XHTMLStream::ESCAPE_NONE:
                str += c;
                break;
+       case XHTMLStream::ESCAPE_ALL:
+               if (c == '<') {
+                       str += "&lt;";
+                       break;
+               } else if (c == '>') {
+                       str += "&gt;";
+                       break;
+               }
+       // fall through
+       case XHTMLStream::ESCAPE_AND:
+               if (c == '&')
+                       str += "&amp;";
+               else
+                       str     +=c ;
+               break;
        }
        return str;
 }
 
 
 // escape what needs escaping
-docstring htmlize(docstring const & str) {
+docstring htmlize(docstring const & str, XHTMLStream::EscapeSettings e) {
        odocstringstream d;
        docstring::const_iterator it = str.begin();
        docstring::const_iterator en = str.end();
        for (; it != en; ++it)
-               d << escapeChar(*it);
+               d << escapeChar(*it, e);
        return d.str();
 }
 
 
-string escapeChar(char c)
+string escapeChar(char c, XHTMLStream::EscapeSettings e)
 {
        string str;
-       switch (c) {
-       case ' ':
-               str += " ";
-               break;
-       case '&':
-               str += "&amp;";
-               break;
-       case '<':
-               str += "&lt;";
-               break;
-       case '>':
-               str += "&gt;";
-               break;
-       default:
+       switch (e) {
+       case XHTMLStream::ESCAPE_NONE:
                str += c;
                break;
+       case XHTMLStream::ESCAPE_ALL:
+               if (c == '<') {
+                       str += "&lt;";
+                       break;
+               } else if (c == '>') {
+                       str += "&gt;";
+                       break;
+               }
+       // fall through
+       case XHTMLStream::ESCAPE_AND:
+               if (c == '&')
+                       str += "&amp;";
+               else
+                       str     +=c ;
+               break;
        }
        return str;
 }
 
 
 // escape what needs escaping
-string htmlize(string const & str) {
+string htmlize(string const & str, XHTMLStream::EscapeSettings e) {
        ostringstream d;
        string::const_iterator it = str.begin();
        string::const_iterator en = str.end();
        for (; it != en; ++it)
-               d << escapeChar(*it);
+               d << escapeChar(*it, e);
        return d.str();
 }
 
@@ -128,11 +135,10 @@ 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 += '_';
+       for (; it != en; ++it) {
+               char_type const c = *it;
+               newname += isAlnumASCII(c) ? c : char_type('_');
+       }
        return newname; 
 }
 
@@ -147,7 +153,7 @@ docstring StartTag::asTag() const
 {
        string output = "<" + tag_;
        if (!attr_.empty())
-               output += " " + html::htmlize(attr_);
+               output += " " + html::htmlize(attr_, XHTMLStream::ESCAPE_NONE);
        output += ">";
        return from_utf8(output);
 }
@@ -171,7 +177,7 @@ docstring CompTag::asTag() const
 {
        string output = "<" + tag_;
        if (!attr_.empty())
-               output += " " + html::htmlize(attr_);
+               output += " " + html::htmlize(attr_, XHTMLStream::ESCAPE_NONE);
        output += " />";
        return from_utf8(output);
 }
@@ -187,7 +193,7 @@ docstring CompTag::asTag() const
 ////////////////////////////////////////////////////////////////
 
 XHTMLStream::XHTMLStream(odocstream & os) 
-               : os_(os), nextraw_(false)
+               : os_(os), escape_(ESCAPE_ALL)
 {}
 
 
@@ -252,11 +258,8 @@ void XHTMLStream::clearTagDeque()
 XHTMLStream & XHTMLStream::operator<<(docstring const & d)
 {
        clearTagDeque();
-       if (nextraw_) {
-               os_ << d;
-               nextraw_ = false;
-       } else
-               os_ << html::htmlize(d);
+       os_ << html::htmlize(d, escape_);
+       escape_ = ESCAPE_ALL;
        return *this;
 }
 
@@ -265,11 +268,8 @@ XHTMLStream & XHTMLStream::operator<<(const char * s)
 {
        clearTagDeque();
        docstring const d = from_ascii(s);
-       if (nextraw_) {
-               os_ << d;
-               nextraw_ = false;
-       } else
-               os_ << html::htmlize(d);
+       os_ << html::htmlize(d, escape_);
+       escape_ = ESCAPE_ALL;
        return *this;
 }
 
@@ -277,11 +277,17 @@ XHTMLStream & XHTMLStream::operator<<(const char * s)
 XHTMLStream & XHTMLStream::operator<<(char_type c)
 {
        clearTagDeque();
-       if (nextraw_) {
-               os_ << c;
-               nextraw_ = false;
-       } else
-               os_ << html::escapeChar(c);
+       os_ << html::escapeChar(c, escape_);
+       escape_ = ESCAPE_ALL;
+       return *this;
+}
+
+
+XHTMLStream & XHTMLStream::operator<<(char c)
+{
+       clearTagDeque();
+       string const d = html::escapeChar(c, escape_);
+       escape_ = ESCAPE_ALL;
        return *this;
 }
 
@@ -290,14 +296,14 @@ XHTMLStream & XHTMLStream::operator<<(int i)
 {
        clearTagDeque();
        os_ << i;
-       nextraw_ = false;
+       escape_ = ESCAPE_ALL;
        return *this;
 }
 
 
-XHTMLStream & XHTMLStream::operator<<(NextRaw const &) 
+XHTMLStream & XHTMLStream::operator<<(EscapeSettings e)
 { 
-       nextraw_ = true; 
+       escape_ = e;
        return *this;
 }
 
@@ -366,8 +372,8 @@ XHTMLStream & XHTMLStream::operator<<(html::EndTag const & etag)
                // 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();
+               TagStack::iterator dit = pending_tags_.begin();
+               TagStack::iterator const den = pending_tags_.end();
                for (; dit != den; ++dit) {
                        if (dit->tag_ == etag.tag_) {
                                // it was pending, so we just erase it
@@ -491,6 +497,20 @@ inline void openTag(XHTMLStream & xs, Layout const & lay)
 }
 
 
+void openTag(XHTMLStream & 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()) {
+               openTag(xs, lay);
+               return;
+       }
+       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());
@@ -515,6 +535,20 @@ inline void openItemTag(XHTMLStream & xs, Layout const & lay)
 }
 
 
+void openItemTag(XHTMLStream & 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;
+       }
+       string attrs = lay.htmlattr() + " style='text-align: " + align + ";'";
+       xs << html::StartTag(lay.htmlitemtag(), attrs);
+}
+
+
 inline void closeItemTag(XHTMLStream & xs, Layout const & lay)
 {
        xs << html::EndTag(lay.htmlitemtag());
@@ -587,7 +621,7 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
                bool const opened = runparams.html_make_pars &&
                        (par != pbegin || !runparams.html_in_par);
                if (opened)
-                       openTag(xs, lay);
+                       openTag(xs, lay, par->params());
                docstring const deferred = 
                        par->simpleLyXHTMLOnePar(buf, xs, runparams, text.outerFont(distance(begin, par)));
 
@@ -606,7 +640,7 @@ ParagraphList::const_iterator makeParagraphs(Buffer const & buf,
                        xs.cr();
                }
                if (!deferred.empty()) {
-                       xs << XHTMLStream::NextRaw() << deferred;
+                       xs << XHTMLStream::ESCAPE_NONE << deferred;
                        xs.cr();
                }
        }
@@ -697,7 +731,7 @@ ParagraphList::const_iterator makeEnvironmentHtml(Buffer const & buf,
                                
                                bool const labelfirst = style.htmllabelfirst();
                                if (!labelfirst)
-                                       openItemTag(xs, style);
+                                       openItemTag(xs, style, par->params());
                                
                                // label output
                                if (style.labeltype != LABEL_NO_LABEL && 
@@ -732,7 +766,7 @@ ParagraphList::const_iterator makeEnvironmentHtml(Buffer const & buf,
                                } // end label output
 
                                if (labelfirst)
-                                       openItemTag(xs, style);
+                                       openItemTag(xs, style, par->params());
 
                                par->simpleLyXHTMLOnePar(buf, xs, runparams, 
                                        text.outerFont(distance(begin, par)), sep);
@@ -795,7 +829,7 @@ void makeCommand(Buffer const & buf,
        if (!style.counter.empty())
                buf.params().documentClass().counters().step(style.counter, OutputUpdate);
 
-       openTag(xs, style);
+       openTag(xs, style, pbegin->params());
 
        // Label around sectioning number:
        // FIXME Probably need to account for LABEL_MANUAL
@@ -881,4 +915,20 @@ void xhtmlParagraphs(Text const & text,
 }
 
 
+string alignmentToCSS(LyXAlignment align) {
+       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 "";
+}
+
 } // namespace lyx