* fr.po: Update from Jean-Pierre Chretien

[lyx.git] / src / output_xhtml.h

diff --git a/src/output_xhtml.h b/src/output_xhtml.h
index 99d07be9d755df9418d352602006ec976aacdda7..ac405cdebd00a880a052d7cb38248ca70e1772d1 100644 (file)
--- a/src/output_xhtml.h
+++ b/src/output_xhtml.h
@@ -30,19 +30,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) 
                : tag_(tag), attr_(attr), keepempty_(keepempty) {}
+       ///
+       ~StartTag() {}
        /// <tag_ attr_>
-       docstring asTag() const;
+       virtual docstring writeTag() const;
        /// </tag_>
-       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_;
        ///
@@ -53,24 +70,31 @@ struct StartTag {
 };
 
 
-struct EndTag {
+///
+struct EndTag
+{
        ///
        explicit EndTag(std::string tag) : tag_(tag) {}
        /// </tag_>
-       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 <img />
 /// 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) {}
@@ -78,7 +102,7 @@ struct CompTag {
        explicit CompTag(std::string const & tag, std::string const & attr)
                : tag_(tag), attr_(attr) {}
        /// <tag_ attr_ />
-       docstring asTag() const;
+       docstring writeTag() const;
        ///
        std::string tag_;
        ///
@@ -86,6 +110,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{};
 
@@ -127,6 +230,10 @@ public:
        ///
        XHTMLStream & operator<<(html::CompTag const &);
        ///
+       XHTMLStream & operator<<(html::ParTag const &);
+       ///
+       XHTMLStream & operator<<(html::FontTag const &);
+       ///
        XHTMLStream & operator<<(html::CR const &);
        ///
        enum EscapeSettings {
@@ -147,9 +254,11 @@ 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;
        ///