src/output_xhtml.h

   1 // -*- C++ -*-
   2 /**
   3  * \file output_xhtml.h
   4  * This file is part of LyX, the document processor.
   5  * Licence details can be found in the file COPYING.
   6  *
   7  * \author Richard Heck
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #ifndef OUTPUT_XHTML_H
  13 #define OUTPUT_XHTML_H
  14
  15 #include "LayoutEnums.h"
  16
  17 #include "support/docstream.h"
  18 #include "support/shared_ptr.h"
  19 #include "support/strfwd.h"
  20
  21 #include <deque>
  22
  23 namespace lyx {
  24
  25 class Buffer;
  26 class OutputParams;
  27 class Text;
  28
  29 // Inspiration for the *Tag structs and for XHTMLStream
  30 // came from MathStream and its cousins.
  31
  32 namespace html {
  33
  34 struct FontTag;
  35 struct EndFontTag;
  36
  37 /// Attributes will be escaped automatically and so should NOT
  38 /// be escaped before being passed to the constructor.
  39 struct StartTag
  40 {
  41         ///
  42         explicit StartTag(std::string const & tag) : tag_(tag), keepempty_(false) {}
  43         ///
  44         explicit StartTag(std::string const & tag, std::string const & attr,
  45                 bool keepempty = false)
  46                 : tag_(tag), attr_(attr), keepempty_(keepempty) {}
  47         ///
  48         virtual ~StartTag() {}
  49         /// <tag_ attr_>
  50         virtual docstring writeTag() const;
  51         /// </tag_>
  52         virtual docstring writeEndTag() const;
  53         ///
  54         virtual FontTag const * asFontTag() const { return 0; }
  55         ///
  56         virtual bool operator==(StartTag const & rhs) const
  57                 { return tag_ == rhs.tag_; }
  58         ///
  59         virtual bool operator!=(StartTag const & rhs) const
  60                 { return !(*this == rhs); }
  61         ///
  62         virtual bool operator==(FontTag const & rhs) const;
  63         ///
  64         std::string tag_;
  65         ///
  66         std::string attr_;
  67         /// whether to keep things like "<tag></tag>" or discard them
  68         /// you would want this for td, e.g, but maybe not for a div
  69         bool keepempty_;
  70 };
  71
  72
  73 ///
  74 struct EndTag
  75 {
  76         ///
  77         explicit EndTag(std::string tag) : tag_(tag) {}
  78         /// </tag_>
  79         virtual docstring writeEndTag() const;
  80         ///
  81         bool operator==(StartTag const & rhs) const
  82                 { return tag_ == rhs.tag_; }
  83         ///
  84         bool operator!=(StartTag const & rhs) const
  85                 { return !(*this == rhs); }
  86         ///
  87         virtual EndFontTag const * asFontTag() const { return 0; }
  88         ///
  89         std::string tag_;
  90 };
  91
  92
  93 /// Tags like <img />
  94 /// Attributes will be escaped automatically and so should NOT
  95 /// be escaped before being passed to the constructor.
  96 struct CompTag
  97 {
  98         ///
  99         explicit CompTag(std::string const & tag)
 100                 : tag_(tag) {}
 101         ///
 102         explicit CompTag(std::string const & tag, std::string const & attr)
 103                 : tag_(tag), attr_(attr) {}
 104         /// <tag_ attr_ />
 105         docstring writeTag() const;
 106         ///
 107         std::string tag_;
 108         ///
 109         std::string attr_;
 110 };
 111
 112
 113 /// A special case of StartTag, used exclusively for tags that wrap paragraphs.
 114 struct ParTag : public StartTag
 115 {
 116         ///
 117         explicit ParTag(std::string const & tag, std::string const & attr,
 118                std::string const & parid)
 119           : StartTag(tag, attr), parid_(parid)
 120         {}
 121         ///
 122         ~ParTag() {}
 123         ///
 124         docstring writeTag() const;
 125         /// the "magic par label" for this paragraph
 126         std::string parid_;
 127 };
 128
 129
 130 ///
 131 enum FontTypes {
 132         // ranges
 133         FT_EMPH,
 134         FT_NOUN,
 135         FT_UBAR,
 136         FT_DBAR,
 137         FT_WAVE,
 138         FT_SOUT,
 139         // bold
 140         FT_BOLD,
 141         // shapes
 142         FT_UPRIGHT,
 143         FT_ITALIC,
 144         FT_SLANTED,
 145         FT_SMALLCAPS,
 146         // families
 147         FT_ROMAN,
 148         FT_SANS,
 149         FT_TYPE,
 150         // sizes
 151         FT_SIZE_TINY,
 152         FT_SIZE_SCRIPT,
 153         FT_SIZE_FOOTNOTE,
 154         FT_SIZE_SMALL,
 155         FT_SIZE_NORMAL,
 156         FT_SIZE_LARGE,
 157         FT_SIZE_LARGER,
 158         FT_SIZE_LARGEST,
 159         FT_SIZE_HUGE,
 160         FT_SIZE_HUGER,
 161         FT_SIZE_INCREASE,
 162         FT_SIZE_DECREASE
 163 };
 164
 165
 166 ///
 167 struct FontTag : public StartTag
 168 {
 169         ///
 170         explicit FontTag(FontTypes type);
 171         ///
 172         FontTag const * asFontTag() const { return this; }
 173         ///
 174         bool operator==(StartTag const &) const;
 175         ///
 176         FontTypes font_type_;
 177 };
 178
 179
 180 ///
 181 struct EndFontTag : public EndTag
 182 {
 183         ///
 184         explicit EndFontTag(FontTypes type);
 185         ///
 186         EndFontTag const * asFontTag() const { return this; }
 187         ///
 188         FontTypes font_type_;
 189 };
 190
 191
 192 // trivial struct for output of newlines
 193 struct CR{};
 194
 195 } // namespace html
 196
 197 class XHTMLStream {
 198 public:
 199         ///
 200         explicit XHTMLStream(odocstream & os);
 201         ///
 202         odocstream & os() { return os_; }
 203         ///
 204         // int & tab() { return tab_; }
 205         /// closes any font tags that are eligible to be closed,
 206         /// i.e., last on the tag_stack_.
 207         /// \return false if there are open font tags we could not close.
 208         /// because they are "blocked" by open non-font tags on the stack.
 209         bool closeFontTags();
 210         /// call at start of paragraph. sets a mark so we know what tags
 211         /// to close at the end.
 212         void startParagraph(bool keep_empty);
 213         /// call at end of paragraph to clear that mark. note that this
 214         /// will also close any tags still open.
 215         void endParagraph();
 216         ///
 217         XHTMLStream & operator<<(docstring const &);
 218         ///
 219         XHTMLStream & operator<<(const char *);
 220         ///
 221         XHTMLStream & operator<<(char_type);
 222         ///
 223         XHTMLStream & operator<<(int);
 224         ///
 225         XHTMLStream & operator<<(char);
 226         ///
 227         XHTMLStream & operator<<(html::StartTag const &);
 228         ///
 229         XHTMLStream & operator<<(html::EndTag const &);
 230         ///
 231         XHTMLStream & operator<<(html::CompTag const &);
 232         ///
 233         XHTMLStream & operator<<(html::ParTag const &);
 234         ///
 235         XHTMLStream & operator<<(html::FontTag const &);
 236         ///
 237         XHTMLStream & operator<<(html::CR const &);
 238         ///
 239         enum EscapeSettings {
 240                 ESCAPE_NONE,
 241                 ESCAPE_AND, // meaning &
 242                 ESCAPE_ALL  // meaning <, >, &, at present
 243         };
 244         /// Sets what we are going to escape on the NEXT write.
 245         /// Everything is reset for the next time.
 246         XHTMLStream & operator<<(EscapeSettings);
 247 #if 0
 248         /// This routine is for debugging the tag stack, etc. Code
 249         /// for it is disabled by default, however, so you will need
 250         /// to enable it if you want to use it.
 251         void dumpTagStack(std::string const & msg) const;
 252 #endif
 253 private:
 254         ///
 255         void clearTagDeque();
 256         ///
 257         bool isTagOpen(html::StartTag const &) const;
 258         ///
 259         bool isTagOpen(html::EndTag const &) const;
 260         ///
 261         bool isTagPending(html::StartTag const &) const;
 262         ///
 263         void writeError(std::string const &) const;
 264         ///
 265         odocstream & os_;
 266         ///
 267         EscapeSettings escape_;
 268         // What we would really like to do here is simply use a
 269         // deque<StartTag>. But we want to store both StartTags and
 270         // sub-classes thereof on this stack, which means we run into the
 271         // so-called polymorphic class problem with the STL. We therefore have
 272         // to use a deque<StartTag *>, which leads to the question who will
 273         // own these pointers and how they will be deleted, so we use shared
 274         // pointers.
 275         ///
 276         typedef shared_ptr<html::StartTag> TagPtr;
 277         typedef std::deque<TagPtr> TagDeque;
 278         ///
 279         template <typename T>
 280         shared_ptr<T> makeTagPtr(T const & tag)
 281                 { return shared_ptr<T>(new T(tag)); }
 282         ///
 283         TagDeque pending_tags_;
 284         ///
 285         TagDeque tag_stack_;
 286 };
 287
 288 ///
 289 void xhtmlParagraphs(Text const & text,
 290                        Buffer const & buf,
 291                        XHTMLStream & xs,
 292                        OutputParams const & runparams);
 293
 294 /// \return a string appropriate for setting alignment in CSS
 295 /// Does NOT return "justify" for "block"
 296 std::string alignmentToCSS(LyXAlignment align);
 297
 298 namespace html {
 299 ///
 300 docstring escapeChar(char_type c, XHTMLStream::EscapeSettings e);
 301 /// converts a string to a form safe for links, etc
 302 docstring htmlize(docstring const & str, XHTMLStream::EscapeSettings e);
 303 /// cleans \param str for use as an atttribute by replacing
 304 /// all non-alnum by "_"
 305 docstring cleanAttr(docstring const & str);
 306 ///
 307 std::string escapeChar(char c, XHTMLStream::EscapeSettings e);
 308 ///
 309 std::string htmlize(std::string const & str, XHTMLStream::EscapeSettings e);
 310 ///
 311 std::string cleanAttr(std::string const & str);
 312
 313 } // namespace html
 314 } // namespace lyx
 315
 316 #endif