Corrected initialization order.

[inkscape.git] / src / dom / css.h

/**
 * Phoebe DOM Implementation.
 *
 * This is a C++ approximation of the W3C DOM model, which follows
 * fairly closely the specifications in the various .idl files, copies of
 * which are provided for reference.  Most important is this one:
 *
 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html
 *
 * Authors:
 *   Bob Jamison
 *
 * Copyright (C) 2005-2008 Bob Jamison
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *  
 * =======================================================================
 * NOTES
 * 
 * Views, Stylesheets and CSS are DOM Level 2 for the purposes of supporting
 * SVG.  Be prepared in the future when they make Level 3 and SVG is likewise
 * updated.  The API here and many of the comments come from this document:
 * http://www.w3.org/TR/DOM-Level-2-Style/css.html    
     
 */

#ifndef __CSS_H__
#define __CSS_H__

#include "dom.h"
#include "stylesheets.h"
#include "views.h"

#include <vector>
#include <map>


namespace org {
namespace w3c {
namespace dom {
namespace css {




//Make local definitions
typedef dom::DOMString DOMString;
typedef dom::Element Element;
typedef dom::DOMImplementation DOMImplementation;

//forward declarations
class CSSRule;
class CSSStyleSheet;
class CSSStyleDeclaration;
class CSSValue;
class Counter;
class Rect;
class RGBColor;





/*#########################################################################
## CSSRule
#########################################################################*/

/**
 * The CSSRule interface is the abstract base interface for any type of CSS 
 * statement. This includes both rule sets and at-rules. An implementation is 
 * expected to preserve all rules specified in a CSS style sheet, even if the 
 * rule is not recognized by the parser. Unrecognized rules are represented using 
 * the CSSUnknownRule interface.
 */
class CSSRule
{
public:

    /**
     * An integer indicating which type of rule this is.
     */      
    typedef enum
        {
        UNKNOWN_RULE    = 0,
        STYLE_RULE      = 1,
        CHARSET_RULE    = 2,
        IMPORT_RULE     = 3,
        MEDIA_RULE      = 4,
        FONT_FACE_RULE  = 5,
        PAGE_RULE       = 6
        } RuleType;


    /**
     * The type of the rule, as defined above. The expectation is that 
     * binding-specific casting methods can be used to cast down from an instance of 
     * the CSSRule interface to the specific derived interface implied by the type.
     */
    virtual unsigned short getType()
        {
        return type;
        }

    /**
     * The parsable textual representation of the rule. This reflects the current 
     * state of the rule and not its initial value.
     */
    virtual DOMString getCssText()
        {
        return cssText;
        }

    /**
     * The parsable textual representation of the rule. This reflects the current 
     * state of the rule and not its initial value.
     * Note that setting involves reparsing.     
     */
    virtual void setCssText(const DOMString &val) throw (dom::DOMException)
        {
        cssText = val;
        }

    /**
     * The style sheet that contains this rule.
     */
    virtual CSSStyleSheet *getParentStyleSheet()
        {
        return parentStyleSheet;
        }

    /**
     * If this rule is contained inside another rule (e.g. a style rule inside an 
     * @media block), this is the containing rule. If this rule is not nested inside 
     * any other rules, this returns null.
     */
    virtual CSSRule *getParentRule()
        {
        return parentRule;
        }



    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSRule()
        {
        type             = UNKNOWN_RULE;
        cssText          = "";
        parentStyleSheet = NULL;
        parentRule       = NULL;
        }

    /**
     *
     */
    CSSRule(const CSSRule &other)
        {
        assign(other);
        }

    /**
     *
     */
    CSSRule &operator=(const CSSRule &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSSRule &other)
        {
        type             = other.type;
        cssText          = other.cssText;
        parentStyleSheet = other.parentStyleSheet;
        parentRule       = other.parentRule;
        }

    /**
     *
     */
    virtual ~CSSRule() {}

protected:

    int type;

    DOMString cssText;

    CSSStyleSheet *parentStyleSheet;

    CSSRule *parentRule;
};



/*#########################################################################
## CSSRuleList
#########################################################################*/

/**
 * The CSSRuleList interface provides the abstraction of an ordered collection of 
 * CSS rules.
 * 
 * The items in the CSSRuleList are accessible via an integral index, starting 
 * from 0.
 */
class CSSRuleList
{
public:

    /**
     * The number of CSSRules in the list. The range of valid child rule indices is 0 
     * to length-1 inclusive.
     */
    virtual unsigned long getLength()
        {
        return rules.size();
        }

    /**
     * Used to retrieve a CSS rule by ordinal index. The order in this collection 
     * represents the order of the rules in the CSS style sheet. If index is greater 
     * than or equal to the number of rules in the list, this returns null.
     */
    virtual CSSRule item(unsigned long index)
        {
        if (index>=rules.size())
            {
            CSSRule rule;
            return rule;
            }
        return rules[index];
        }


    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSRuleList() {}


    /**
     *
     */
    CSSRuleList(const CSSRuleList &other)
        {
        rules = other.rules;
        }

    /**
     *
     */
    CSSRuleList &operator=(const CSSRuleList &other)
        {
        rules = other.rules;
        return *this;
        }

    /**
     *
     */
    virtual ~CSSRuleList() {}

protected:

friend class CSSMediaRule;
friend class CSSStyleSheet;

    /**
     *
     */
    virtual void addRule(const CSSRule &rule)
        {
        rules.push_back(rule);
        }


    /**
     *
     */
    virtual void deleteRule(unsigned long index)
        {
        if (index>=rules.size())
            return;
        std::vector<CSSRule>::iterator iter = rules.begin() + index;
        rules.erase(iter);
        }


    /**
     *
     */
    virtual long insertRule(const CSSRule &rule, unsigned long index)
        {
        if (index>=rules.size())
            return -1;
        std::vector<CSSRule>::iterator iter = rules.begin() + index;
        rules.insert(iter, rule);
        return index;
        }

    std::vector<CSSRule>rules;
};


/*#########################################################################
## CSSStyleSheet
#########################################################################*/

/**
 * The CSSStyleSheet interface is a concrete interface used to represent a CSS 
 * style sheet i.e., a style sheet whose content type is "text/css".
 */
class CSSStyleSheet : virtual public stylesheets::StyleSheet
{
public:

    /**
     * If this style sheet comes from an @import rule, the ownerRule attribute will 
     * contain the CSSImportRule. In that case, the ownerNode attribute in the 
     * StyleSheet interface will be null. If the style sheet comes from an element or 
     * a processing instruction, the ownerRule attribute will be null and the 
     * ownerNode attribute will contain the Node.
     */
    virtual CSSRule *getOwnerRule()
        {
        return ownerRule;
        }

    /**
     * The list of all CSS rules contained within the style sheet. This
     *   includes both rule sets and at-rules.
     */
    virtual CSSRuleList getCssRules()
        {
        return rules;
        }

    /**
     * Used to insert a new rule into the style sheet. The new rule now
     *   becomes part of the cascade. 
     */
    virtual unsigned long insertRule(const DOMString &/*ruleStr*/,
                                     unsigned long index)
                                     throw (dom::DOMException)
        {
        CSSRule rule;
        return rules.insertRule(rule, index);
        }

    /**
     * Used to delete a rule from the style sheet. 
     */
    virtual void deleteRule(unsigned long index)
                            throw (dom::DOMException)
        {
        rules.deleteRule(index);
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSStyleSheet() : stylesheets::StyleSheet()
        {
        }

    /**
     *
     */
    CSSStyleSheet(const CSSStyleSheet &other) :
                  stylesheets::StyleSheet(other)
        {
        assign(other);
        }

    /**
     *
     */
    CSSStyleSheet &operator=(const CSSStyleSheet &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSSStyleSheet &other)
        {
        ownerRule = other.ownerRule;
        rules     = other.rules;
        }

    /**
     *
     */
    virtual ~CSSStyleSheet() {}

protected:

    CSSRule *ownerRule;

    CSSRuleList rules;
};


/*#########################################################################
## CSSValue
#########################################################################*/

/**
 * The CSSValue interface represents a simple or a complex value. A CSSValue 
 * object only occurs in a context of a CSS property.
 */
class CSSValue
{
public:

    /**
     * An integer indicating which type of unit applies to the value.
     */
    typedef enum
        {
        CSS_INHERIT         = 0,
        CSS_PRIMITIVE_VALUE = 1,
        CSS_VALUE_LIST      = 2,
        CSS_CUSTOM          = 3
        } UnitTypes;

    /**
     * A code defining the type of the value as defined above.
     */
    virtual unsigned short getCssValueType()
        {
        return valueType;
        }

    /**
     * A string representation of the current value.
     */
    virtual DOMString getCssText()
        {
        return cssText;
        }

    /**
     * A string representation of the current value.
     * Note that setting implies parsing.     
     */
    virtual void setCssText(const DOMString &val)
                            throw (dom::DOMException)
        {
        cssText = val;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSValue()
        {
        valueType = CSS_INHERIT;
        }

    /**
     *
     */
    CSSValue(const CSSValue &other)
        {
        assign(other);
        }

    /**
     *
     */
    CSSValue &operator=(const CSSValue &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSSValue &other)
        {
        cssText   = other.cssText;
        valueType = other.valueType;
        }

    /**
     *
     */
    virtual ~CSSValue() {}

protected:

    DOMString cssText;
    int valueType;
};





/*#########################################################################
## CSSStyleDeclaration
#########################################################################*/

/**
 * The CSSStyleDeclaration interface represents a single CSS declaration block. 
 * This interface may be used to determine the style properties currently set in 
 * a block or to set style properties explicitly within the block.
 * 
 * While an implementation may not recognize all CSS properties within a CSS 
 * declaration block, it is expected to provide access to all specified 
 * properties in the style sheet through the CSSStyleDeclaration interface. 
 * Furthermore, implementations that support a specific level of CSS should 
 * correctly handle CSS shorthand properties for that level. For a further 
 * discussion of shorthand properties, see the CSS2Properties interface.
 * 
 * This interface is also used to provide a read-only access to the computed 
 * values of an element. See also the ViewCSS interface.
 * 
 * Note: The CSS Object Model doesn't provide an access to the specified or 
 * actual values of the CSS cascade.
 */
class CSSStyleDeclaration
{
private:

        class CSSStyleDeclarationEntry
        {
        public:
            CSSStyleDeclarationEntry(const DOMString &nameArg,
                                     const DOMString &valueArg,
                                     const DOMString &prioArg)
                {
                name  = nameArg;
                value = valueArg;
                prio  = prioArg;
                }
            virtual ~CSSStyleDeclarationEntry(){}
            DOMString name;
            DOMString value;
            DOMString prio;
        };
        

public:

    /**
     * The parsable textual representation of the declaration block (excluding the 
     * surrounding curly braces).
     */
    virtual DOMString getCssText()
        {
        return cssText;
        }

    /**
     * The parsable textual representation of the declaration block (excluding the 
     * surrounding curly braces). Setting this attribute will result in the parsing 
     * of the new value and resetting of all the properties in the declaration block 
     * including the removal or addition of properties.
     */
    virtual void setCssText(const DOMString &val)
                            throw (dom::DOMException)
        {
        cssText = val;
        }

