X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_xhtml.h;h=3c4ad2ae0dd69dc66d23e12f31ae3a2955f21b9d;hb=28be7d552f62cc02fa86d7f79201d089bfb2d7b5;hp=94bdf0bd2b7f643fbf18802175444dfa6550323b;hpb=ec1a541a6c30a3fe3bbe59e97516e4db5d4b43e9;p=lyx.git diff --git a/src/output_xhtml.h b/src/output_xhtml.h index 94bdf0bd2b..3c4ad2ae0d 100644 --- a/src/output_xhtml.h +++ b/src/output_xhtml.h @@ -13,10 +13,13 @@ #define OUTPUT_XHTML_H #include "LayoutEnums.h" + #include "support/docstream.h" #include "support/strfwd.h" #include +#include + namespace lyx { @@ -28,19 +31,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 +71,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 +105,91 @@ 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 attr, + std::string const & parid); + /// + ~ParTag() {} +}; + + +/// +enum FontTypes { + // ranges + FT_EMPH, + FT_NOUN, + FT_UBAR, + FT_DBAR, + FT_WAVE, + FT_SOUT, + FT_XOUT, + // 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{}; + } // namespace html class XHTMLStream { @@ -90,8 +197,6 @@ public: /// explicit XHTMLStream(odocstream & os); /// - void cr(); - /// odocstream & os() { return os_; } /// // int & tab() { return tab_; } @@ -100,6 +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(); + /// 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 &); /// @@ -117,6 +229,12 @@ public: /// XHTMLStream & operator<<(html::CompTag const &); /// + XHTMLStream & operator<<(html::ParTag const &); + /// + XHTMLStream & operator<<(html::FontTag const &); + /// + XHTMLStream & operator<<(html::CR const &); + /// enum EscapeSettings { ESCAPE_NONE, ESCAPE_AND, // meaning & @@ -125,23 +243,42 @@ public: /// Sets what we are going to escape on the NEXT write. /// Everything is reset for the next time. XHTMLStream & operator<<(EscapeSettings); + /// 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); 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 std::shared_ptr TagPtr; + typedef std::deque TagDeque; + /// + template + TagPtr makeTagPtr(T const & tag) { return std::make_shared(tag); } + /// + TagDeque pending_tags_; + /// + TagDeque tag_stack_; }; /// @@ -162,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