X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_xhtml.h;h=a9ee0ea090baa8230509aa9cd811a09da9709084;hb=037b1e14789223c89e88e8bd74baffa4d0956571;hp=0bcc9849c0e354c9781cfcccdbe4bc7e06000589;hpb=64f0cffbba33c9a02e8f1f5d3b825d8e79257012;p=lyx.git diff --git a/src/output_xhtml.h b/src/output_xhtml.h index 0bcc9849c0..a9ee0ea090 100644 --- 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 +#include + namespace lyx { @@ -31,6 +32,9 @@ class Text; 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 @@ -38,22 +42,26 @@ 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() {} /// - virtual docstring asTag() const; + virtual docstring writeTag() const; /// - virtual docstring asEndTag() const; + virtual docstring writeEndTag() const; /// - bool operator==(StartTag const & rhs) const + virtual FontTag const * asFontTag() const { return 0; } + /// + virtual bool operator==(StartTag const & rhs) const { return tag_ == rhs.tag_; } /// - bool operator!=(StartTag const & rhs) const + virtual bool operator!=(StartTag const & rhs) const { return !(*this == rhs); } /// + virtual bool operator==(FontTag const & rhs) const; + /// std::string tag_; /// std::string attr_; @@ -63,39 +71,93 @@ struct StartTag }; +/// +struct EndTag +{ + /// + explicit EndTag(std::string const & tag) : tag_(tag) {} + /// + virtual ~EndTag() {} + /// + 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_; +}; + + +/// Tags like +/// Attributes will be escaped automatically and so should NOT +/// be escaped before being passed to the constructor. +struct CompTag +{ + /// + explicit CompTag(std::string const & tag) + : tag_(tag) {} + /// + explicit CompTag(std::string const & tag, std::string const & attr) + : tag_(tag), attr_(attr) {} + /// + 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) - {} + explicit ParTag(std::string const & tag, std::string attr, + std::string const & parid); /// ~ParTag() {} - /// - docstring asTag() const; - /// the "magic par label" for this paragraph - std::string parid_; }; /// enum FontTypes { + // ranges FT_EMPH, - FT_BOLD, FT_NOUN, FT_UBAR, FT_DBAR, - FT_SOUT, FT_WAVE, + FT_SOUT, + FT_XOUT, + // bold + FT_BOLD, + // shapes + FT_UPRIGHT, FT_ITALIC, FT_SLANTED, FT_SMALLCAPS, + // families FT_ROMAN, FT_SANS, - FT_TYPER - // 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 }; @@ -105,56 +167,23 @@ struct FontTag : public StartTag /// explicit FontTag(FontTypes type); /// - docstring asTag() const; - /// - docstring asEndTag() const; - /// - bool isFontTag() { return true; } + FontTag const * asFontTag() const { return this; } /// - bool operator==(FontTag const & rhs) - { return font_type_ == rhs.font_type_; } - /// Asserts. - bool operator==(StartTag const &); + bool operator==(StartTag const &) const; /// FontTypes font_type_; }; /// -struct EndTag +struct EndFontTag : public EndTag { /// - explicit EndTag(std::string tag) : tag_(tag) {} - /// - docstring asEndTag() const; + explicit EndFontTag(FontTypes type); /// - bool operator==(StartTag const & rhs) const - { return tag_ == rhs.tag_; } - /// - bool operator!=(StartTag const & rhs) const - { return !(*this == rhs); } + EndFontTag const * asFontTag() const { return this; } /// - std::string tag_; -}; - - -/// Tags like -/// Attributes will be escaped automatically and so should NOT -/// be escaped before being passed to the constructor. -struct CompTag -{ - /// - explicit CompTag(std::string const & tag) - : tag_(tag) {} - /// - explicit CompTag(std::string const & tag, std::string const & attr) - : tag_(tag), attr_(attr) {} - /// - docstring asTag() const; - /// - std::string tag_; - /// - std::string attr_; + FontTypes font_type_; }; @@ -176,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 &); /// @@ -201,6 +231,8 @@ public: /// XHTMLStream & operator<<(html::ParTag const &); /// + XHTMLStream & operator<<(html::FontTag const &); + /// XHTMLStream & operator<<(html::CR const &); /// enum EscapeSettings { @@ -211,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(); @@ -230,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. 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, 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::shared_ptr TagPtr; typedef std::deque TagDeque; /// - template - shared_ptr makeTagPtr(T const & tag) - { return shared_ptr(new T(tag)); } + template + TagPtr makeTagPtr(T const & tag) { return std::make_shared(tag); } /// TagDeque pending_tags_; /// @@ -270,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