WebCore/css/CSSMutableStyleDeclaration.h

   1 /*
   2  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
   3  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #ifndef CSSMutableStyleDeclaration_h
  22 #define CSSMutableStyleDeclaration_h
  23
  24 #include "CSSStyleDeclaration.h"
  25 #include "CSSPrimitiveValue.h"
  26 #include "CSSProperty.h"
  27 #include "KURLHash.h"
  28 #include "PlatformString.h"
  29 #include <wtf/ListHashSet.h>
  30 #include <wtf/Vector.h>
  31
  32 namespace WebCore {
  33
  34 class Node;
  35
  36 class CSSMutableStyleDeclarationConstIterator {
  37 public:
  38     CSSMutableStyleDeclarationConstIterator(const CSSMutableStyleDeclaration* decl, CSSProperty* current);
  39     CSSMutableStyleDeclarationConstIterator(const CSSMutableStyleDeclarationConstIterator& o);
  40     ~CSSMutableStyleDeclarationConstIterator();
  41
  42     const CSSProperty& operator*() const { return *m_current; }
  43     const CSSProperty* operator->() const { return m_current; }
  44
  45     bool operator!=(const CSSMutableStyleDeclarationConstIterator& o) { ASSERT(m_decl == o.m_decl); return m_current != o.m_current; }
  46     bool operator==(const CSSMutableStyleDeclarationConstIterator& o) { ASSERT(m_decl == o.m_decl); return m_current == o.m_current; }
  47
  48     CSSMutableStyleDeclarationConstIterator& operator=(const CSSMutableStyleDeclarationConstIterator& o);
  49
  50     CSSMutableStyleDeclarationConstIterator& operator++();
  51     CSSMutableStyleDeclarationConstIterator& operator--();
  52
  53 private:
  54     const CSSMutableStyleDeclaration* m_decl;
  55     CSSProperty* m_current;
  56 };
  57
  58 class CSSMutableStyleDeclaration : public CSSStyleDeclaration {
  59 public:
  60     static PassRefPtr<CSSMutableStyleDeclaration> create()
  61     {
  62         return adoptRef(new CSSMutableStyleDeclaration);
  63     }
  64     static PassRefPtr<CSSMutableStyleDeclaration> create(CSSRule* parentRule)
  65     {
  66         return adoptRef(new CSSMutableStyleDeclaration(parentRule));
  67     }
  68     static PassRefPtr<CSSMutableStyleDeclaration> create(CSSRule* parentRule, const CSSProperty* const* properties, int numProperties)
  69     {
  70         return adoptRef(new CSSMutableStyleDeclaration(parentRule, properties, numProperties));
  71     }
  72     static PassRefPtr<CSSMutableStyleDeclaration> create(const Vector<CSSProperty>& properties, unsigned variableDependentValueCount)
  73     {
  74         return adoptRef(new CSSMutableStyleDeclaration(0, properties, variableDependentValueCount));
  75     }
  76
  77     CSSMutableStyleDeclaration& operator=(const CSSMutableStyleDeclaration&);
  78
  79     typedef CSSMutableStyleDeclarationConstIterator const_iterator;
  80
  81     const_iterator begin() { return const_iterator(this, m_properties.begin()); }
  82     const_iterator end() { return const_iterator(this, m_properties.end()); }
  83
  84     void setNode(Node* node) { m_node = node; }
  85
  86     virtual bool isMutableStyleDeclaration() const { return true; }
  87
  88     virtual String cssText() const;
  89     virtual void setCssText(const String&, ExceptionCode&);
  90
  91     virtual unsigned virtualLength() const;
  92     unsigned length() const { return m_properties.size(); }
  93
  94     virtual String item(unsigned index) const;
  95
  96     virtual PassRefPtr<CSSValue> getPropertyCSSValue(int propertyID) const;
  97     virtual String getPropertyValue(int propertyID) const;
  98     virtual bool getPropertyPriority(int propertyID) const;
  99     virtual int getPropertyShorthand(int propertyID) const;
 100     virtual bool isPropertyImplicit(int propertyID) const;
 101
 102     virtual void setProperty(int propertyId, const String& value, bool important, ExceptionCode&);
 103     virtual String removeProperty(int propertyID, ExceptionCode&);
 104
 105     virtual PassRefPtr<CSSMutableStyleDeclaration> copy() const;
 106
 107     bool setProperty(int propertyID, int value, bool important = false, bool notifyChanged = true);
 108     bool setProperty(int propertyID, const String& value, bool important = false, bool notifyChanged = true);
 109
 110     String removeProperty(int propertyID, bool notifyChanged = true, bool returnText = false);
 111
 112     // setLengthProperty treats integers as pixels! (Needed for conversion of HTML attributes.)
 113     void setLengthProperty(int propertyId, const String& value, bool important, bool multiLength = false);
 114     void setStringProperty(int propertyId, const String& value, CSSPrimitiveValue::UnitTypes, bool important = false); // parsed string value
 115     void setImageProperty(int propertyId, const String& url, bool important = false);
 116
 117     // The following parses an entire new style declaration.
 118     void parseDeclaration(const String& styleDeclaration);
 119
 120     // Besides adding the properties, this also removes any existing properties with these IDs.
 121     // It does no notification since it's called by the parser.
 122     void addParsedProperties(const CSSProperty* const *, int numProperties);
 123     // This does no change notifications since it's only called by createMarkup.
 124     void addParsedProperty(const CSSProperty&);
 125
 126     PassRefPtr<CSSMutableStyleDeclaration> copyBlockProperties() const;
 127     void removeBlockProperties();
 128     void removePropertiesInSet(const int* set, unsigned length, bool notifyChanged = true);
 129
 130     void merge(CSSMutableStyleDeclaration*, bool argOverridesOnConflict = true);
 131
 132     bool hasVariableDependentValue() const { return m_variableDependentValueCount > 0; }
 133
 134     void setStrictParsing(bool b) { m_strictParsing = b; }
 135     bool useStrictParsing() const { return m_strictParsing; }
 136
 137     void addSubresourceStyleURLs(ListHashSet<KURL>&);
 138
 139 protected:
 140     CSSMutableStyleDeclaration(CSSRule* parentRule);
 141
 142 private:
 143     CSSMutableStyleDeclaration();
 144     CSSMutableStyleDeclaration(CSSRule* parentRule, const Vector<CSSProperty>&, unsigned variableDependentValueCount);
 145     CSSMutableStyleDeclaration(CSSRule* parentRule, const CSSProperty* const *, int numProperties);
 146
 147     virtual PassRefPtr<CSSMutableStyleDeclaration> makeMutable();
 148
 149     void setNeedsStyleRecalc();
 150
 151     String getShorthandValue(const int* properties, int number) const;
 152     String getCommonValue(const int* properties, int number) const;
 153     String getLayeredShorthandValue(const int* properties, unsigned number) const;
 154     String get4Values(const int* properties) const;
 155
 156     void setPropertyInternal(const CSSProperty&, CSSProperty* slot = 0);
 157     bool removeShorthandProperty(int propertyID, bool notifyChanged);
 158
 159     Vector<CSSProperty>::const_iterator findPropertyWithId(int propertyId) const;
 160     Vector<CSSProperty>::iterator findPropertyWithId(int propertyId);
 161
 162     Vector<CSSProperty, 4> m_properties;
 163
 164     Node* m_node;
 165     unsigned m_variableDependentValueCount : 24;
 166     bool m_strictParsing : 1;
 167 #ifndef NDEBUG
 168     unsigned m_iteratorCount : 4;
 169 #endif
 170
 171     friend class CSSMutableStyleDeclarationConstIterator;
 172 };
 173
 174 inline CSSMutableStyleDeclarationConstIterator::CSSMutableStyleDeclarationConstIterator(const CSSMutableStyleDeclaration* decl, CSSProperty* current)
 175 : m_decl(decl)
 176 , m_current(current)
 177 {
 178 #ifndef NDEBUG
 179     const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++;
 180 #endif
 181 }
 182
 183 inline CSSMutableStyleDeclarationConstIterator::CSSMutableStyleDeclarationConstIterator(const CSSMutableStyleDeclarationConstIterator& o)
 184 : m_decl(o.m_decl)
 185 , m_current(o.m_current)
 186 {
 187 #ifndef NDEBUG
 188     const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++;
 189 #endif
 190 }
 191
 192 inline CSSMutableStyleDeclarationConstIterator::~CSSMutableStyleDeclarationConstIterator()
 193 {
 194 #ifndef NDEBUG
 195     const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount--;
 196 #endif
 197 }
 198
 199 inline CSSMutableStyleDeclarationConstIterator& CSSMutableStyleDeclarationConstIterator::operator=(const CSSMutableStyleDeclarationConstIterator& o)
 200 {
 201     m_decl = o.m_decl;
 202     m_current = o.m_current;
 203 #ifndef NDEBUG
 204     const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++;
 205 #endif
 206     return *this;
 207 }
 208
 209 inline CSSMutableStyleDeclarationConstIterator& CSSMutableStyleDeclarationConstIterator::operator++()
 210 {
 211     ASSERT(m_current != const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_properties.end());
 212     ++m_current;
 213     return *this;
 214 }
 215
 216 inline CSSMutableStyleDeclarationConstIterator& CSSMutableStyleDeclarationConstIterator::operator--()
 217 {
 218     --m_current;
 219     return *this;
 220 }
 221
 222 } // namespace WebCore
 223
 224 #endif // CSSMutableStyleDeclaration_h