    /**
     * Used to retrieve the value of a CSS property if it has been explicitly
     *   set within this declaration block. 
     */
    virtual DOMString getPropertyValue(const DOMString &propertyName)
        {
        std::vector<CSSStyleDeclarationEntry>::iterator iter;
        for (iter=items.begin() ; iter!=items.end() ; iter++)
            {
            if (iter->name == propertyName)
                return iter->value;
            }
        return "";
        }

    /**
     * Used to retrieve the object representation of the value of a CSS property if 
     * it has been explicitly set within this declaration block. This method returns 
     * null if the property is a shorthand property. Shorthand property values can 
     * only be accessed and modified as strings, using the getPropertyValue and 
     * setProperty methods.
     */
    virtual CSSValue getPropertyCSSValue(const DOMString &/*propertyName*/)
        {
        CSSValue value;
        return value;
        }

    /**
     * Used to remove a CSS property if it has been explicitly set within
     *   this declaration block. 
     */
    virtual DOMString removeProperty(const DOMString &propertyName)
                                     throw (dom::DOMException)
        {
        std::vector<CSSStyleDeclarationEntry>::iterator iter;
        for (iter=items.begin() ; iter!=items.end() ; iter++)
            {
            if (iter->name == propertyName)
                items.erase(iter);
            }
        return propertyName;
        }

    /**
     * Used to retrieve the priority of a CSS property (e.g. the "important" 
     * qualifier) if the property has been explicitly set in this declaration block.
     */
    virtual DOMString getPropertyPriority(const DOMString &propertyName)
        {
        std::vector<CSSStyleDeclarationEntry>::iterator iter;
        for (iter=items.begin() ; iter!=items.end() ; iter++)
            {
            if (iter->name == propertyName)
                return iter->prio;
            }
        return "";
        }

    /**
     * Used to set a property value and priority within this declaration block. 
     */
    virtual void setProperty(const DOMString &propertyName,
                             const DOMString &value,
                             const DOMString &priority)
                             throw (dom::DOMException)
        {
        std::vector<CSSStyleDeclarationEntry>::iterator iter;
        for (iter=items.begin() ; iter!=items.end() ; iter++)
            {
            if (iter->name == propertyName)
                {
                iter->name  = propertyName;
                iter->value = value;
                iter->prio  = priority;
                return;
                }
            }
        CSSStyleDeclarationEntry entry(propertyName, value, priority);
        items.push_back(entry);
        }

    /**
     * The number of properties that have been explicitly set in this declaration 
     * block. The range of valid indices is 0 to length-1 inclusive.
     */
    virtual unsigned long getLength()
        {
        return items.size();
        }

    /**
     * Used to retrieve the properties that have been explicitly set in this 
     * declaration block. The order of the properties retrieved using this method 
     * does not have to be the order in which they were set. This method can be used 
     * to iterate over all properties in this declaration block.
     */
    virtual DOMString item(unsigned long index)
        {
        if (index>=items.size())
            return "";
        DOMString ret = items[index].name;
        ret.append(":");
        ret.append(items[index].value);
        return ret;
        }

    /**
     * The CSS rule that contains this declaration block or null if this 
     * CSSStyleDeclaration is not attached to a CSSRule.
     */
    virtual CSSRule *getParentRule()
        {
        return parentRule;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSStyleDeclaration()
        {
        parentRule = NULL;
        }

    /**
     *
     */
    CSSStyleDeclaration(const CSSStyleDeclaration &other)
        {
        assign(other);
        }

    /**
     *
     */
    CSSStyleDeclaration &operator=(const CSSStyleDeclaration &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSSStyleDeclaration &other)
        {
        parentRule = other.parentRule;
        cssText    = other.cssText;
        items      = other.items;
        }

    /**
     *
     */
    virtual ~CSSStyleDeclaration() {}

protected:

   DOMString cssText;

   CSSRule *parentRule;

   std::vector<CSSStyleDeclarationEntry> items;
};




/*#########################################################################
## CSSStyleRule
#########################################################################*/

/**
 * The CSSStyleRule interface represents a single rule set in a CSS style sheet.
 */
class CSSStyleRule : virtual public CSSRule
{
public:

    /**
     * The textual representation of the selector for the rule set. The 
     * implementation may have stripped out insignificant whitespace while parsing 
     * the selector.
     */
    virtual DOMString getSelectorText()
        {
        return selectorText;
        }

    /**
     * The textual representation of the selector for the rule set. The 
     * implementation may have stripped out insignificant whitespace while parsing 
     * the selector.  Setting implies reparsing.
     */
    virtual void setSelectorText(const DOMString &val)
                throw (dom::DOMException)
        {
        selectorText = val;
        }


    /**
     * The declaration-block of this rule set.
     */
    virtual CSSStyleDeclaration &getStyle()
        {
        return style;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSStyleRule() : CSSRule()
        {
        type = STYLE_RULE;
        selectorText = "";
        }


    /**
     *
     */
    CSSStyleRule(const CSSStyleRule &other) : CSSRule(other)
        {
        assign(other);
        }

    /**
     *
     */
    CSSStyleRule &operator=(const CSSStyleRule &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSSStyleRule &other)
        {
        selectorText = other.selectorText;
        style        = other.style;
        }

    /**
     *
     */
    virtual ~CSSStyleRule() {}

protected:

    DOMString selectorText;

    CSSStyleDeclaration style;

};

/*#########################################################################
## CSSMediaRule
#########################################################################*/

/**
 * The CSSMediaRule interface represents a @media rule in a CSS style sheet. A 
 * @media rule can be used to delimit style rules for specific media types.
 */
class CSSMediaRule : virtual public CSSRule
{
public:

    /**
     * A list of media types for this rule.
     */
    virtual stylesheets::MediaList getMedia()
        {
        return mediaList;
        }

    /**
     * A list of all CSS rules contained within the media block.
     */
    virtual CSSRuleList getCssRules()
        {
        return cssRules;
        }

    /**
     * Used to insert a new rule into the media block. 
     */
    virtual unsigned long insertRule(const DOMString &/*ruleStr*/,
                                     unsigned long index)
                                     throw (dom::DOMException)
        {
        if (index>cssRules.getLength())
            return 0;
        CSSRule rule;
        cssRules.insertRule(rule, index);
        return index;
        }

    /**
     * Used to delete a rule from the media block. 
     */
    virtual void deleteRule(unsigned long index)
                            throw(dom::DOMException)
        {
        cssRules.deleteRule(index);
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSMediaRule() : CSSRule()
        {
        type = MEDIA_RULE;
        }

    /**
     *
     */
    CSSMediaRule(const CSSMediaRule &other) : CSSRule(other)
        {
        assign(other);
        }

    /**
     *
     */
    CSSMediaRule &operator=(const CSSMediaRule &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSSMediaRule &other)
        {
        mediaList = other.mediaList;
        cssRules  = other.cssRules;
        }

    /**
     *
     */
    virtual ~CSSMediaRule() {}

protected:

    stylesheets::MediaList mediaList;

    CSSRuleList cssRules;
};




/*#########################################################################
## CSSFontFaceRule
#########################################################################*/

/**
 * The CSSFontFaceRule interface represents a @font-face rule in a CSS style 
 * sheet. The @font-face rule is used to hold a set of font descriptions.
 */
class CSSFontFaceRule : virtual public CSSRule
{
public:

    /**
     * The declaration-block of this rule.
     */
    virtual CSSStyleDeclaration getStyle()
        {
        return style;
        }


    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSFontFaceRule() : CSSRule()
        {
        type = FONT_FACE_RULE;
        }

    /**
     *
     */
    CSSFontFaceRule(const CSSFontFaceRule &other) : CSSRule(other)
        {
        style = other.style;
        }

    /**
     *
     */
    CSSFontFaceRule &operator=(const CSSFontFaceRule &other)
        {
        style = other.style;
        return *this;
        }

    /**
     *
     */
    void assign(const CSSFontFaceRule &other)
        {
        style = other.style;
        }

    /**
     *
     */
    virtual ~CSSFontFaceRule() {}

protected:

    CSSStyleDeclaration style;
};




/*#########################################################################
## CSSPageRule
#########################################################################*/

/**
 * The CSSPageRule interface represents a @page rule within a CSS style sheet. 
 * The @page rule is used to specify the dimensions, orientation, margins, etc. 
 * of a page box for paged media.
 */
class CSSPageRule : virtual public CSSRule
{
public:

    /**
     * The parsable textual representation of the page selector for the rule.
     */
    virtual DOMString getSelectorText()
        {
        return selectorText;
        }

    /**
     * The parsable textual representation of the page selector for the rule.
     * Setting implies parsing.     
     */
    virtual void setSelectorText(const DOMString &val)
                         throw(dom::DOMException)
        {
        selectorText = val;
        }


    /**
     * The declaration-block of this rule.
     */
    virtual CSSStyleDeclaration getStyle()
        {
        return style;
        }


    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSPageRule() : CSSRule()
        {
        type = PAGE_RULE;
        }

    /**
     *
     */
    CSSPageRule(const CSSPageRule &other) : CSSRule(other)
        {
        assign(other);
        }

    /**
     *
     */
    CSSPageRule &operator=(const CSSPageRule &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSSPageRule &other)
        {
        selectorText = other.selectorText;
        style        = other.style;
        }

    /**
     *
     */
    virtual ~CSSPageRule() {}

protected:

    DOMString selectorText;

    CSSStyleDeclaration style;
};





/*#########################################################################
## CSSImportRule
#########################################################################*/

/**
 * The CSSImportRule interface represents a @import rule within a CSS style 
 * sheet. The @import rule is used to import style rules from other style sheets.
 */
class CSSImportRule : virtual public CSSRule
{
public:

    /**
     * The location of the style sheet to be imported. The attribute will not contain 
     * the "url(...)" specifier around the URI.
     */
    virtual DOMString getHref()
        {
        return href;
        }

    /**
     * A list of media types for which this style sheet may be used.
     */
    virtual stylesheets::MediaList getMedia()
        {
        return mediaList;
        }

    /**
     * The style sheet referred to by this rule, if it has been loaded. The value of 
     * this attribute is null if the style sheet has not yet been loaded or if it 
     * will not be loaded (e.g. if the style sheet is for a media type not supported 
     * by the user agent).
     */
    virtual CSSStyleSheet getStyleSheet()
        {
        return styleSheet;
        }


    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSImportRule() : CSSRule()
        {
        type = IMPORT_RULE;
        }

    /**
     *
     */
    CSSImportRule(const CSSImportRule &other) : CSSRule(other)
        {
        assign(other);
        }

    /**
     *
     */
    CSSImportRule &operator=(const CSSImportRule &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSSImportRule &other)
        {
        mediaList  = other.mediaList;
        styleSheet = other.styleSheet;
        }

    /**
     *
     */
    virtual ~CSSImportRule() {}

protected:

    DOMString href;

