Reorganize the TagStack objects.

[features.git] / src / output_xhtml.h

diff --git a/src/output_xhtml.h b/src/output_xhtml.h
index b2abc89d5bd83f5a5edc216e7258f84d9356271e..99d07be9d755df9418d352602006ec976aacdda7 100644 (file)
--- a/src/output_xhtml.h
+++ b/src/output_xhtml.h
@@ -13,11 +13,12 @@
 #define OUTPUT_XHTML_H
 
 #include "LayoutEnums.h"
+
 #include "support/docstream.h"
+#include "support/shared_ptr.h"
 #include "support/strfwd.h"
 
 #include <deque>
-#include <vector>
 
 namespace lyx {
 
@@ -84,6 +85,10 @@ struct CompTag {
        std::string attr_;
 };
 
+
+// trivial struct for output of newlines
+struct CR{};
+
 } // namespace html
 
 class XHTMLStream {
@@ -91,8 +96,6 @@ public:
        ///
        explicit XHTMLStream(odocstream & os);
        ///
-       void cr();
-       ///
        odocstream & os() { return os_; }
        ///
        // int & tab() { return tab_; }
@@ -101,6 +104,12 @@ 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();
        ///
        XHTMLStream & operator<<(docstring const &);
        ///
@@ -118,6 +127,8 @@ public:
        ///
        XHTMLStream & operator<<(html::CompTag const &);
        ///
+       XHTMLStream & operator<<(html::CR const &);
+       ///
        enum EscapeSettings {
                ESCAPE_NONE,
                ESCAPE_AND, // meaning &
@@ -126,27 +137,43 @@ 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
 private:
        ///
        void clearTagDeque();
        ///
-       bool isTagOpen(std::string const &);
+       bool isTagOpen(std::string const &) const;
        ///
-       void writeError(std::string const &);
+       bool isTagPending(std::string const &) const;
+       ///
+       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 
+       // 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.
        ///
-       // int tab_;
+       typedef shared_ptr<html::StartTag> TagPtr;
+       typedef std::deque<TagPtr> TagDeque;
        ///
-       typedef std::deque<html::StartTag> TagDeque;
+       template <typename T> 
+       shared_ptr<T> makeTagPtr(T const & tag) 
+               { return shared_ptr<T>(new T(tag)); }
        ///
-       typedef std::vector<html::StartTag> TagStack;
-       /// holds start tags until we know there is content in them.
        TagDeque pending_tags_;
-       /// remembers the history, so we can make sure we nest properly.
-       TagStack tag_stack_;
-       /// 
-       EscapeSettings escape_;
+       ///
+       TagDeque tag_stack_;
 };
 
 ///