X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_xhtml.h;h=473ebe335a41a744e83663c22aab32fefdf1de8e;hb=f5f8c6fd3828285b67e43a9c16d4ac2ff2140944;hp=416e0daf4909337cdcf091693dd92e880d0a4b67;hpb=b3475e9fac0322b1cf20a720bbc1f09b462a531c;p=lyx.git diff --git a/src/output_xhtml.h b/src/output_xhtml.h index 416e0daf49..473ebe335a 100644 --- a/src/output_xhtml.h +++ b/src/output_xhtml.h @@ -13,7 +13,9 @@ #define OUTPUT_XHTML_H #include "LayoutEnums.h" + #include "support/docstream.h" +#include "support/shared_ptr.h" #include "support/strfwd.h" #include @@ -28,19 +30,36 @@ class Text; // came from MathStream and its cousins. namespace html { + +struct FontTag; +struct EndFontTag; + /// Attributes will be escaped automatically and so should NOT /// be escaped before being passed to the constructor. -struct StartTag { +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) {} + /// + virtual ~StartTag() {} /// - docstring asTag() const; + virtual docstring writeTag() const; /// - docstring asEndTag() const; + virtual docstring writeEndTag() const; + /// + virtual FontTag const * asFontTag() const { return 0; } + /// + virtual bool operator==(StartTag const & rhs) const + { return tag_ == rhs.tag_; } + /// + virtual bool operator!=(StartTag const & rhs) const + { return !(*this == rhs); } + /// + virtual bool operator==(FontTag const & rhs) const; /// std::string tag_; /// @@ -51,24 +70,33 @@ struct StartTag { }; -struct EndTag { +/// +struct EndTag +{ /// explicit EndTag(std::string tag) : tag_(tag) {} + /// + virtual ~EndTag() {} /// - docstring asEndTag() const; + virtual docstring writeEndTag() const; + /// + bool operator==(StartTag const & rhs) const + { return tag_ == rhs.tag_; } + /// + bool operator!=(StartTag const & rhs) const + { return !(*this == rhs); } + /// + virtual EndFontTag const * asFontTag() const { return 0; } /// std::string tag_; }; -// FIXME XHTML -// We need to allow these to be deferrable, which means it should -// inherit from StartTag. This is probably better, anyway, but we'll -// need to re-work a bit of code.... /// Tags like /// Attributes will be escaped automatically and so should NOT /// be escaped before being passed to the constructor. -struct CompTag { +struct CompTag +{ /// explicit CompTag(std::string const & tag) : tag_(tag) {} @@ -76,13 +104,93 @@ struct CompTag { explicit CompTag(std::string const & tag, std::string const & attr) : tag_(tag), attr_(attr) {} /// - docstring asTag() const; + docstring writeTag() const; /// std::string tag_; /// std::string attr_; }; + +/// A special case of StartTag, used exclusively for tags that wrap paragraphs. +struct ParTag : public StartTag +{ + /// + explicit ParTag(std::string const & tag, std::string const & attr, + std::string const & parid) + : StartTag(tag, attr), parid_(parid) + {} + /// + ~ParTag() {} + /// + docstring writeTag() const; + /// the "magic par label" for this paragraph + std::string parid_; +}; + + +/// +enum FontTypes { + // ranges + FT_EMPH, + FT_NOUN, + FT_UBAR, + FT_DBAR, + FT_WAVE, + FT_SOUT, + // bold + FT_BOLD, + // shapes + FT_UPRIGHT, + FT_ITALIC, + FT_SLANTED, + FT_SMALLCAPS, + // families + FT_ROMAN, + FT_SANS, + 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 +}; + + +/// +struct FontTag : public StartTag +{ + /// + explicit FontTag(FontTypes type); + /// + FontTag const * asFontTag() const { return this; } + /// + bool operator==(StartTag const &) const; + /// + FontTypes font_type_; +}; + + +/// +struct EndFontTag : public EndTag +{ + /// + explicit EndFontTag(FontTypes type); + /// + EndFontTag const * asFontTag() const { return this; } + /// + FontTypes font_type_; +}; + + // trivial struct for output of newlines struct CR{}; @@ -102,10 +210,10 @@ public: /// 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. + /// 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. + /// will also close any tags still open. void endParagraph(); /// XHTMLStream & operator<<(docstring const &); @@ -124,6 +232,10 @@ public: /// XHTMLStream & operator<<(html::CompTag const &); /// + XHTMLStream & operator<<(html::ParTag const &); + /// + XHTMLStream & operator<<(html::FontTag const &); + /// XHTMLStream & operator<<(html::CR const &); /// enum EscapeSettings { @@ -134,23 +246,45 @@ 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(html::StartTag const &) const; + /// + bool isTagOpen(html::EndTag const &) const; /// - void writeError(std::string const &); + bool isTagPending(html::StartTag const &) const; + /// + void writeError(std::string const &) const; /// odocstream & os_; /// - typedef std::deque TagStack; - /// holds start tags until we know there is content in them. - TagStack pending_tags_; - /// remembers the history, so we can make sure we nest properly. - TagStack tag_stack_; - /// EscapeSettings escape_; + // What we would really like to do here is simply use a + // deque. 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, which leads to the question who will + // own these pointers and how they will be deleted, so we use shared + // pointers. + /// + typedef shared_ptr TagPtr; + typedef std::deque TagDeque; + /// + template + shared_ptr makeTagPtr(T const & tag) + { return shared_ptr(new T(tag)); } + /// + TagDeque pending_tags_; + /// + TagDeque tag_stack_; }; /// @@ -171,12 +305,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