    stylesheets::MediaList mediaList;

    CSSStyleSheet styleSheet;
};






/*#########################################################################
## CSSCharsetRule
#########################################################################*/

/**
 * The CSSCharsetRule interface represents a @charset rule in a CSS style sheet. 
 * The value of the encoding attribute does not affect the encoding of text data 
 * in the DOM objects; this encoding is always UTF-16. After a stylesheet is 
 * loaded, the value of the encoding attribute is the value found in the @charset 
 * rule. If there was no @charset in the original document, then no 
 * CSSCharsetRule is created. The value of the encoding attribute may also be 
 * used as a hint for the encoding used on serialization of the style sheet.
 * 
 * The value of the @charset rule (and therefore of the CSSCharsetRule) may not 
 * correspond to the encoding the document actually came in; character encoding 
 * information e.g. in an HTTP header, has priority (see CSS document 
 * representation) but this is not reflected in the CSSCharsetRule.
 */
class CSSCharsetRule : virtual public CSSRule
{
public:

    /**
     * The encoding information used in this @charset rule.
     */
    virtual DOMString getEncoding()
        {
        return encoding;
        }

    /**
     * The encoding information used in this @charset rule.
     * Setting implies parsing.     
     */
    virtual void setEncoding(const DOMString &val) throw (dom::DOMException)
        {
        encoding = val;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSCharsetRule() : CSSRule()
        {
        type = CHARSET_RULE;
        }

    /**
     *
     */
    CSSCharsetRule(const CSSCharsetRule &other) : CSSRule(other)
        {
        encoding = other.encoding;
        }

    /**
     *
     */
    CSSCharsetRule &operator=(const CSSCharsetRule &other)
        {
        encoding = other.encoding;
        return *this;
        }

    /**
     *
     */
    virtual ~CSSCharsetRule() {}

protected:

    DOMString encoding;

};





/*#########################################################################
## CSSUnknownRule
#########################################################################*/

/**
 * The CSSUnknownRule interface represents an at-rule not supported by
 *  this user agent.
 */
class CSSUnknownRule : virtual public CSSRule
{
public:

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSUnknownRule() : CSSRule()
        {
        type = UNKNOWN_RULE;
        }

    /**
     *
     */
    CSSUnknownRule(const CSSUnknownRule &other) : CSSRule(other)
        {
        }

    /**
     *
     */
    CSSUnknownRule &operator=(const CSSUnknownRule &/*other*/)
        {
        return *this;
        }

    /**
     *
     */
    virtual ~CSSUnknownRule() {}
};







/*#########################################################################
## CSSValueList
#########################################################################*/

/**
 * The CSSValueList interface provides the abstraction of an ordered collection 
 * of CSS values.
 * 
 * Some properties allow an empty list into their syntax. In that case, these 
 * properties take the none identifier. So, an empty list means that the property 
 * has the value none.
 * 
 * The items in the CSSValueList are accessible via an integral index, starting 
 * from 0.
 */
class CSSValueList : virtual public CSSValue
{
public:

    /**
     * The number of CSSValues in the list. The range of valid values of the indices 
     * is 0 to length-1 inclusive.
     */
    virtual unsigned long getLength()
        {
        return items.size();
        }

    /**
     * Used to retrieve a CSSValue by ordinal index. The order in this collection 
     * represents the order of the values in the CSS style property. If index is 
     * greater than or equal to the number of values in the list, this returns null.
     */
    virtual CSSValue item(unsigned long index)
        {
        if (index>=items.size())
            {
            CSSValue dummy;
            return dummy;
            }
        return items[index];
        }


    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSValueList()
        {
        }

    /**
     *
     */
    CSSValueList(const CSSValueList &other) : CSSValue(other)
        {
        items = other.items;
        }

    /**
     *
     */
    CSSValueList &operator=(const CSSValueList &other)
        {
        items = other.items;
        return *this;
        }

    /**
     *
     */
    virtual ~CSSValueList() {}

protected:

    std::vector<CSSValue> items;
};




/*#########################################################################
## CSSPrimitiveValue
#########################################################################*/

/**
 * The CSSPrimitiveValue interface represents a single CSS value. This interface 
 * may be used to determine the value of a specific style property currently set 
 * in a block or to set a specific style property explicitly within the block. An 
 * instance of this interface might be obtained from the getPropertyCSSValue 
 * method of the CSSStyleDeclaration interface. A CSSPrimitiveValue object only 
 * occurs in a context of a CSS property.
 * 
 * Conversions are allowed between absolute values (from millimeters to 
 * centimeters, from degrees to radians, and so on) but not between relative 
 * values. (For example, a pixel value cannot be converted to a centimeter value.)
 * Percentage values can't be converted since they are relative to the parent 
 * value (or another property value). There is one exception for color percentage 
 * values: since a color percentage value is relative to the range 0-255, a color 
 * percentage value can be converted to a number; (see also the RGBColor 
 * interface).
 */
class CSSPrimitiveValue : virtual public CSSValue
{
public:

    /**
     *An integer indicating which type of unit applies to the value.
     */
    typedef enum
        {
        CSS_UNKNOWN    = 0,
        CSS_NUMBER     = 1,
        CSS_PERCENTAGE = 2,
        CSS_EMS        = 3,
        CSS_EXS        = 4,
        CSS_PX         = 5,
        CSS_CM         = 6,
        CSS_MM         = 7,
        CSS_IN         = 8,
        CSS_PT         = 9,
        CSS_PC         = 10,
        CSS_DEG        = 11,
        CSS_RAD        = 12,
        CSS_GRAD       = 13,
        CSS_MS         = 14,
        CSS_S          = 15,
        CSS_HZ         = 16,
        CSS_KHZ        = 17,
        CSS_DIMENSION  = 18,
        CSS_STRING     = 19,
        CSS_URI        = 20,
        CSS_IDENT      = 21,
        CSS_ATTR       = 22,
        CSS_COUNTER    = 23,
        CSS_RECT       = 24,
        CSS_RGBCOLOR   = 25
        } UnitTypes;


    /**
     * The type of the value as defined by the constants specified above.
     */
    virtual unsigned short getPrimitiveType()
        {
        return primitiveType;
        }

    /**
     * A method to set the float value with a specified unit. If the property 
     * attached with this value can not accept the specified unit or the float value, 
     * the value will be unchanged and a DOMException will be raised.
     */
    virtual void setFloatValue(unsigned short unitType,
                               double doubleValueArg)
                               throw (dom::DOMException)
        {
        primitiveType = unitType;
        doubleValue = doubleValueArg;
        }

    /**
     * This method is used to get a float value in a specified unit. If this CSS 
     * value doesn't contain a float value or can't be converted into the specified 
     * unit, a DOMException is raised.
     */
    virtual double getFloatValue(unsigned short /*unitType*/)
                                throw (dom::DOMException)
        {
        return doubleValue;
        }

    /**
     * A method to set the string value with the specified unit. If the property 
     * attached to this value can't accept the specified unit or the string value, 
     * the value will be unchanged and a DOMException will be raised.
     */
    virtual void setStringValue(unsigned short /*stringType*/,
                                const DOMString &stringValueArg)
                                throw (dom::DOMException)
        {
        stringValue = stringValueArg;
        }

    /**
     * This method is used to get the string value. If the CSS value doesn't contain 
     * a string value, a DOMException is raised.
     * 
     * Note: Some properties (like 'font-family' or 'voice-family') convert a 
     * whitespace separated list of idents to a string.
     */
    virtual DOMString getStringValue() throw (dom::DOMException)
        {
        return stringValue;
        }

    /**
     * This method is used to get the Counter value. If this CSS value doesn't 
     * contain a counter value, a DOMException is raised. Modification to the 
     * corresponding style property can be achieved using the Counter interface.
     */
    virtual Counter *getCounterValue() throw (dom::DOMException)
        {
        return NULL;
        }

    /**
     * This method is used to get the Rect value. If this CSS value doesn't contain a 
     * rect value, a DOMException is raised. Modification to the corresponding style 
     * property can be achieved using the Rect interface.
     */
    virtual Rect *getRectValue() throw (dom::DOMException)
        {
        return NULL;
        }

    /**
     * This method is used to get the RGB color. If this CSS value doesn't contain a 
     * RGB color value, a DOMException is raised. Modification to the corresponding 
     * style property can be achieved using the RGBColor interface.
     */
    virtual RGBColor *getRGBColorValue() throw (dom::DOMException)
        {
        return NULL;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSSPrimitiveValue() : CSSValue()
        {
        }

    /**
     *
     */
    CSSPrimitiveValue(const CSSPrimitiveValue &other) : CSSValue(other)
        {
        }

    /**
     *
     */
    CSSPrimitiveValue &operator=(const CSSPrimitiveValue &/*other*/)
        {
        return *this;
        }

    /**
     *
     */
    virtual ~CSSPrimitiveValue() {}

protected:

    int primitiveType;

    double doubleValue;

    DOMString stringValue;


};



/*#########################################################################
## RGBColor
#########################################################################*/

/**
 * The RGBColor interface is used to represent any RGB color value. This 
 * interface reflects the values in the underlying style property. Hence, 
 * modifications made to the CSSPrimitiveValue objects modify the style property.
 * 
 * A specified RGB color is not clipped (even if the number is outside the range 
 * 0-255 or 0%-100%). A computed RGB color is clipped depending on the device.
 * 
 * Even if a style sheet can only contain an integer for a color value, the 
 * internal storage of this integer is a float, and this can be used as a float 
 * in the specified or the computed style.
 * 
 * A color percentage value can always be converted to a number and vice versa.
 */
class RGBColor
{
public:

    /**
     * This attribute is used for the red value of the RGB color.
     */
    virtual CSSPrimitiveValue getRed()
        {
        return red;
        }

    /**
     * This attribute is used for the green value of the RGB color.
     */
    virtual CSSPrimitiveValue getGreen()
        {
        return green;
        }

    /**
     * This attribute is used for the blue value of the RGB color.
     */
    virtual CSSPrimitiveValue getBlue()
        {
        return blue;
        }

    /**
     * REPLACES: RGBColor CSSPrimitiveValue::getRGBColorValue() throw (dom::DOMException)
     */
    static RGBColor getRGBColorValue(const CSSPrimitiveValue &/*val*/)
        {
        RGBColor col;
        return col;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    RGBColor() {}

    /**
     *
     */
    RGBColor(const RGBColor &other)
        {
        assign(other);
        }

    /**
     *
     */
    RGBColor &operator=(const RGBColor &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const RGBColor &other)
        {
        red   = other.red;
        green = other.green;
        blue  = other.blue;
        }

    /**
     *
     */
    virtual ~RGBColor() {}

protected:

    CSSPrimitiveValue red;
    CSSPrimitiveValue green;
    CSSPrimitiveValue blue;
};




/*#########################################################################
## Rect
#########################################################################*/

/**
 * The Rect interface is used to represent any rect value. This interface 
 * reflects the values in the underlying style property. Hence, modifications 
 * made to the CSSPrimitiveValue objects modify the style property.
 */
class Rect
{
public:

