X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_xhtml.h;h=a2eac95ab437881bf06926839fe04e786aae94ac;hb=0f5c34b8abcaf5bf4ae2df665b2f5aed40229502;hp=ceabc42dcf38150e23353f4a66c24cbeacfe47a6;hpb=ad56bb7286cabddefb4d2e470b833ac1874623a3;p=lyx.git diff --git a/src/output_xhtml.h b/src/output_xhtml.h index ceabc42dcf..a2eac95ab4 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,85 @@ 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 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{}; @@ -123,10 +211,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 &); @@ -147,6 +235,8 @@ public: /// XHTMLStream & operator<<(html::ParTag const &); /// + XHTMLStream & operator<<(html::FontTag const &); + /// XHTMLStream & operator<<(html::CR const &); /// enum EscapeSettings { @@ -167,29 +257,30 @@ private: /// void clearTagDeque(); /// - bool isTagOpen(std::string const &) const; + bool isTagOpen(html::StartTag const &) const; + /// + bool isTagOpen(html::EndTag const &) const; /// - bool isTagPending(std::string 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 +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