X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_xhtml.h;h=981038ba8ef97b7a6f221a4a3bd6e454c0d6c4a5;hb=2ebd535e99ebd1578209bf3e5890b06871e1dfeb;hp=ceabc42dcf38150e23353f4a66c24cbeacfe47a6;hpb=ad56bb7286cabddefb4d2e470b833ac1874623a3;p=lyx.git diff --git a/src/output_xhtml.h b/src/output_xhtml.h index ceabc42dcf..981038ba8e 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 { @@ -30,6 +31,10 @@ 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 @@ -37,15 +42,25 @@ 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; + /// + 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_; /// @@ -56,29 +71,23 @@ struct StartTag }; -/// A special case of StartTag, used exclusively for tags that wrap paragraphs. -struct ParTag : public StartTag -{ - /// - ParTag(std::string const & tag, std::string const & attr, - std::string const & parid) - : StartTag(tag, attr), parid_(parid) - {} - /// - ~ParTag() {} - /// - docstring asTag() const; - /// the "magic par label" for this paragraph - std::string parid_; -}; - - +/// 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_; }; @@ -96,7 +105,7 @@ 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_; /// @@ -104,6 +113,79 @@ struct CompTag }; +/// A special case of StartTag, used exclusively for tags that wrap paragraphs. +struct ParTag : public StartTag +{ + /// + explicit ParTag(std::string const & tag, std::string attr, + std::string const & parid); + /// + ~ParTag() {} +}; + + +/// +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{}; @@ -122,12 +204,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 &); /// @@ -147,6 +230,8 @@ public: /// XHTMLStream & operator<<(html::ParTag const &); /// + XHTMLStream & operator<<(html::FontTag const &); + /// XHTMLStream & operator<<(html::CR const &); /// enum EscapeSettings { @@ -157,39 +242,38 @@ 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(); /// - bool isTagOpen(std::string const &) const; + bool isTagOpen(html::StartTag const &) const; /// - bool isTagPending(std::string const &) const; + bool isTagOpen(html::EndTag const &) const; + /// + bool isTagPending(html::StartTag 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. 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_; /// @@ -214,12 +298,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