    /**
     * This attribute is used for the top of the rect.
     */
    virtual CSSPrimitiveValue getTop()
        {
        return top;
        }

    /**
     * This attribute is used for the right of the rect.
     */
    virtual CSSPrimitiveValue getRight()
        {
        return right;
        }

    /**
     * This attribute is used for the bottom of the rect.
     */
    virtual CSSPrimitiveValue getBottom()
        {
        return bottom;
        }

    /**
     * This attribute is used for the left of the rect.
     */
    virtual CSSPrimitiveValue getLeft()
        {
        return left;
        }

    /**
     * REPLACES: Rect CSSPrimitiveValue::getRectValue() throw (dom::DOMException)
     */
    static Rect getRectValue(const CSSPrimitiveValue &/*val*/)
        {
        Rect rect;
        return rect;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    Rect() {}

    /**
     *
     */
    Rect(const Rect &other)
        {
        assign(other);
        }

    /**
     *
     */
    Rect &operator=(const Rect &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const Rect &other)
        {
        top    = other.top;
        right  = other.right;
        bottom = other.bottom;
        left   = other.left;
        }

    /**
     *
     */
    virtual ~Rect() {}

protected:

    CSSPrimitiveValue top;
    CSSPrimitiveValue right;
    CSSPrimitiveValue bottom;
    CSSPrimitiveValue left;
};






/*#########################################################################
## Counter
#########################################################################*/

/**
 * The Counter interface is used to represent any counter or counters function 
 * value. This interface reflects the values in the underlying style property.
 */
class Counter
{
public:

    /**
     * This attribute is used for the identifier of the counter.
     */
    virtual DOMString getIdentifier()
        {
        return identifier;
        }

    /**
     * This attribute is used for the style of the list.
     */
    virtual DOMString getListStyle()
        {
        return listStyle;
        }

    /**
     * This attribute is used for the separator of the nested counters.
     */
    virtual DOMString getSeparator()
        {
        return separator;
        }

    /**
     * REPLACES: Counter CSSPrimitiveValue::getCounterValue() throw (dom::DOMException)
     */
    static Counter getCounterValue(const CSSPrimitiveValue &/*val*/)
        {
        Counter counter;
        return counter;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    Counter() {}

    /**
     *
     */
    Counter(const Counter &other)
        {
        assign(other);
        }

    /**
     *
     */
    Counter &operator=(const Counter &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const Counter &other)
        {
        identifier = other.identifier;
        listStyle  = other.listStyle;
        separator  = other.separator;
        }

    /**
     *
     */
    virtual ~Counter() {}

protected:

    DOMString identifier;
    DOMString listStyle;
    DOMString separator;

};




/*#########################################################################
## ElementCSSInlineStyle
#########################################################################*/

/**
 * Inline style information attached to elements is exposed through the style 
 * attribute. This represents the contents of the STYLE attribute for HTML 
 * elements (or elements in other schemas or DTDs which use the STYLE attribute 
 * in the same way). The expectation is that an instance of the 
 * ElementCSSInlineStyle interface can be obtained by using binding-specific 
 * casting methods on an instance of the Element interface when the element 
 * supports inline CSS style informations.
 */
class ElementCSSInlineStyle
{
public:

    /**
     * The style attribute.
     */
    virtual CSSStyleDeclaration getStyle()
        {
        return style;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    ElementCSSInlineStyle() {}

    /**
     *
     */
    ElementCSSInlineStyle(const ElementCSSInlineStyle &other)
        {
        style = other.style;
        }

    /**
     *
     */
    ElementCSSInlineStyle &operator=(const ElementCSSInlineStyle &other)
        {
        style = other.style;
        return *this;
        }

    /**
     *
     */
    virtual ~ElementCSSInlineStyle() {}

protected:

    CSSStyleDeclaration style;
};






/*#########################################################################
## CSS2Properties
#########################################################################*/

/**
 * The CSS2Properties interface represents a convenience mechanism for retrieving 
 * and setting properties within a CSSStyleDeclaration. The attributes of this 
 * interface correspond to all the properties specified in CSS2. Getting an 
 * attribute of this interface is equivalent to calling the getPropertyValue 
 * method of the CSSStyleDeclaration interface. Setting an attribute of this 
 * interface is equivalent to calling the setProperty method of the 
 * CSSStyleDeclaration interface.
 * 
 * A conformant implementation of the CSS module is not required to implement the 
 * CSS2Properties interface. If an implementation does implement this interface, 
 * the expectation is that language-specific methods can be used to cast from an 
 * instance of the CSSStyleDeclaration interface to the CSS2Properties interface.
 * 
 * If an implementation does implement this interface, it is expected to 
 * understand the specific syntax of the shorthand properties, and apply their 
 * semantics; when the margin property is set, for example, the marginTop, 
 * marginRight, marginBottom and marginLeft properties are actually being set by 
 * the underlying implementation.
 * 
 * When dealing with CSS "shorthand" properties, the shorthand properties should 
 * be decomposed into their component longhand properties as appropriate, and 
 * when querying for their value, the form returned should be the shortest form 
 * exactly equivalent to the declarations made in the ruleset. However, if there 
 * is no shorthand declaration that could be added to the ruleset without 
 * changing in any way the rules already declared in the ruleset (i.e., by adding 
 * longhand rules that were previously not declared in the ruleset), then the 
 * empty string should be returned for the shorthand property.
 * 
 * For example, querying for the font property should not return "normal normal 
 * normal 14pt/normal Arial, sans-serif", when "14pt Arial, sans-serif" suffices. 
 * (The normals are initial values, and are implied by use of the longhand 
 * property.)
 * 
 * If the values for all the longhand properties that compose a particular string 
 * are the initial values, then a string consisting of all the initial values 
 * should be returned (e.g. a border-width value of "medium" should be returned 
 * as such, not as "").
 * 
 * For some shorthand properties that take missing values from other sides, such 
 * as the margin, padding, and border-[width|style|color] properties, the minimum 
 * number of sides possible should be used; i.e., "0px 10px" will be returned 
 * instead of "0px 10px 0px 10px".
 * 
 * If the value of a shorthand property can not be decomposed into its component 
 * longhand properties, as is the case for the font property with a value of 
 * "menu", querying for the values of the component longhand properties should 
 * return the empty string.
 *  */
class CSS2Properties
{
public:


    /**
     *  return the 'azimuth' property
     */
    virtual DOMString getAzimuth()
        {
        return azimuth;
        }

    /**
     *  set the 'azimuth' property
     */
    virtual void setAzimuth(const DOMString &val)
                         throw (dom::DOMException)
        {
        azimuth = val;
        }

    /**
     *  return the 'background' property
     */
    virtual DOMString getBackground()
        {
        return background;
        }

    /**
     *  set the 'background' property
     */
    virtual void setBackground(const DOMString &val)
                         throw (dom::DOMException)
        {
        background = val;
        }

    /**
     *  return the 'backgroundAttachment' property
     */
    virtual DOMString getBackgroundAttachment()
        {
        return backgroundAttachment;
        }

    /**
     *  set the 'backgroundAttachment' property
     */
    virtual void setBackgroundAttachment(const DOMString &val)
                         throw (dom::DOMException)
        {
        backgroundAttachment = val;
        }

    /**
     *  return the 'backgroundColor' property
     */
    virtual DOMString getBackgroundColor()
        {
        return backgroundColor;
        }

    /**
     *  set the 'backgroundColor' property
     */
    virtual void setBackgroundColor(const DOMString &val)
                         throw (dom::DOMException)
        {
        backgroundColor = val;
        }

    /**
     *  return the 'backgroundImage' property
     */
    virtual DOMString getBackgroundImage()
        {
        return backgroundImage;
        }

    /**
     *  set the 'backgroundImage' property
     */
    virtual void setBackgroundImage(const DOMString &val)
                         throw (dom::DOMException)
        {
        backgroundImage = val;
        }

    /**
     *  return the 'backgroundPosition' property
     */
    virtual DOMString getBackgroundPosition()
        {
        return backgroundPosition;
        }

    /**
     *  set the 'backgroundPosition' property
     */
    virtual void setBackgroundPosition(const DOMString &val)
                         throw (dom::DOMException)
        {
        backgroundPosition = val;
        }

    /**
     *  return the 'backgroundRepeat' property
     */
    virtual DOMString getBackgroundRepeat()
        {
        return backgroundRepeat;
        }

    /**
     *  set the 'backgroundRepeat' property
     */
    virtual void setBackgroundRepeat(const DOMString &val)
                         throw (dom::DOMException)
        {
        backgroundRepeat = val;
        }

    /**
     *  return the 'border' property
     */
    virtual DOMString getBorder()
        {
        return border;
        }

    /**
     *  set the 'border' property
     */
    virtual void setBorder(const DOMString &val)
                         throw (dom::DOMException)
        {
        border = val;
        }

    /**
     *  return the 'borderCollapse' property
     */
    virtual DOMString getBorderCollapse()
        {
        return borderCollapse;
        }

    /**
     *  set the 'borderCollapse' property
     */
    virtual void setBorderCollapse(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderCollapse = val;
        }

    /**
     *  return the 'borderColor' property
     */
    virtual DOMString getBorderColor()
        {
        return borderColor;
        }

    /**
     *  set the 'borderColor' property
     */
    virtual void setBorderColor(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderColor = val;
        }

    /**
     *  return the 'borderSpacing' property
     */
    virtual DOMString getBorderSpacing()
        {
        return borderSpacing;
        }

    /**
     *  set the 'borderSpacing' property
     */
    virtual void setBorderSpacing(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderSpacing = val;
        }

    /**
     *  return the 'borderStyle' property
     */
    virtual DOMString getBorderStyle()
        {
        return borderStyle;
        }

    /**
     *  set the 'borderStyle' property
     */
    virtual void setBorderStyle(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderStyle = val;
        }

    /**
     *  return the 'borderTop' property
     */
    virtual DOMString getBorderTop()
        {
        return borderTop;
        }

    /**
     *  set the 'borderTop' property
     */
    virtual void setBorderTop(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderTop = val;
        }

    /**
     *  return the 'borderRight' property
     */
    virtual DOMString getBorderRight()
        {
        return borderRight;
        }

    /**
     *  set the 'borderRight' property
     */
    virtual void setBorderRight(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderRight = val;
        }

    /**
     *  return the 'borderBottom' property
     */
    virtual DOMString getBorderBottom()
        {
        return borderBottom;
        }

    /**
     *  set the 'borderBottom' property
     */
    virtual void setBorderBottom(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderBottom = val;
        }

    /**
     *  return the 'borderLeft' property
     */
    virtual DOMString getBorderLeft()
        {
        return borderLeft;
        }

    /**
     *  set the 'borderLeft' property
     */
    virtual void setBorderLeft(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderLeft = val;
        }

    /**
     *  return the 'borderTopColor' property
     */
    virtual DOMString getBorderTopColor()
        {
        return borderTopColor;
        }

    /**
     *  set the 'borderTopColor' property
     */
    virtual void setBorderTopColor(const DOMString &val)
                         throw (dom::DOMException)
        {
    borderTopColor = val;
        }

