Update status

[lyx.git] / src / output_xhtml.h

diff --git a/src/output_xhtml.h b/src/output_xhtml.h
index d5fabf97a00a203db2cc561ff1cd057ca97841a1..3c4ad2ae0dd69dc66d23e12f31ae3a2955f21b9d 100644 (file)
--- a/src/output_xhtml.h
+++ b/src/output_xhtml.h
@@ -15,10 +15,11 @@
 #include "LayoutEnums.h"
 
 #include "support/docstream.h"
-#include "support/shared_ptr.h"
 #include "support/strfwd.h"
 
 #include <deque>
+#include <memory>
+
 
 namespace lyx {
 
@@ -31,8 +32,8 @@ class Text;
 
 namespace html {
 
-class FontTag;
-class EndFontTag;
+struct FontTag;
+struct EndFontTag;
 
 /// Attributes will be escaped automatically and so should NOT
 /// be escaped before being passed to the constructor.
@@ -41,11 +42,11 @@ struct StartTag
        ///
        explicit StartTag(std::string const & tag) : tag_(tag), keepempty_(false) {}
        ///
-       explicit StartTag(std::string const & tag, std::string const & attr, 
-               bool keepempty = false) 
+       explicit StartTag(std::string const & tag, std::string const & attr,
+               bool keepempty = false)
                : tag_(tag), attr_(attr), keepempty_(keepempty) {}
        ///
-       ~StartTag() {}
+       virtual ~StartTag() {}
        /// <tag_ attr_>
        virtual docstring writeTag() const;
        /// </tag_>
@@ -75,6 +76,8 @@ struct EndTag
 {
        ///
        explicit EndTag(std::string tag) : tag_(tag) {}
+       ///
+       virtual ~EndTag() {}
        /// </tag_>
        virtual docstring writeEndTag() const;
        ///
@@ -114,16 +117,10 @@ struct CompTag
 struct ParTag : public StartTag
 {
        ///
-       explicit ParTag(std::string const & tag, std::string const & attr,
-              std::string const & parid)
-         : StartTag(tag, attr), parid_(parid)
-       {}
+       explicit ParTag(std::string const & tag, std::string attr,
+              std::string const & parid);
        ///
        ~ParTag() {}
-       ///
-       docstring writeTag() const;
-       /// the "magic par label" for this paragraph
-       std::string parid_;
 };
 
 
@@ -136,6 +133,7 @@ enum FontTypes {
        FT_DBAR,
        FT_WAVE,
        FT_SOUT,
+       FT_XOUT,
        // bold
        FT_BOLD,
        // shapes
@@ -146,8 +144,20 @@ enum FontTypes {
        // families
        FT_ROMAN,
        FT_SANS,
-       FT_TYPE
-       // SIZES?
+       FT_TYPE,
+       // sizes
+       FT_SIZE_TINY,
+       FT_SIZE_SCRIPT,
+       FT_SIZE_FOOTNOTE,
+       FT_SIZE_SMALL,
+       FT_SIZE_NORMAL,
+       FT_SIZE_LARGE,
+       FT_SIZE_LARGER,
+       FT_SIZE_LARGEST,
+       FT_SIZE_HUGE,
+       FT_SIZE_HUGER,
+       FT_SIZE_INCREASE,
+       FT_SIZE_DECREASE
 };
 
 
@@ -195,12 +205,13 @@ public:
        /// \return false if there are open font tags we could not close.
        /// because they are "blocked" by open non-font tags on the stack.
        bool closeFontTags();
-       /// call at start of paragraph. sets a mark so we know what tags
-       /// to close at the end. 
-       void startParagraph(bool keep_empty);
-       /// call at end of paragraph to clear that mark. note that this
-       /// will also close any tags still open. 
-       void endParagraph();
+       /// sets a mark so we know what tags to close at the end.
+       /// normally called at the start of a paragraph.
+       void startDivision(bool keep_empty);
+       /// clears the mark set by previous method.
+       /// there should not be any other tags open before it on the stack,
+       /// but if there are, we will close them.
+       void endDivision();
        ///
        XHTMLStream & operator<<(docstring const &);
        ///
@@ -232,12 +243,10 @@ public:
        /// Sets what we are going to escape on the NEXT write.
        /// Everything is reset for the next time.
        XHTMLStream & operator<<(EscapeSettings);
-#if 0
        /// This routine is for debugging the tag stack, etc. Code
        /// for it is disabled by default, however, so you will need
        /// to enable it if you want to use it.
-       void dumpTagStack(std::string const & msg) const;
-#endif
+       void dumpTagStack(std::string const & msg);
 private:
        ///
        void clearTagDeque();
@@ -251,22 +260,21 @@ private:
        void writeError(std::string const &) const;
        ///
        odocstream & os_;
-       /// 
+       ///
        EscapeSettings escape_;
        // What we would really like to do here is simply use a
        // deque<StartTag>. But we want to store both StartTags and
-       // sub-classes thereof on this stack, which means we run into the 
+       // sub-classes thereof on this stack, which means we run into the
        // so-called polymorphic class problem with the STL. We therefore have
        // to use a deque<StartTag *>, which leads to the question who will
        // own these pointers and how they will be deleted, so we use shared
        // pointers.
        ///
-       typedef shared_ptr<html::StartTag> TagPtr;
+       typedef std::shared_ptr<html::StartTag> TagPtr;
        typedef std::deque<TagPtr> TagDeque;
        ///
-       template <typename T> 
-       shared_ptr<T> makeTagPtr(T const & tag) 
-               { return shared_ptr<T>(new T(tag)); }
+       template <typename T>
+       TagPtr makeTagPtr(T const & tag) { return std::make_shared<T>(tag); }
        ///
        TagDeque pending_tags_;
        ///
@@ -291,12 +299,8 @@ docstring htmlize(docstring const & str, XHTMLStream::EscapeSettings e);
 /// cleans \param str for use as an atttribute by replacing
 /// all non-alnum by "_"
 docstring cleanAttr(docstring const & str);
-///
-std::string escapeChar(char c, XHTMLStream::EscapeSettings e);
-/// 
-std::string htmlize(std::string const & str, XHTMLStream::EscapeSettings e);
-/// 
-std::string cleanAttr(std::string const & str);
+/// \p c must be ASCII
+docstring escapeChar(char c, XHTMLStream::EscapeSettings e);
 
 } // namespace html
 } // namespace lyx