X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_xhtml.h;h=3c4ad2ae0dd69dc66d23e12f31ae3a2955f21b9d;hb=a128c373f9e3563a52405a485d9a672e210208b0;hp=74e60e28158b104677949be6915d5e6e85c77f92;hpb=508ee6560c5c5a3bb8cb906fb45ba7722acedb77;p=lyx.git diff --git a/src/output_xhtml.h b/src/output_xhtml.h index 74e60e2815..3c4ad2ae0d 100644 --- a/src/output_xhtml.h +++ b/src/output_xhtml.h @@ -12,11 +12,14 @@ #ifndef OUTPUT_XHTML_H #define OUTPUT_XHTML_H +#include "LayoutEnums.h" + #include "support/docstream.h" #include "support/strfwd.h" #include -#include +#include + namespace lyx { @@ -27,19 +30,37 @@ class Text; // Inspiration for the *Tag structs and for XHTMLStream // came from MathStream and its cousins. +namespace html { + +struct FontTag; +struct EndFontTag; + /// Attributes will be escaped automatically and so should NOT -/// be escaped before passing to the constructor. -struct StartTag { +/// be escaped before being passed to the constructor. +struct StartTag +{ /// - StartTag(std::string const & tag) : tag_(tag) {} + explicit StartTag(std::string const & tag) : tag_(tag), keepempty_(false) {} /// - 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_; /// @@ -50,11 +71,23 @@ struct StartTag { }; -struct EndTag { +/// +struct EndTag +{ /// - EndTag(std::string tag) : tag_(tag) {} + 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_; }; @@ -62,16 +95,17 @@ struct EndTag { /// Tags like /// Attributes will be escaped automatically and so should NOT -/// be escaped before passing to the constructor. -struct CompTag { +/// be escaped before being passed to the constructor. +struct CompTag +{ /// - CompTag(std::string const & tag) + explicit CompTag(std::string const & tag) : tag_(tag) {} /// - CompTag(std::string const & tag, std::string const & attr) + explicit CompTag(std::string const & tag, std::string const & attr) : tag_(tag), attr_(attr) {} /// - docstring asTag() const; + docstring writeTag() const; /// std::string tag_; /// @@ -79,13 +113,90 @@ 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, + 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 { public: /// explicit XHTMLStream(odocstream & os); /// - void cr(); - /// odocstream & os() { return os_; } /// // int & tab() { return tab_; } @@ -94,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 &); /// @@ -101,38 +219,66 @@ public: /// XHTMLStream & operator<<(char_type); /// - XHTMLStream & operator<<(StartTag const &); + XHTMLStream & operator<<(int); /// - XHTMLStream & operator<<(EndTag const &); + XHTMLStream & operator<<(char); /// - XHTMLStream & operator<<(CompTag const &); - /// A trivial struct that functions as a stream modifier. - /// << NextRaw() causes the next string-like thing sent to the - /// stream not to be escaped. - struct NextRaw {}; + XHTMLStream & operator<<(html::StartTag const &); /// - XHTMLStream & operator<<(NextRaw const &); + XHTMLStream & operator<<(html::EndTag const &); + /// + 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 & + ESCAPE_ALL // meaning <, >, &, at present + }; + /// 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; + /// + bool isTagPending(html::StartTag const &) const; /// - void writeError(std::string const &); + void writeError(std::string const &) const; /// odocstream & os_; /// - // int tab_; + 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::deque TagDeque; + typedef std::shared_ptr TagPtr; + typedef std::deque TagDeque; + /// + template + TagPtr makeTagPtr(T const & tag) { return std::make_shared(tag); } /// - typedef std::vector TagStack; - /// holds start tags until we know there is content in them. TagDeque pending_tags_; - /// remembers the history, so we can make sure we nest properly. - TagStack tag_stack_; - /// - bool nextraw_; + /// + TagDeque tag_stack_; }; /// @@ -141,23 +287,22 @@ void xhtmlParagraphs(Text const & text, XHTMLStream & xs, OutputParams const & runparams); +/// \return a string appropriate for setting alignment in CSS +/// Does NOT return "justify" for "block" +std::string alignmentToCSS(LyXAlignment align); + namespace html { /// -docstring escapeChar(char_type c); +docstring escapeChar(char_type c, XHTMLStream::EscapeSettings e); /// converts a string to a form safe for links, etc -docstring htmlize(docstring const & str); -/// -std::string escapeChar(char c); -/// converts a string to a form safe for links, etc -std::string htmlize(std::string const & str); - -// to be removed -/// \return true if tag was opened, false if not -bool openTag(odocstream & os, std::string const & tag, - std::string const & attr); -/// \return true if tag was opened, false if not -bool closeTag(odocstream & os, std::string const & tag); -} +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); +/// \p c must be ASCII +docstring escapeChar(char c, XHTMLStream::EscapeSettings e); + +} // namespace html } // namespace lyx #endif