    /**
     *  return the 'borderRightColor' property
     */
    virtual DOMString getBorderRightColor()
        {
        return borderRightColor;
        }

    /**
     *  set the 'borderRightColor' property
     */
    virtual void setBorderRightColor(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderRightColor = val;
        }

    /**
     *  return the 'borderBottomColor' property
     */
    virtual DOMString getBorderBottomColor()
        {
        return borderBottomColor;
        }

    /**
     *  set the 'borderBottomColor' property
     */
    virtual void setBorderBottomColor(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderBottomColor = val;
        }

    /**
     *  return the 'borderLeftColor' property
     */
    virtual DOMString getBorderLeftColor()
        {
        return borderLeftColor;
        }

    /**
     *  set the 'borderLeftColor' property
     */
    virtual void setBorderLeftColor(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderLeftColor = val;
        }

    /**
     *  return the 'borderTopStyle' property
     */
    virtual DOMString getBorderTopStyle()
        {
        return borderTopStyle;
        }

    /**
     *  set the 'borderTopStyle' property
     */
    virtual void setBorderTopStyle(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderTopStyle = val;
        }

    /**
     *  return the 'borderRightStyle' property
     */
    virtual DOMString getBorderRightStyle()
        {
        return borderRightStyle;
        }

    /**
     *  set the 'borderRightStyle' property
     */
    virtual void setBorderRightStyle(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderRightStyle = val;
        }

    /**
     *  return the 'borderBottomStyle' property
     */
    virtual DOMString getBorderBottomStyle()
        {
        return borderBottomStyle;
        }

    /**
     *  set the 'borderBottomStyle' property
     */
    virtual void setBorderBottomStyle(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderBottomStyle = val;
        }

    /**
     *  return the 'borderLeftStyle' property
     */
    virtual DOMString getBorderLeftStyle()
        {
        return borderLeftStyle;
        }

    /**
     *  set the 'borderLeftStyle' property
     */
    virtual void setBorderLeftStyle(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderLeftStyle = val;
        }

    /**
     *  return the 'borderTopWidth' property
     */
    virtual DOMString getBorderTopWidth()
        {
        return borderTopWidth;
        }

    /**
     *  set the 'borderTopWidth' property
     */
    virtual void setBorderTopWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderTopWidth = val;
        }

    /**
     *  return the 'borderRightWidth' property
     */
    virtual DOMString getBorderRightWidth()
        {
        return borderRightWidth;
        }

    /**
     *  set the 'borderRightWidth' property
     */
    virtual void setBorderRightWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderRightWidth = val;
        }

    /**
     *  return the 'borderBottomWidth' property
     */
    virtual DOMString getBorderBottomWidth()
        {
        return borderBottomWidth;
        }

    /**
     *  set the 'borderBottomWidth' property
     */
    virtual void setBorderBottomWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderBottomWidth = val;
        }

    /**
     *  return the 'borderLeftWidth' property
     */
    virtual DOMString getBorderLeftWidth()
        {
        return borderLeftWidth;
        }

    /**
     *  set the 'borderLeftWidth' property
     */
    virtual void setBorderLeftWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderLeftWidth = val;
        }

    /**
     *  return the 'borderWidth' property
     */
    virtual DOMString getBorderWidth()
        {
        return borderWidth;
        }

    /**
     *  set the 'borderWidth' property
     */
    virtual void setBorderWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        borderWidth = val;
        }

    /**
     *  return the 'bottom' property
     */
    virtual DOMString getBottom()
        {
        return bottom;
        }

    /**
     *  set the 'bottom' property
     */
    virtual void setBottom(const DOMString &val)
                         throw (dom::DOMException)
        {
        bottom = val;
        }

    /**
     *  return the 'captionSide' property
     */
    virtual DOMString getCaptionSide()
        {
        return captionSide;
        }

    /**
     *  set the 'captionSide' property
     */
    virtual void setCaptionSide(const DOMString &val)
                         throw (dom::DOMException)
        {
        captionSide = val;
        }

    /**
     *  return the 'clear' property
     */
    virtual DOMString getClear()
        {
        return clear;
        }

    /**
     *  set the 'clear' property
     */
    virtual void setClear(const DOMString &val)
                         throw (dom::DOMException)
        {
        clear = val;
        }

    /**
     *  return the 'clip' property
     */
    virtual DOMString getClip()
        {
        return clip;
        }

    /**
     *  set the 'clip' property
     */
    virtual void setClip(const DOMString &val)
                         throw (dom::DOMException)
        {
        clip = val;
        }

    /**
     *  return the 'color' property
     */
    virtual DOMString getColor()
        {
        return color;
        }

    /**
     *  set the 'color' property
     */
    virtual void setColor(const DOMString &val)
                         throw (dom::DOMException)
        {
        color = val;
        }

    /**
     *  return the 'content' property
     */
    virtual DOMString getContent()
        {
        return content;
        }

    /**
     *  set the 'content' property
     */
    virtual void setContent(const DOMString &val)
                         throw (dom::DOMException)
        {
        content = val;
        }

    /**
     *  return the 'counterIncrement' property
     */
    virtual DOMString getCounterIncrement()
        {
        return counterIncrement;
        }

    /**
     *  set the 'counterIncrement' property
     */
    virtual void setCounterIncrement(const DOMString &val)
                         throw (dom::DOMException)
        {
        counterIncrement = val;
        }

    /**
     *  return the 'counterReset' property
     */
    virtual DOMString getCounterReset()
        {
        return counterReset;
        }

    /**
     *  set the 'counterReset' property
     */
    virtual void setCounterReset(const DOMString &val)
                         throw (dom::DOMException)
        {
        counterReset = val;
        }

    /**
     *  return the 'cue' property
     */
    virtual DOMString getCue()
        {
        return cue;
        }

    /**
     *  set the 'cue' property
     */
    virtual void setCue(const DOMString &val)
                         throw (dom::DOMException)
        {
        cue = val;
        }

    /**
     *  return the 'cueAfter' property
     */
    virtual DOMString getCueAfter()
        {
        return cueAfter;
        }

    /**
     *  set the 'cueAfter' property
     */
    virtual void setCueAfter(const DOMString &val)
                         throw (dom::DOMException)
        {
        cueAfter = val;
        }

    /**
     *  return the 'cueBefore' property
     */
    virtual DOMString getCueBefore()
        {
        return cueBefore;
        }

    /**
     *  set the 'cueBefore' property
     */
    virtual void setCueBefore(const DOMString &val)
                         throw (dom::DOMException)
        {
        cueBefore = val;
        }

    /**
     *  return the 'cursor' property
     */
    virtual DOMString getCursor()
        {
        return cursor;
        }

    /**
     *  set the 'cursor' property
     */
    virtual void setCursor(const DOMString &val)
                         throw (dom::DOMException)
        {
        cursor = val;
        }

    /**
     *  return the 'direction' property
     */
    virtual DOMString getDirection()
        {
        return direction;
        }

    /**
     *  set the 'direction' property
     */
    virtual void setDirection(const DOMString &val)
                         throw (dom::DOMException)
        {
        direction = val;
        }

    /**
     *  return the 'display' property
     */
    virtual DOMString getDisplay()
        {
        return display;
        }

    /**
     *  set the 'display' property
     */
    virtual void setDisplay(const DOMString &val)
                         throw (dom::DOMException)
        {
        display = val;
        }

    /**
     *  return the 'elevation' property
     */
    virtual DOMString getElevation()
        {
        return elevation;
        }

    /**
     *  set the 'elevation' property
     */
    virtual void setElevation(const DOMString &val)
                         throw (dom::DOMException)
        {
        elevation = val;
        }

    /**
     *  return the 'emptyCells' property
     */
    virtual DOMString getEmptyCells()
        {
        return emptyCells;
        }

    /**
     *  set the 'emptyCells' property
     */
    virtual void setEmptyCells(const DOMString &val)
                         throw (dom::DOMException)
        {
        emptyCells = val;
        }

    /**
     *  return the 'cssFloat' property
     */
    virtual DOMString getCssFloat()
        {
        return cssFloat;
        }

    /**
     *  set the 'cssFloat' property
     */
    virtual void setCssFloat(const DOMString &val)
                         throw (dom::DOMException)
        {
        cssFloat = val;
        }

    /**
     *  return the 'font' property
     */
    virtual DOMString getFont()
        {
        return font;
        }

    /**
     *  set the 'font' property
     */
    virtual void setFont(const DOMString &val)
                         throw (dom::DOMException)
        {
        font = val;
        }

    /**
     *  return the 'fontFamily' property
     */
    virtual DOMString getFontFamily()
        {
        return fontFamily;
        }

    /**
     *  set the 'fontFamily' property
     */
    virtual void setFontFamily(const DOMString &val)
                         throw (dom::DOMException)
        {
        fontFamily = val;
        }

    /**
     *  return the 'fontSize' property
     */
    virtual DOMString getFontSize()
        {
        return fontSize;
        }

    /**
     *  set the 'fontSize' property
     */
    virtual void setFontSize(const DOMString &val)
                         throw (dom::DOMException)
        {
        fontSize = val;
        }

    /**
     *  return the 'fontSizeAdjust' property
     */
    virtual DOMString getFontSizeAdjust()
        {
        return fontSizeAdjust;
        }

    /**
     *  set the 'fontSizeAdjust' property
     */
    virtual void setFontSizeAdjust(const DOMString &val)
                         throw (dom::DOMException)
        {
        fontSizeAdjust = val;
        }

    /**
     *  return the 'fontStretch' property
     */
    virtual DOMString getFontStretch()
        {
        return fontStretch;
        }

    /**
     *  set the 'fontStretch' property
     */
    virtual void setFontStretch(const DOMString &val)
                         throw (dom::DOMException)
        {
        fontStretch = val;
        }

    /**
     *  return the 'fontStyle' property
     */
    virtual DOMString getFontStyle()
        {
        return fontStyle;
        }

    /**
     *  set the 'fontStyle' property
     */
    virtual void setFontStyle(const DOMString &val)
                         throw (dom::DOMException)
        {
        fontStyle = val;
        }

    /**
     *  return the 'fontVariant' property
     */
    virtual DOMString getFontVariant()
        {
        return fontVariant;
        }

    /**
     *  set the 'fontVariant' property
     */
    virtual void setFontVariant(const DOMString &val)
                         throw (dom::DOMException)
        {
        fontVariant = val;
        }

    /**
     *  return the 'fontWeight' property
     */
    virtual DOMString getFontWeight()
        {
        return fontWeight;
        }

    /**
     *  set the 'fontWeight' property
     */
    virtual void setFontWeight(const DOMString &val)
                         throw (dom::DOMException)
        {
        fontWeight = val;
        }

    /**
     *  return the 'height' property
     */
    virtual DOMString getHeight()
        {
        return height;
        }

    /**
     *  set the 'height' property
     */
    virtual void setHeight(const DOMString &val)
                         throw (dom::DOMException)
        {
        height = val;
        }

    /**
     *  return the 'left' property
     */
    virtual DOMString getLeft()
        {
        return left;
        }

    /**
     *  set the 'left' property
     */
    virtual void setLeft(const DOMString &val)
                         throw (dom::DOMException)
        {
        left = val;
        }

    /**
     *  return the 'letterSpacing' property
     */
    virtual DOMString getLetterSpacing()
        {
        return letterSpacing;
        }

    /**
     *  set the 'letterSpacing' property
     */
    virtual void setLetterSpacing(const DOMString &val)
                         throw (dom::DOMException)
        {
        letterSpacing = val;
        }

    /**
     *  return the 'lineHeight' property
     */
    virtual DOMString getLineHeight()
        {
        return lineHeight;
        }

    /**
     *  set the 'lineHeight' property
     */
    virtual void setLineHeight(const DOMString &val)
                         throw (dom::DOMException)
        {
        lineHeight = val;
        }

    /**
     *  return the 'listStyle' property
     */
    virtual DOMString getListStyle()
        {
        return listStyle;
        }

    /**
     *  set the 'listStyle' property
     */
    virtual void setListStyle(const DOMString &val)
                         throw (dom::DOMException)
        {
        listStyle = val;
        }

    /**
     *  return the 'listStyleImage' property
     */
    virtual DOMString getListStyleImage()
        {
        return listStyleImage;
        }

    /**
     *  set the 'listStyleImage' property
     */
    virtual void setListStyleImage(const DOMString &val)
                         throw (dom::DOMException)
        {
        listStyleImage = val;
        }

    /**
     *  return the 'listStylePosition' property
     */
    virtual DOMString getListStylePosition()
        {
        return listStylePosition;
        }

    /**
     *  set the 'listStylePosition' property
     */
    virtual void setListStylePosition(const DOMString &val)
                         throw (dom::DOMException)
        {
        listStylePosition = val;
        }

    /**
     *  return the 'listStyleType' property
     */
    virtual DOMString getListStyleType()
        {
        return listStyleType;
        }

    /**
     *  set the 'listStyleType' property
     */
    virtual void setListStyleType(const DOMString &val)
                         throw (dom::DOMException)
        {
        listStyleType = val;
        }

    /**
     *  return the 'margin' property
     */
    virtual DOMString getMargin()
        {
        return margin;
        }

    /**
     *  set the 'margin' property
     */
    virtual void setMargin(const DOMString &val)
                         throw (dom::DOMException)
        {
        margin = val;
        }

    /**
     *  return the 'marginTop' property
     */
    virtual DOMString getMarginTop()
        {
        return marginTop;
        }

    /**
     *  set the 'marginTop' property
     */
    virtual void setMarginTop(const DOMString &val)
                         throw (dom::DOMException)
        {
        marginTop = val;
        }

    /**
     *  return the 'marginRight' property
     */
    virtual DOMString getMarginRight()
        {
        return marginRight;
        }

    /**
     *  set the 'marginRight' property
     */
    virtual void setMarginRight(const DOMString &val)
                         throw (dom::DOMException)
        {
        marginRight = val;
        }

    /**
     *  return the 'marginBottom' property
     */
    virtual DOMString getMarginBottom()
        {
        return marginBottom;
        }

    /**
     *  set the 'marginBottom' property
     */
    virtual void setMarginBottom(const DOMString &val)
                         throw (dom::DOMException)
        {
        marginBottom = val;
        }

    /**
     *  return the 'marginLeft' property
     */
    virtual DOMString getMarginLeft()
        {
        return marginLeft;
        }

    /**
     *  set the 'marginLeft' property
     */
    virtual void setMarginLeft(const DOMString &val)
                         throw (dom::DOMException)
        {
        marginLeft = val;
        }

    /**
     *  return the 'markerOffset' property
     */
    virtual DOMString getMarkerOffset()
        {
        return markerOffset;
        }

    /**
     *  set the 'markerOffset' property
     */
    virtual void setMarkerOffset(const DOMString &val)
                         throw (dom::DOMException)
        {
        markerOffset = val;
        }

    /**
     *  return the 'marks' property
     */
    virtual DOMString getMarks()
        {
        return marks;
        }

    /**
     *  set the 'marks' property
     */
    virtual void setMarks(const DOMString &val)
                         throw (dom::DOMException)
        {
        marks = val;
        }

    /**
     *  return the 'maxHeight' property
     */
    virtual DOMString getMaxHeight()
        {
        return maxHeight;
        }

    /**
     *  set the 'maxHeight' property
     */
    virtual void setMaxHeight(const DOMString &val)
                         throw (dom::DOMException)
        {
        maxHeight = val;
        }

    /**
     *  return the 'maxWidth' property
     */
    virtual DOMString getMaxWidth()
        {
        return maxWidth;
        }

    /**
     *  set the 'maxWidth' property
     */
    virtual void setMaxWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        maxWidth = val;
        }

    /**
     *  return the 'minHeight' property
     */
    virtual DOMString getMinHeight()
        {
        return minHeight;
        }

    /**
     *  set the 'minHeight' property
     */
    virtual void setMinHeight(const DOMString &val)
                         throw (dom::DOMException)
        {
        minHeight = val;
        }

    /**
     *  return the 'minWidth' property
     */
    virtual DOMString getMinWidth()
        {
        return minWidth;
        }

    /**
     *  set the 'minWidth' property
     */
    virtual void setMinWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        minWidth = val;
        }

    /**
     *  return the 'orphans' property
     */
    virtual DOMString getOrphans()
        {
        return orphans;
        }

    /**
     *  set the 'orphans' property
     */
    virtual void setOrphans(const DOMString &val)
                         throw (dom::DOMException)
        {
        orphans = val;
        }

    /**
     *  return the 'outline' property
     */
    virtual DOMString getOutline()
        {
        return outline;
        }

    /**
     *  set the 'outline' property
     */
    virtual void setOutline(const DOMString &val)
                         throw (dom::DOMException)
        {
        outline = val;
        }

    /**
     *  return the 'outlineColor' property
     */
    virtual DOMString getOutlineColor()
        {
        return outlineColor;
        }

    /**
     *  set the 'outlineColor' property
     */
    virtual void setOutlineColor(const DOMString &val)
                         throw (dom::DOMException)
        {
        outlineColor = val;
        }

    /**
     *  return the 'outlineStyle' property
     */
    virtual DOMString getOutlineStyle()
        {
        return outlineStyle;
        }

    /**
     *  set the 'outlineStyle' property
     */
    virtual void setOutlineStyle(const DOMString &val)
                         throw (dom::DOMException)
        {
        outlineStyle = val;
        }

    /**
     *  return the 'outlineWidth' property
     */
    virtual DOMString getOutlineWidth()
        {
        return outlineWidth;
        }

    /**
     *  set the 'outlineWidth' property
     */
    virtual void setOutlineWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        outlineWidth = val;
        }

    /**
     *  return the 'overflow' property
     */
    virtual DOMString getOverflow()
        {
        return overflow;
        }

    /**
     *  set the 'overflow' property
     */
    virtual void setOverflow(const DOMString &val)
                         throw (dom::DOMException)
        {
        overflow = val;
        }

    /**
     *  return the 'padding' property
     */
    virtual DOMString getPadding()
        {
        return padding;
        }

    /**
     *  set the 'padding' property
     */
    virtual void setPadding(const DOMString &val)
                         throw (dom::DOMException)
        {
        padding = val;
        }

    /**
     *  return the 'paddingTop' property
     */
    virtual DOMString getPaddingTop()
        {
        return paddingTop;
        }

    /**
     *  set the 'paddingTop' property
     */
    virtual void setPaddingTop(const DOMString &val)
                         throw (dom::DOMException)
        {
        paddingTop = val;
        }

    /**
     *  return the 'paddingRight' property
     */
    virtual DOMString getPaddingRight()
        {
        return paddingRight;
        }

    /**
     *  set the 'paddingRight' property
     */
    virtual void setPaddingRight(const DOMString &val)
                         throw (dom::DOMException)
        {
        paddingRight = val;
        }

    /**
     *  return the 'paddingBottom' property
     */
    virtual DOMString getPaddingBottom()
        {
        return paddingBottom;
        }

    /**
     *  set the 'paddingBottom' property
     */
    virtual void setPaddingBottom(const DOMString &val)
                         throw (dom::DOMException)
        {
        paddingBottom = val;
        }

    /**
     *  return the 'paddingLeft' property
     */
    virtual DOMString getPaddingLeft()
        {
        return paddingLeft;
        }

    /**
     *  set the 'paddingLeft' property
     */
    virtual void setPaddingLeft(const DOMString &val)
                         throw (dom::DOMException)
        {
        paddingLeft = val;
        }

    /**
     *  return the 'page' property
     */
    virtual DOMString getPage()
        {
        return page;
        }

    /**
     *  set the 'page' property
     */
    virtual void setPage(const DOMString &val)
                         throw (dom::DOMException)
        {
        page = val;
        }

    /**
     *  return the 'pageBreakAfter' property
     */
    virtual DOMString getPageBreakAfter()
        {
        return pageBreakAfter;
        }

    /**
     *  set the 'pageBreakAfter' property
     */
    virtual void setPageBreakAfter(const DOMString &val)
                         throw (dom::DOMException)
        {
        pageBreakAfter = val;
        }

    /**
     *  return the 'pageBreakBefore' property
     */
    virtual DOMString getPageBreakBefore()
        {
        return pageBreakBefore;
        }

    /**
     *  set the 'pageBreakBefore' property
     */
    virtual void setPageBreakBefore(const DOMString &val)
                         throw (dom::DOMException)
        {
        pageBreakBefore = val;
        }

    /**
     *  return the 'pageBreakInside' property
     */
    virtual DOMString getPageBreakInside()
        {
        return pageBreakInside;
        }

    /**
     *  set the 'pageBreakInside' property
     */
    virtual void setPageBreakInside(const DOMString &val)
                         throw (dom::DOMException)
        {
        pageBreakInside = val;
        }

    /**
     *  return the 'pause' property
     */
    virtual DOMString getPause()
        {
        return pause;
        }

    /**
     *  set the 'pause' property
     */
    virtual void setPause(const DOMString &val)
                         throw (dom::DOMException)
        {
        pause = val;
        }

    /**
     *  return the 'pauseAfter' property
     */
    virtual DOMString getPauseAfter()
        {
        return pauseAfter;
        }

    /**
     *  set the 'pauseAfter' property
     */
    virtual void setPauseAfter(const DOMString &val)
                         throw (dom::DOMException)
        {
        pauseAfter = val;
        }

    /**
     *  return the 'pauseBefore' property
     */
    virtual DOMString getPauseBefore()
        {
        return pauseBefore;
        }

    /**
     *  set the 'pauseBefore' property
     */
    virtual void setPauseBefore(const DOMString &val)
                         throw (dom::DOMException)
        {
        pauseBefore = val;
        }

    /**
     *  return the 'pitch' property
     */
    virtual DOMString getPitch()
        {
        return pitch;
        }

    /**
     *  set the 'pitch' property
     */
    virtual void setPitch(const DOMString &val)
                         throw (dom::DOMException)
        {
        pitch = val;
        }

    /**
     *  return the 'pitchRange' property
     */
    virtual DOMString getPitchRange()
        {
        return pitchRange;
        }

    /**
     *  set the 'pitchRange' property
     */
    virtual void setPitchRange(const DOMString &val)
                         throw (dom::DOMException)
        {
        pitchRange = val;
        }

    /**
     *  return the 'playDuring' property
     */
    virtual DOMString getPlayDuring()
        {
        return playDuring;
        }

    /**
     *  set the 'playDuring' property
     */
    virtual void setPlayDuring(const DOMString &val)
                         throw (dom::DOMException)
        {
        playDuring = val;
        }

    /**
     *  return the 'position' property
     */
    virtual DOMString getPosition()
        {
        return position;
        }

    /**
     *  set the 'position' property
     */
    virtual void setPosition(const DOMString &val)
                         throw (dom::DOMException)
        {
        position = val;
        }

    /**
     *  return the 'quotes' property
     */
    virtual DOMString getQuotes()
        {
        return quotes;
        }

    /**
     *  set the 'quotes' property
     */
    virtual void setQuotes(const DOMString &val)
                         throw (dom::DOMException)
        {
        quotes = val;
        }

    /**
     *  return the 'richness' property
     */
    virtual DOMString getRichness()
        {
        return richness;
        }

    /**
     *  set the 'richness' property
     */
    virtual void setRichness(const DOMString &val)
                         throw (dom::DOMException)
        {
        richness = val;
        }

    /**
     *  return the 'right' property
     */
    virtual DOMString getRight()
        {
        return right;
        }

    /**
     *  set the 'right' property
     */
    virtual void setRight(const DOMString &val)
                         throw (dom::DOMException)
        {
        right = val;
        }

    /**
     *  return the 'size' property
     */
    virtual DOMString getSize()
        {
        return size;
        }

    /**
     *  set the 'size' property
     */
    virtual void setSize(const DOMString &val)
                         throw (dom::DOMException)
        {
        size = val;
        }

    /**
     *  return the 'speak' property
     */
    virtual DOMString getSpeak()
        {
        return speak;
        }

    /**
     *  set the 'speak' property
     */
    virtual void setSpeak(const DOMString &val)
                         throw (dom::DOMException)
        {
        speak = val;
        }

    /**
     *  return the 'speakHeader' property
     */
    virtual DOMString getSpeakHeader()
        {
        return speakHeader;
        }

    /**
     *  set the 'speakHeader' property
     */
    virtual void setSpeakHeader(const DOMString &val)
                         throw (dom::DOMException)
        {
        speakHeader = val;
        }

    /**
     *  return the 'speakNumeral' property
     */
    virtual DOMString getSpeakNumeral()
        {
        return speakNumeral;
        }

    /**
     *  set the 'speakNumeral' property
     */
    virtual void setSpeakNumeral(const DOMString &val)
                         throw (dom::DOMException)
        {
        speakNumeral = val;
        }

    /**
     *  return the 'speakPunctuation' property
     */
    virtual DOMString getSpeakPunctuation()
        {
        return speakPunctuation;
        }

    /**
     *  set the 'speakPunctuation' property
     */
    virtual void setSpeakPunctuation(const DOMString &val)
                         throw (dom::DOMException)
        {
        speakPunctuation = val;
        }

    /**
     *  return the 'speechRate' property
     */
    virtual DOMString getSpeechRate()
        {
        return speechRate;
        }

    /**
     *  set the 'speechRate' property
     */
    virtual void setSpeechRate(const DOMString &val)
                         throw (dom::DOMException)
        {
        speechRate = val;
        }

    /**
     *  return the 'stress' property
     */
    virtual DOMString getStress()
        {
        return stress;
        }

    /**
     *  set the 'stress' property
     */
    virtual void setStress(const DOMString &val)
                         throw (dom::DOMException)
        {
        stress = val;
        }

    /**
     *  return the 'tableLayout' property
     */
    virtual DOMString getTableLayout()
        {
        return tableLayout;
        }

    /**
     *  set the 'tableLayout' property
     */
    virtual void setTableLayout(const DOMString &val)
                         throw (dom::DOMException)
        {
        tableLayout = val;
        }

    /**
     *  return the 'textAlign' property
     */
    virtual DOMString getTextAlign()
        {
        return textAlign;
        }

    /**
     *  set the 'textAlign' property
     */
    virtual void setTextAlign(const DOMString &val)
                         throw (dom::DOMException)
        {
        textAlign = val;
        }

    /**
     *  return the 'textDecoration' property
     */
    virtual DOMString getTextDecoration()
        {
        return textDecoration;
        }

    /**
     *  set the 'textDecoration' property
     */
    virtual void setTextDecoration(const DOMString &val)
                         throw (dom::DOMException)
        {
        textDecoration = val;
        }

    /**
     *  return the 'textIndent' property
     */
    virtual DOMString getTextIndent()
        {
        return textIndent;
        }

    /**
     *  set the 'textIndent' property
     */
    virtual void setTextIndent(const DOMString &val)
                         throw (dom::DOMException)
        {
        textIndent = val;
        }

    /**
     *  return the 'textShadow' property
     */
    virtual DOMString getTextShadow()
        {
        return textShadow;
        }

    /**
     *  set the 'textShadow' property
     */
    virtual void setTextShadow(const DOMString &val)
                         throw (dom::DOMException)
        {
        textShadow = val;
        }

    /**
     *  return the 'textTransform' property
     */
    virtual DOMString getTextTransform()
        {
        return textTransform;
        }

    /**
     *  set the 'textTransform' property
     */
    virtual void setTextTransform(const DOMString &val)
                         throw (dom::DOMException)
        {
        textTransform = val;
        }

    /**
     *  return the 'top' property
     */
    virtual DOMString getTop()
        {
        return top;
        }

    /**
     *  set the 'top' property
     */
    virtual void setTop(const DOMString &val)
                         throw (dom::DOMException)
        {
        top = val;
        }

    /**
     *  return the 'unicodeBidi' property
     */
    virtual DOMString getUnicodeBidi()
        {
        return unicodeBidi;
        }

    /**
     *  set the 'unicodeBidi' property
     */
    virtual void setUnicodeBidi(const DOMString &val)
                         throw (dom::DOMException)
        {
        unicodeBidi = val;
        }

    /**
     *  return the 'verticalAlign' property
     */
    virtual DOMString getVerticalAlign()
        {
        return verticalAlign;
        }

    /**
     *  set the 'verticalAlign' property
     */
    virtual void setVerticalAlign(const DOMString &val)
                         throw (dom::DOMException)
        {
        verticalAlign = val;
        }

    /**
     *  return the 'visibility' property
     */
    virtual DOMString getVisibility()
        {
        return visibility;
        }

    /**
     *  set the 'visibility' property
     */
    virtual void setVisibility(const DOMString &val)
                         throw (dom::DOMException)
        {
        visibility = val;
        }

    /**
     *  return the 'voiceFamily' property
     */
    virtual DOMString getVoiceFamily()
        {
        return voiceFamily;
        }

    /**
     *  set the 'voiceFamily' property
     */
    virtual void setVoiceFamily(const DOMString &val)
                         throw (dom::DOMException)
        {
        voiceFamily = val;
        }

    /**
     *  return the 'volume' property
     */
    virtual DOMString getVolume()
        {
        return volume;
        }

    /**
     *  set the 'volume' property
     */
    virtual void setVolume(const DOMString &val)
                         throw (dom::DOMException)
        {
        volume = val;
        }

    /**
     *  return the 'whiteSpace' property
     */
    virtual DOMString getWhiteSpace()
        {
        return whiteSpace;
        }

    /**
     *  set the 'whiteSpace' property
     */
    virtual void setWhiteSpace(const DOMString &val)
                         throw (dom::DOMException)
        {
        whiteSpace = val;
        }

    /**
     *  return the 'widows' property
     */
    virtual DOMString getWidows()
        {
        return widows;
        }

    /**
     *  set the 'widows' property
     */
    virtual void setWidows(const DOMString &val)
                         throw (dom::DOMException)
        {
        widows = val;
        }

    /**
     *  return the 'width' property
     */
    virtual DOMString getWidth()
        {
        return width;
        }

    /**
     *  set the 'width' property
     */
    virtual void setWidth(const DOMString &val)
                         throw (dom::DOMException)
        {
        width = val;
        }

    /**
     *  return the 'wordSpacing' property
     */
    virtual DOMString getWordSpacing()
        {
        return wordSpacing;
        }

    /**
     *  set the 'wordSpacing' property
     */
    virtual void setWordSpacing(const DOMString &val)
                         throw (dom::DOMException)
        {
        wordSpacing = val;
        }

    /**
     *  return the 'zIndex' property
     */
    virtual DOMString getZIndex()
        {
        return zIndex;
        }

    /**
     *  set the 'zIndex' property
     */
    virtual void setZIndex(const DOMString &val)
                         throw (dom::DOMException)
        {
        zIndex = val;
        }



    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    CSS2Properties()
        {
        }

    /**
     *
     */
    CSS2Properties(const CSS2Properties &other)
        {
        assign(other);
        }

    /**
     *
     */
    CSS2Properties &operator=(const CSS2Properties &other)
        {
        assign(other);
        return *this;
        }

    /**
     *
     */
    void assign(const CSS2Properties &other)
        {
        azimuth              = other.azimuth;
        background           = other.background;
        backgroundAttachment = other.backgroundAttachment;
        backgroundColor      = other.backgroundColor;
        backgroundImage      = other.backgroundImage;
        backgroundPosition   = other.backgroundPosition;
        backgroundRepeat     = other.backgroundRepeat;
        border               = other.border;
        borderCollapse       = other.borderCollapse;
        borderColor          = other.borderColor;
        borderSpacing        = other.borderSpacing;
        borderStyle          = other.borderStyle;
        borderTop            = other.borderTop;
        borderRight          = other.borderRight;
        borderBottom         = other.borderBottom;
        borderLeft           = other.borderLeft;
        borderTopColor       = other.borderTopColor;
        borderRightColor     = other.borderRightColor;
        borderBottomColor    = other.borderBottomColor;
        borderLeftColor      = other.borderLeftColor;
        borderTopStyle       = other.borderTopStyle;
        borderRightStyle     = other.borderRightStyle;
        borderBottomStyle    = other.borderBottomStyle;
        borderLeftStyle      = other.borderLeftStyle;
        borderTopWidth       = other.borderTopWidth;
        borderRightWidth     = other.borderRightWidth;
        borderBottomWidth    = other.borderBottomWidth;
        borderLeftWidth      = other.borderLeftWidth;
        borderWidth          = other.borderWidth;
        bottom               = other.bottom;
        captionSide          = other.captionSide;
        clear                = other.clear;
        clip                 = other.clip;
        color                = other.color;
        content              = other.content;
        counterIncrement     = other.counterIncrement;
        counterReset         = other.counterReset;
        cue                  = other.cue;
        cueAfter             = other.cueAfter;
        cueBefore            = other.cueBefore;
        cursor               = other.cursor;
        direction            = other.direction;
        display              = other.display;
        elevation            = other.elevation;
        emptyCells           = other.emptyCells;
        cssFloat             = other.cssFloat;
        font                 = other.font;
        fontFamily           = other.fontFamily;
        fontSize             = other.fontSize;
        fontSizeAdjust       = other.fontSizeAdjust;
        fontStretch          = other.fontStretch;
        fontStyle            = other.fontStyle;
        fontVariant          = other.fontVariant;
        fontWeight           = other.fontWeight;
        height               = other.height;
        left                 = other.left;
        letterSpacing        = other.letterSpacing;
        lineHeight           = other.lineHeight;
        listStyle            = other.listStyle;
        listStyleImage       = other.listStyleImage;
        listStylePosition    = other.listStylePosition;
        listStyleType        = other.listStyleType;
        margin               = other.margin;
        marginTop            = other.marginTop;
        marginRight          = other.marginRight;
        marginBottom         = other.marginBottom;
        marginLeft           = other.marginLeft;
        markerOffset         = other.markerOffset;
        marks                = other.marks;
        maxHeight            = other.maxHeight;
        maxWidth             = other.maxWidth;
        minHeight            = other.minHeight;
        minWidth             = other.minWidth;
        orphans              = other.orphans;
        outline              = other.outline;
        outlineColor         = other.outlineColor;
        outlineStyle         = other.outlineStyle;
        outlineWidth         = other.outlineWidth;
        overflow             = other.overflow;
        padding              = other.padding;
        paddingTop           = other.paddingTop;
        paddingRight         = other.paddingRight;
        paddingBottom        = other.paddingBottom;
        paddingLeft          = other.paddingLeft;
        page                 = other.page;
        pageBreakAfter       = other.pageBreakAfter;
        pageBreakBefore      = other.pageBreakBefore;
        pageBreakInside      = other.pageBreakInside;
        pause                = other.pause;
        pauseAfter           = other.pauseAfter;
        pauseBefore          = other.pauseBefore;
        pitch                = other.pitch;
        pitchRange           = other.pitchRange;
        playDuring           = other.playDuring;
        position             = other.position;
        quotes               = other.quotes;
        richness             = other.richness;
        right                = other.right;
        size                 = other.size;
        speak                = other.speak;
        speakHeader          = other.speakHeader;
        speakNumeral         = other.speakNumeral;
        speakPunctuation     = other.speakPunctuation;
        speechRate           = other.speechRate;
        stress               = other.stress;
        tableLayout          = other.tableLayout;
        textAlign            = other.textAlign;
        textDecoration       = other.textDecoration;
        textIndent           = other.textIndent;
        textShadow           = other.textShadow;
        textTransform        = other.textTransform;
        top                  = other.top;
        unicodeBidi          = other.unicodeBidi;
        verticalAlign        = other.verticalAlign;
        visibility           = other.visibility;
        voiceFamily          = other.voiceFamily;
        volume               = other.volume;
        whiteSpace           = other.whiteSpace;
        widows               = other.widows;
        width                = other.width;
        wordSpacing          = other.wordSpacing;
        zIndex               = other.zIndex;
        }

    /**
     *
     */
    virtual ~CSS2Properties() {}

protected:

    //######################
    //# P R O P E R T I E S
    //######################
    DOMString azimuth;
    DOMString background;
    DOMString backgroundAttachment;
    DOMString backgroundColor;
    DOMString backgroundImage;
    DOMString backgroundPosition;
    DOMString backgroundRepeat;
    DOMString border;
    DOMString borderCollapse;
    DOMString borderColor;
    DOMString borderSpacing;
    DOMString borderStyle;
    DOMString borderTop;
    DOMString borderRight;
    DOMString borderBottom;
    DOMString borderLeft;
    DOMString borderTopColor;
    DOMString borderRightColor;
    DOMString borderBottomColor;
    DOMString borderLeftColor;
    DOMString borderTopStyle;
    DOMString borderRightStyle;
    DOMString borderBottomStyle;
    DOMString borderLeftStyle;
    DOMString borderTopWidth;
    DOMString borderRightWidth;
    DOMString borderBottomWidth;
    DOMString borderLeftWidth;
    DOMString borderWidth;
    DOMString bottom;
    DOMString captionSide;
    DOMString clear;
    DOMString clip;
    DOMString color;
    DOMString content;
    DOMString counterIncrement;
    DOMString counterReset;
    DOMString cue;
    DOMString cueAfter;
    DOMString cueBefore;
    DOMString cursor;
    DOMString direction;
    DOMString display;
    DOMString elevation;
    DOMString emptyCells;
    DOMString cssFloat;
    DOMString font;
    DOMString fontFamily;
    DOMString fontSize;
    DOMString fontSizeAdjust;
    DOMString fontStretch;
    DOMString fontStyle;
    DOMString fontVariant;
    DOMString fontWeight;
    DOMString height;
    DOMString left;
    DOMString letterSpacing;
    DOMString lineHeight;
    DOMString listStyle;
    DOMString listStyleImage;
    DOMString listStylePosition;
    DOMString listStyleType;
    DOMString margin;
    DOMString marginTop;
    DOMString marginRight;
    DOMString marginBottom;
    DOMString marginLeft;
    DOMString markerOffset;
    DOMString marks;
    DOMString maxHeight;
    DOMString maxWidth;
    DOMString minHeight;
    DOMString minWidth;
    DOMString orphans;
    DOMString outline;
    DOMString outlineColor;
    DOMString outlineStyle;
    DOMString outlineWidth;
    DOMString overflow;
    DOMString padding;
    DOMString paddingTop;
    DOMString paddingRight;
    DOMString paddingBottom;
    DOMString paddingLeft;
    DOMString page;
    DOMString pageBreakAfter;
    DOMString pageBreakBefore;
    DOMString pageBreakInside;
    DOMString pause;
    DOMString pauseAfter;
    DOMString pauseBefore;
    DOMString pitch;
    DOMString pitchRange;
    DOMString playDuring;
    DOMString position;
    DOMString quotes;
    DOMString richness;
    DOMString right;
    DOMString size;
    DOMString speak;
    DOMString speakHeader;
    DOMString speakNumeral;
    DOMString speakPunctuation;
    DOMString speechRate;
    DOMString stress;
    DOMString tableLayout;
    DOMString textAlign;
    DOMString textDecoration;
    DOMString textIndent;
    DOMString textShadow;
    DOMString textTransform;
    DOMString top;
    DOMString unicodeBidi;
    DOMString verticalAlign;
    DOMString visibility;
    DOMString voiceFamily;
    DOMString volume;
    DOMString whiteSpace;
    DOMString widows;
    DOMString width;
    DOMString wordSpacing;
    DOMString zIndex;


};








/*#########################################################################
## ViewCSS
#########################################################################*/

/**
 * This interface represents a CSS view. The getComputedStyle method provides a 
 * read only access to the computed values of an element.
 * 
 * The expectation is that an instance of the ViewCSS interface can be obtained 
 * by using binding-specific casting methods on an instance of the AbstractView 
 * interface.
 * 
 * Since a computed style is related to an Element node, if this element is 
 * removed from the document, the associated CSSStyleDeclaration and CSSValue 
 * related to this declaration are no longer valid.
 */
class ViewCSS : virtual public views::AbstractView
{
public:

    /**
     * This method is used to get the computed style as it is defined in [CSS2]. 
     */
    virtual CSSStyleDeclaration getComputedStyle(const Element &/*elt*/,
                                                 const DOMString &/*pseudoElt*/)
        {
        CSSStyleDeclaration style;
        return style;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    ViewCSS() : views::AbstractView()
       {
       }

    /**
     *
     */
    ViewCSS(const ViewCSS &other) : views::AbstractView(other)
       {
       }

    /**
     *
     */
    ViewCSS &operator=(const ViewCSS &/*other*/)
       {
       return *this;
       }

    /**
     *
     */
    virtual ~ViewCSS() {}
};





/*#########################################################################
## DocumentCSS
#########################################################################*/

/**
 * This interface represents a document with a CSS view.
 * 
 * The getOverrideStyle method provides a mechanism through which a DOM author 
 * could effect immediate change to the style of an element without modifying the 
 * explicitly linked style sheets of a document or the inline style of elements 
 * in the style sheets. This style sheet comes after the author style sheet in 
 * the cascade algorithm and is called override style sheet. The override style 
 * sheet takes precedence over author style sheets. An "!important" declaration 
 * still takes precedence over a normal declaration. Override, author, and user 
 * style sheets all may contain "!important" declarations. User "!important" 
 * rules take precedence over both override and author "!important" rules, and 
 * override "!important" rules take precedence over author "!important" rules.
 * 
 * The expectation is that an instance of the DocumentCSS interface can be 
 * obtained by using binding-specific casting methods on an instance of the 
 * Document interface.
 */
class DocumentCSS : virtual public stylesheets::DocumentStyle
{
public:

    /**
     * This method is used to retrieve the override style declaration for a specified 
     * element and a specified pseudo-element.
     */
    virtual CSSStyleDeclaration getOverrideStyle(const Element */*elt*/,
                                                 const DOMString &/*pseudoElt*/)
        {
        CSSStyleDeclaration style;
        return style;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    DocumentCSS() : stylesheets::DocumentStyle()
        {
        }

    /**
     *
     */
    DocumentCSS(const DocumentCSS &other) : stylesheets::DocumentStyle(other)
       {
       }

    /**
     *
     */
    DocumentCSS &operator=(const DocumentCSS &/*other*/)
       {
       return *this;
       }

    /**
     *
     */
    virtual ~DocumentCSS() {}
};






/*#########################################################################
## DOMImplementationCSS
#########################################################################*/

/**
 * This interface allows the DOM user to create a CSSStyleSheet outside the 
 * context of a document. There is no way to associate the new CSSStyleSheet with 
 * a document in DOM Level 2.
 */
class DOMImplementationCSS : virtual public DOMImplementation
{
public:

    /**
     * Creates a new CSSStyleSheet. 
     */
    virtual CSSStyleSheet createCSSStyleSheet(const DOMString &/*title*/,
                                              const DOMString &/*media*/)
                                               throw (dom::DOMException)
        {
        CSSStyleSheet sheet;
        return sheet;
        }

    //##################
    //# Non-API methods
    //##################

    /**
     *
     */
    DOMImplementationCSS() {}

    /**
     *
     */
    DOMImplementationCSS(const DOMImplementationCSS &other)
                         : DOMImplementation(other)
       {
       }

    /**
     *
     */
    DOMImplementationCSS &operator=(const DOMImplementationCSS &/*other*/)
       {
       return *this;
       }

    /**
     *
     */
    virtual ~DOMImplementationCSS() {}
};








}  //namespace css
}  //namespace dom
}  //namespace w3c
}  //namespace org


#endif /* __CSS_H__ */

/*#########################################################################
## E N D    O F    F I L E
#########################################################################*/