WebCore/css/CSSMutableStyleDeclaration.cpp

   1 /**
   2  * This file is part of the DOM implementation for KDE.
   3  *
   4  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
   5  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public License
  18  * along with this library; see the file COPYING.LIB.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #include "config.h"
  24 #include "CSSMutableStyleDeclaration.h"
  25
  26 #include "CSSImageValue.h"
  27 #include "CSSParser.h"
  28 #include "CSSProperty.h"
  29 #include "CSSPropertyNames.h"
  30 #include "CSSStyleSheet.h"
  31 #include "CSSValueList.h"
  32 #include "Document.h"
  33 #include "ExceptionCode.h"
  34 #include "StyledElement.h"
  35
  36 using namespace std;
  37
  38 namespace WebCore {
  39
  40 CSSMutableStyleDeclaration::CSSMutableStyleDeclaration()
  41     : m_node(0)
  42 {
  43 }
  44
  45 CSSMutableStyleDeclaration::CSSMutableStyleDeclaration(CSSRule* parent)
  46     : CSSStyleDeclaration(parent)
  47     , m_node(0)
  48 {
  49 }
  50
  51 CSSMutableStyleDeclaration::CSSMutableStyleDeclaration(CSSRule* parent, const DeprecatedValueList<CSSProperty>& values)
  52     : CSSStyleDeclaration(parent)
  53     , m_values(values)
  54     , m_node(0)
  55 {
  56     // FIXME: This allows duplicate properties.
  57 }
  58
  59 CSSMutableStyleDeclaration::CSSMutableStyleDeclaration(CSSRule* parent, const CSSProperty* const * properties, int numProperties)
  60     : CSSStyleDeclaration(parent)
  61     , m_node(0)
  62 {
  63     for (int i = 0; i < numProperties; ++i) {
  64         ASSERT(properties[i]);
  65         m_values.append(*properties[i]);
  66     }
  67     // FIXME: This allows duplicate properties.
  68 }
  69
  70 CSSMutableStyleDeclaration& CSSMutableStyleDeclaration::operator=(const CSSMutableStyleDeclaration& other)
  71 {
  72     // don't attach it to the same node, just leave the current m_node value
  73     m_values = other.m_values;
  74     return *this;
  75 }
  76
  77 String CSSMutableStyleDeclaration::getPropertyValue(int propertyID) const
  78 {
  79     RefPtr<CSSValue> value = getPropertyCSSValue(propertyID);
  80     if (value)
  81         return value->cssText();
  82
  83     // Shorthand and 4-values properties
  84     switch (propertyID) {
  85         case CSS_PROP_BACKGROUND_POSITION: {
  86             // FIXME: Is this correct? The code in cssparser.cpp is confusing
  87             const int properties[2] = { CSS_PROP_BACKGROUND_POSITION_X,
  88                                         CSS_PROP_BACKGROUND_POSITION_Y };
  89             return getLayeredShorthandValue(properties, 2);
  90         }
  91         case CSS_PROP_BACKGROUND: {
  92             const int properties[6] = { CSS_PROP_BACKGROUND_IMAGE, CSS_PROP_BACKGROUND_REPEAT,
  93                                         CSS_PROP_BACKGROUND_ATTACHMENT, CSS_PROP_BACKGROUND_POSITION_X,
  94                                         CSS_PROP_BACKGROUND_POSITION_Y, CSS_PROP_BACKGROUND_COLOR };
  95             return getLayeredShorthandValue(properties, 6);
  96         }
  97         case CSS_PROP_BORDER: {
  98             const int properties[3] = { CSS_PROP_BORDER_WIDTH, CSS_PROP_BORDER_STYLE,
  99                                         CSS_PROP_BORDER_COLOR };
 100             return getShorthandValue(properties, 3);
 101         }
 102         case CSS_PROP_BORDER_TOP: {
 103             const int properties[3] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_TOP_STYLE,
 104                                         CSS_PROP_BORDER_TOP_COLOR};
 105             return getShorthandValue(properties, 3);
 106         }
 107         case CSS_PROP_BORDER_RIGHT: {
 108             const int properties[3] = { CSS_PROP_BORDER_RIGHT_WIDTH, CSS_PROP_BORDER_RIGHT_STYLE,
 109                                         CSS_PROP_BORDER_RIGHT_COLOR};
 110             return getShorthandValue(properties, 3);
 111         }
 112         case CSS_PROP_BORDER_BOTTOM: {
 113             const int properties[3] = { CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_BOTTOM_STYLE,
 114                                         CSS_PROP_BORDER_BOTTOM_COLOR};
 115             return getShorthandValue(properties, 3);
 116         }
 117         case CSS_PROP_BORDER_LEFT: {
 118             const int properties[3] = { CSS_PROP_BORDER_LEFT_WIDTH, CSS_PROP_BORDER_LEFT_STYLE,
 119                                         CSS_PROP_BORDER_LEFT_COLOR};
 120             return getShorthandValue(properties, 3);
 121         }
 122         case CSS_PROP_OUTLINE: {
 123             const int properties[3] = { CSS_PROP_OUTLINE_WIDTH, CSS_PROP_OUTLINE_STYLE,
 124                                         CSS_PROP_OUTLINE_COLOR };
 125             return getShorthandValue(properties, 3);
 126         }
 127         case CSS_PROP_BORDER_COLOR: {
 128             const int properties[4] = { CSS_PROP_BORDER_TOP_COLOR, CSS_PROP_BORDER_RIGHT_COLOR,
 129                                         CSS_PROP_BORDER_BOTTOM_COLOR, CSS_PROP_BORDER_LEFT_COLOR };
 130             return get4Values(properties);
 131         }
 132         case CSS_PROP_BORDER_WIDTH: {
 133             const int properties[4] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_RIGHT_WIDTH,
 134                                         CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_LEFT_WIDTH };
 135             return get4Values(properties);
 136         }
 137         case CSS_PROP_BORDER_STYLE: {
 138             const int properties[4] = { CSS_PROP_BORDER_TOP_STYLE, CSS_PROP_BORDER_RIGHT_STYLE,
 139                                         CSS_PROP_BORDER_BOTTOM_STYLE, CSS_PROP_BORDER_LEFT_STYLE };
 140             return get4Values(properties);
 141         }
 142         case CSS_PROP_MARGIN: {
 143             const int properties[4] = { CSS_PROP_MARGIN_TOP, CSS_PROP_MARGIN_RIGHT,
 144                                         CSS_PROP_MARGIN_BOTTOM, CSS_PROP_MARGIN_LEFT };
 145             return get4Values(properties);
 146         }
 147         case CSS_PROP_PADDING: {
 148             const int properties[4] = { CSS_PROP_PADDING_TOP, CSS_PROP_PADDING_RIGHT,
 149                                         CSS_PROP_PADDING_BOTTOM, CSS_PROP_PADDING_LEFT };
 150             return get4Values(properties);
 151         }
 152         case CSS_PROP_LIST_STYLE: {
 153             const int properties[3] = { CSS_PROP_LIST_STYLE_TYPE, CSS_PROP_LIST_STYLE_POSITION,
 154                                         CSS_PROP_LIST_STYLE_IMAGE };
 155             return getShorthandValue(properties, 3);
 156         }
 157     }
 158     return String();
 159 }
 160
 161 String CSSMutableStyleDeclaration::get4Values( const int* properties ) const
 162 {
 163     String res;
 164     for (int i = 0; i < 4; ++i) {
 165         if (!isPropertyImplicit(properties[i])) {
 166             RefPtr<CSSValue> value = getPropertyCSSValue(properties[i]);
 167
 168             // apparently all 4 properties must be specified.
 169             if (!value)
 170                 return String();
 171
 172             if (!res.isNull())
 173                 res += " ";
 174             res += value->cssText();
 175         }
 176     }
 177     return res;
 178 }
 179
 180 String CSSMutableStyleDeclaration::getLayeredShorthandValue(const int* properties, unsigned number) const
 181 {
 182     String res;
 183     unsigned i;
 184     unsigned j;
 185
 186     // Begin by collecting the properties into an array.
 187     Vector< RefPtr<CSSValue> > values(number);
 188     unsigned numLayers = 0;
 189
 190     for (i = 0; i < number; ++i) {
 191         values[i] = getPropertyCSSValue(properties[i]);
 192         if (values[i]) {
 193             if (values[i]->isValueList()) {
 194                 CSSValueList* valueList = static_cast<CSSValueList*>(values[i].get());
 195                 numLayers = max(valueList->length(), numLayers);
 196             } else
 197                 numLayers = max(1U, numLayers);
 198         }
 199     }
 200
 201     // Now stitch the properties together.  Implicit initial values are flagged as such and
 202     // can safely be omitted.
 203     for (i = 0; i < numLayers; i++) {
 204         String layerRes;
 205         for (j = 0; j < number; j++) {
 206             RefPtr<CSSValue> value;
 207             if (values[j]) {
 208                 if (values[j]->isValueList())
 209                     value = static_cast<CSSValueList*>(values[j].get())->item(i);
 210                 else {
 211                     value = values[j];
 212
 213                     // Color only belongs in the last layer.
 214                     if (properties[j] == CSS_PROP_BACKGROUND_COLOR) {
 215                         if (i != numLayers - 1)
 216                             value = 0;
 217                     } else if (i != 0) // Other singletons only belong in the first layer.
 218                         value = 0;
 219                 }
 220             }
 221
 222             if (value && !value->isImplicitInitialValue()) {
 223                 if (!layerRes.isNull())
 224                     layerRes += " ";
 225                 layerRes += value->cssText();
 226             }
 227         }
 228
 229         if (!layerRes.isNull()) {
 230             if (!res.isNull())
 231                 res += ", ";
 232             res += layerRes;
 233         }
 234     }
 235
 236     return res;
 237 }
 238
 239 String CSSMutableStyleDeclaration::getShorthandValue(const int* properties, int number) const
 240 {
 241     String res;
 242     for (int i = 0; i < number; ++i) {
 243         if (!isPropertyImplicit(properties[i])) {
 244             RefPtr<CSSValue> value = getPropertyCSSValue(properties[i]);
 245             // FIXME: provide default value if !value
 246             if (value) {
 247                 if (!res.isNull())
 248                     res += " ";
 249                 res += value->cssText();
 250             }
 251         }
 252     }
 253     return res;
 254 }
 255
 256 PassRefPtr<CSSValue> CSSMutableStyleDeclaration::getPropertyCSSValue(int propertyID) const
 257 {
 258     DeprecatedValueListConstIterator<CSSProperty> end;
 259     for (DeprecatedValueListConstIterator<CSSProperty> it = m_values.fromLast(); it != end; --it) {
 260         if (propertyID == (*it).m_id)
 261             return (*it).value();
 262     }
 263     return 0;
 264 }
 265
 266 struct PropertyLonghand {
 267     PropertyLonghand()
 268         : m_properties(0)
 269         , m_length(0)
 270     {
 271     }
 272
 273     PropertyLonghand(const int* firstProperty, unsigned numProperties)
 274         : m_properties(firstProperty)
 275         , m_length(numProperties)
 276     {
 277     }
 278
 279     const int* properties() const { return m_properties; }
 280     unsigned length() const { return m_length; }
 281
 282 private:
 283     const int* m_properties;
 284     unsigned m_length;
 285 };
 286
 287 static void initShorthandMap(HashMap<int, PropertyLonghand>& shorthandMap)
 288 {
 289     #define SET_SHORTHAND_MAP_ENTRY(map, propID, array) \
 290         map.set(propID, PropertyLonghand(array, sizeof(array) / sizeof(array[0])))
 291
 292     // FIXME: The 'font' property has "shorthand nature" but is not parsed as a shorthand.
 293
 294     // Do not change the order of the following four shorthands, and keep them together.
 295     static const int borderProperties[4][3] = {
 296         { CSS_PROP_BORDER_TOP_COLOR, CSS_PROP_BORDER_TOP_STYLE, CSS_PROP_BORDER_TOP_WIDTH },
 297         { CSS_PROP_BORDER_RIGHT_COLOR, CSS_PROP_BORDER_RIGHT_STYLE, CSS_PROP_BORDER_RIGHT_WIDTH },
 298         { CSS_PROP_BORDER_BOTTOM_COLOR, CSS_PROP_BORDER_BOTTOM_STYLE, CSS_PROP_BORDER_BOTTOM_WIDTH },
 299         { CSS_PROP_BORDER_LEFT_COLOR, CSS_PROP_BORDER_LEFT_STYLE, CSS_PROP_BORDER_LEFT_WIDTH }
 300     };
 301     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BORDER_TOP, borderProperties[0]);
 302     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BORDER_RIGHT, borderProperties[1]);
 303     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BORDER_BOTTOM, borderProperties[2]);
 304     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BORDER_LEFT, borderProperties[3]);
 305
 306     shorthandMap.set(CSS_PROP_BORDER, PropertyLonghand(borderProperties[0], sizeof(borderProperties) / sizeof(borderProperties[0][0])));
 307
 308     static const int borderColorProperties[] = {
 309         CSS_PROP_BORDER_TOP_COLOR,
 310         CSS_PROP_BORDER_RIGHT_COLOR,
 311         CSS_PROP_BORDER_BOTTOM_COLOR,
 312         CSS_PROP_BORDER_LEFT_COLOR
 313     };
 314     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BORDER_COLOR, borderColorProperties);
 315
 316     static const int borderStyleProperties[] = {
 317         CSS_PROP_BORDER_TOP_STYLE,
 318         CSS_PROP_BORDER_RIGHT_STYLE,
 319         CSS_PROP_BORDER_BOTTOM_STYLE,
 320         CSS_PROP_BORDER_LEFT_STYLE
 321     };
 322     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BORDER_STYLE, borderStyleProperties);
 323
 324     static const int borderWidthProperties[] = {
 325         CSS_PROP_BORDER_TOP_WIDTH,
 326         CSS_PROP_BORDER_RIGHT_WIDTH,
 327         CSS_PROP_BORDER_BOTTOM_WIDTH,
 328         CSS_PROP_BORDER_LEFT_WIDTH
 329     };
 330     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BORDER_WIDTH, borderWidthProperties);
 331
 332     static const int backgroundPositionProperties[] = { CSS_PROP_BACKGROUND_POSITION_X, CSS_PROP_BACKGROUND_POSITION_Y };
 333     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BACKGROUND_POSITION, backgroundPositionProperties);
 334
 335     static const int borderSpacingProperties[] = { CSS_PROP__WEBKIT_BORDER_HORIZONTAL_SPACING, CSS_PROP__WEBKIT_BORDER_VERTICAL_SPACING };
 336     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BORDER_SPACING, borderSpacingProperties);
 337
 338     static const int listStyleProperties[] = {
 339         CSS_PROP_LIST_STYLE_IMAGE,
 340         CSS_PROP_LIST_STYLE_POSITION,
 341         CSS_PROP_LIST_STYLE_TYPE
 342     };
 343     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_LIST_STYLE, listStyleProperties);
 344
 345     static const int marginProperties[] = {
 346         CSS_PROP_MARGIN_TOP,
 347         CSS_PROP_MARGIN_RIGHT,
 348         CSS_PROP_MARGIN_BOTTOM,
 349         CSS_PROP_MARGIN_LEFT
 350     };
 351     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_MARGIN, marginProperties);
 352
 353     static const int marginCollapseProperties[] = { CSS_PROP__WEBKIT_MARGIN_TOP_COLLAPSE, CSS_PROP__WEBKIT_MARGIN_BOTTOM_COLLAPSE };
 354     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP__WEBKIT_MARGIN_COLLAPSE, marginCollapseProperties);
 355
 356     static const int marqueeProperties[] = {
 357         CSS_PROP__WEBKIT_MARQUEE_DIRECTION,
 358         CSS_PROP__WEBKIT_MARQUEE_INCREMENT,
 359         CSS_PROP__WEBKIT_MARQUEE_REPETITION,
 360         CSS_PROP__WEBKIT_MARQUEE_STYLE,
 361         CSS_PROP__WEBKIT_MARQUEE_SPEED
 362     };
 363     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP__WEBKIT_MARQUEE, marqueeProperties);
 364
 365     static const int outlineProperties[] = {
 366         CSS_PROP_OUTLINE_COLOR,
 367         CSS_PROP_OUTLINE_OFFSET,
 368         CSS_PROP_OUTLINE_STYLE,
 369         CSS_PROP_OUTLINE_WIDTH
 370     };
 371     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_OUTLINE, outlineProperties);
 372
 373     static const int paddingProperties[] = {
 374         CSS_PROP_PADDING_TOP,
 375         CSS_PROP_PADDING_RIGHT,
 376         CSS_PROP_PADDING_BOTTOM,
 377         CSS_PROP_PADDING_LEFT
 378     };
 379     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_PADDING, paddingProperties);
 380
 381     static const int textStrokeProperties[] = { CSS_PROP__WEBKIT_TEXT_STROKE_COLOR, CSS_PROP__WEBKIT_TEXT_STROKE_WIDTH };
 382     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP__WEBKIT_TEXT_STROKE, textStrokeProperties);
 383
 384     static const int backgroundProperties[] = {
 385         CSS_PROP_BACKGROUND_ATTACHMENT,
 386         CSS_PROP_BACKGROUND_COLOR,
 387         CSS_PROP_BACKGROUND_IMAGE,
 388         CSS_PROP_BACKGROUND_POSITION_X,
 389         CSS_PROP_BACKGROUND_POSITION_Y,
 390         CSS_PROP_BACKGROUND_REPEAT,
 391         CSS_PROP__WEBKIT_BACKGROUND_SIZE
 392     };
 393     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_BACKGROUND, backgroundProperties);
 394
 395     static const int columnsProperties[] = { CSS_PROP__WEBKIT_COLUMN_WIDTH, CSS_PROP__WEBKIT_COLUMN_COUNT };
 396     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP__WEBKIT_COLUMNS, columnsProperties);
 397
 398     static const int columnRuleProperties[] = {
 399         CSS_PROP__WEBKIT_COLUMN_RULE_COLOR,
 400         CSS_PROP__WEBKIT_COLUMN_RULE_STYLE,
 401         CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH
 402     };
 403     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP__WEBKIT_COLUMN_RULE, columnRuleProperties);
 404
 405     static const int overflowProperties[] = { CSS_PROP_OVERFLOW_X, CSS_PROP_OVERFLOW_Y };
 406     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP_OVERFLOW, overflowProperties);
 407
 408     static const int borderRadiusProperties[] = {
 409         CSS_PROP__WEBKIT_BORDER_TOP_RIGHT_RADIUS,
 410         CSS_PROP__WEBKIT_BORDER_TOP_LEFT_RADIUS,
 411         CSS_PROP__WEBKIT_BORDER_BOTTOM_LEFT_RADIUS,
 412         CSS_PROP__WEBKIT_BORDER_BOTTOM_RIGHT_RADIUS
 413     };
 414     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSS_PROP__WEBKIT_BORDER_RADIUS, borderRadiusProperties);
 415
 416     #undef SET_SHORTHAND_MAP_ENTRY
 417 }
 418
 419 String CSSMutableStyleDeclaration::removeProperty(int propertyID, bool notifyChanged, bool returnText, ExceptionCode& ec)
 420 {
 421     ec = 0;
 422
 423     static HashMap<int, PropertyLonghand> shorthandMap;
 424     if (shorthandMap.isEmpty())
 425         initShorthandMap(shorthandMap);
 426
 427     PropertyLonghand longhand = shorthandMap.get(propertyID);
 428     if (longhand.length()) {
 429         removePropertiesInSet(longhand.properties(), longhand.length(), notifyChanged);
 430         // FIXME: Return an equivalent shorthand when possible.
 431         return String();
 432     }
 433
 434     String value;
 435
 436     DeprecatedValueListIterator<CSSProperty> end;
 437     for (DeprecatedValueListIterator<CSSProperty> it = m_values.fromLast(); it != end; --it) {
 438         if (propertyID == (*it).m_id) {
 439             if (returnText)
 440                 value = (*it).value()->cssText();
 441             m_values.remove(it);
 442             if (notifyChanged)
 443                 setChanged();
 444             break;
 445         }
 446     }
 447
 448     return value;
 449 }
 450
 451 void CSSMutableStyleDeclaration::clear()
 452 {
 453     m_values.clear();
 454     setChanged();
 455 }
 456
 457 void CSSMutableStyleDeclaration::setChanged(StyleChangeType changeType)
 458 {
 459     if (m_node) {
 460         m_node->setChanged(changeType);
 461         // FIXME: Ideally, this should be factored better and there
 462         // should be a subclass of CSSMutableStyleDeclaration just
 463         // for inline style declarations that handles this
 464         if (m_node->isStyledElement() && this == static_cast<StyledElement*>(m_node)->inlineStyleDecl())
 465             static_cast<StyledElement*>(m_node)->invalidateStyleAttribute();
 466         return;
 467     }
 468
 469     // FIXME: quick&dirty hack for KDE 3.0... make this MUCH better! (Dirk)
 470     StyleBase* root = this;
 471     while (StyleBase* parent = root->parent())
 472         root = parent;
 473     if (root->isCSSStyleSheet())
 474         static_cast<CSSStyleSheet*>(root)->doc()->updateStyleSelector();
 475 }
 476
 477 bool CSSMutableStyleDeclaration::getPropertyPriority(int propertyID) const
 478 {
 479     DeprecatedValueListConstIterator<CSSProperty> end;
 480     for (DeprecatedValueListConstIterator<CSSProperty> it = m_values.begin(); it != end; ++it) {
 481         if (propertyID == (*it).id())
 482             return (*it).isImportant();
 483     }
 484     return false;
 485 }
 486
 487 int CSSMutableStyleDeclaration::getPropertyShorthand(int propertyID) const
 488 {
 489     DeprecatedValueListConstIterator<CSSProperty> end;
 490     for (DeprecatedValueListConstIterator<CSSProperty> it = m_values.begin(); it != end; ++it) {
 491         if (propertyID == (*it).id())
 492             return (*it).shorthandID();
 493     }
 494     return false;
 495 }
 496
 497 bool CSSMutableStyleDeclaration::isPropertyImplicit(int propertyID) const
 498 {
 499     DeprecatedValueListConstIterator<CSSProperty> end;
 500     for (DeprecatedValueListConstIterator<CSSProperty> it = m_values.begin(); it != end; ++it) {
 501         if (propertyID == (*it).id())
 502             return (*it).isImplicit();
 503     }
 504     return false;
 505 }
 506
 507 void CSSMutableStyleDeclaration::setProperty(int propertyID, const String& value, bool important, ExceptionCode& ec)
 508 {
 509     setProperty(propertyID, value, important, true, ec);
 510 }
 511
 512 String CSSMutableStyleDeclaration::removeProperty(int propertyID, ExceptionCode& ec)
 513 {
 514     return removeProperty(propertyID, true, true, ec);
 515 }
 516
 517 bool CSSMutableStyleDeclaration::setProperty(int propertyID, const String& value, bool important, bool notifyChanged, ExceptionCode& ec)
 518 {
 519     ec = 0;
 520
 521     // Setting the value to an empty string just removes the property in both IE and Gecko.
 522     // Setting it to null seems to produce less consistent results, but we treat it just the same.
 523     if (value.isEmpty()) {
 524         removeProperty(propertyID, notifyChanged, false, ec);
 525         return ec == 0;
 526     }
 527
 528     // When replacing an existing property value, this moves the property to the end of the list.
 529     // Firefox preserves the position, and MSIE moves the property to the beginning.
 530     CSSParser parser(useStrictParsing());
 531     bool success = parser.parseValue(this, propertyID, value, important);
 532     if (!success) {
 533         // CSS DOM requires raising SYNTAX_ERR here, but this is too dangerous for compatibility,
 534         // see <http://bugs.webkit.org/show_bug.cgi?id=7296>.
 535     } else if (notifyChanged)
 536         setChanged(InlineStyleChange);
 537     ASSERT(!ec);
 538     return success;
 539 }
 540
 541 bool CSSMutableStyleDeclaration::setProperty(int propertyID, int value, bool important, bool notifyChanged)
 542 {
 543     removeProperty(propertyID);
 544     m_values.append(CSSProperty(propertyID, new CSSPrimitiveValue(value), important));
 545     if (notifyChanged)
 546         setChanged();
 547     return true;
 548 }
 549
 550 void CSSMutableStyleDeclaration::setStringProperty(int propertyId, const String &value, CSSPrimitiveValue::UnitTypes type, bool important)
 551 {
 552     removeProperty(propertyId);
 553     m_values.append(CSSProperty(propertyId, new CSSPrimitiveValue(value, type), important));
 554     setChanged();
 555 }
 556
 557 void CSSMutableStyleDeclaration::setImageProperty(int propertyId, const String& url, bool important)
 558 {
 559     removeProperty(propertyId);
 560     m_values.append(CSSProperty(propertyId, new CSSImageValue(url, this), important));
 561     setChanged();
 562 }
 563
 564 void CSSMutableStyleDeclaration::parseDeclaration(const String& styleDeclaration)
 565 {
 566     m_values.clear();
 567     CSSParser parser(useStrictParsing());
 568     parser.parseDeclaration(this, styleDeclaration);
 569     setChanged();
 570 }
 571
 572 void CSSMutableStyleDeclaration::addParsedProperties(const CSSProperty * const * properties, int numProperties)
 573 {
 574     for (int i = 0; i < numProperties; ++i) {
 575         // Only add properties that have no !important counterpart present
 576         if (!getPropertyPriority(properties[i]->id()) || properties[i]->isImportant()) {
 577             removeProperty(properties[i]->id(), false);
 578             ASSERT(properties[i]);
 579             m_values.append(*properties[i]);
 580         }
 581     }
 582     // FIXME: This probably should have a call to setChanged() if something changed. We may also wish to add
 583     // a notifyChanged argument to this function to follow the model of other functions in this class.
 584 }
 585
 586 void CSSMutableStyleDeclaration::setLengthProperty(int propertyId, const String& value, bool important, bool /*multiLength*/)
 587 {
 588     bool parseMode = useStrictParsing();
 589     setStrictParsing(false);
 590     setProperty(propertyId, value, important);
 591     setStrictParsing(parseMode);
 592 }
 593
 594 unsigned CSSMutableStyleDeclaration::length() const
 595 {
 596     return m_values.count();
 597 }
 598
 599 String CSSMutableStyleDeclaration::item(unsigned i) const
 600 {
 601     if (i >= m_values.count())
 602        return String();
 603     return getPropertyName(static_cast<CSSPropertyID>(m_values[i].id()));
 604 }
 605
 606 String CSSMutableStyleDeclaration::cssText() const
 607 {
 608     String result = "";
 609
 610     const CSSProperty* positionXProp = 0;
 611     const CSSProperty* positionYProp = 0;
 612
 613     DeprecatedValueListConstIterator<CSSProperty> end;
 614     for (DeprecatedValueListConstIterator<CSSProperty> it = m_values.begin(); it != end; ++it) {
 615         const CSSProperty& prop = *it;
 616         if (prop.id() == CSS_PROP_BACKGROUND_POSITION_X)
 617             positionXProp = &prop;
 618         else if (prop.id() == CSS_PROP_BACKGROUND_POSITION_Y)
 619             positionYProp = &prop;
 620         else
 621             result += prop.cssText();
 622     }
 623
 624     // FIXME: This is a not-so-nice way to turn x/y positions into single background-position in output.
 625     // It is required because background-position-x/y are non-standard properties and WebKit generated output
 626     // would not work in Firefox (<rdar://problem/5143183>)
 627     // It would be a better solution if background-position was CSS_PAIR.
 628     if (positionXProp && positionYProp && positionXProp->isImportant() == positionYProp->isImportant()) {
 629         String positionValue;
 630         const int properties[2] = { CSS_PROP_BACKGROUND_POSITION_X, CSS_PROP_BACKGROUND_POSITION_Y };
 631         if (positionXProp->value()->isValueList() || positionYProp->value()->isValueList())
 632             positionValue = getLayeredShorthandValue(properties, 2);
 633         else
 634             positionValue = positionXProp->value()->cssText() + " " + positionYProp->value()->cssText();
 635         result += "background-position: " + positionValue + (positionXProp->isImportant() ? " !important" : "") + "; ";
 636     } else {
 637         if (positionXProp)
 638             result += positionXProp->cssText();
 639         if (positionYProp)
 640             result += positionYProp->cssText();
 641     }
 642
 643     return result;
 644 }
 645
 646 void CSSMutableStyleDeclaration::setCssText(const String& text, ExceptionCode& ec)
 647 {
 648     ec = 0;
 649     m_values.clear();
 650     CSSParser parser(useStrictParsing());
 651     parser.parseDeclaration(this, text);
 652     // FIXME: Detect syntax errors and set ec.
 653     setChanged();
 654 }
 655
 656 void CSSMutableStyleDeclaration::merge(CSSMutableStyleDeclaration* other, bool argOverridesOnConflict)
 657 {
 658     DeprecatedValueListConstIterator<CSSProperty> end;
 659     for (DeprecatedValueListConstIterator<CSSProperty> it = other->valuesIterator(); it != end; ++it) {
 660         const CSSProperty& property = *it;
 661         RefPtr<CSSValue> value = getPropertyCSSValue(property.id());
 662         if (value) {
 663             if (!argOverridesOnConflict)
 664                 continue;
 665             removeProperty(property.id());
 666         }
 667         m_values.append(property);
 668     }
 669     // FIXME: This probably should have a call to setChanged() if something changed. We may also wish to add
 670     // a notifyChanged argument to this function to follow the model of other functions in this class.
 671 }
 672
 673 // This is the list of properties we want to copy in the copyBlockProperties() function.
 674 // It is the list of CSS properties that apply specially to block-level elements.
 675 static const int blockProperties[] = {
 676     CSS_PROP_ORPHANS,
 677     CSS_PROP_OVERFLOW, // This can be also be applied to replaced elements
 678     CSS_PROP__WEBKIT_COLUMN_COUNT,
 679     CSS_PROP__WEBKIT_COLUMN_GAP,
 680     CSS_PROP__WEBKIT_COLUMN_RULE_COLOR,
 681     CSS_PROP__WEBKIT_COLUMN_RULE_STYLE,
 682     CSS_PROP__WEBKIT_COLUMN_RULE_WIDTH,
 683     CSS_PROP__WEBKIT_COLUMN_BREAK_BEFORE,
 684     CSS_PROP__WEBKIT_COLUMN_BREAK_AFTER,
 685     CSS_PROP__WEBKIT_COLUMN_BREAK_INSIDE,
 686     CSS_PROP__WEBKIT_COLUMN_WIDTH,
 687     CSS_PROP_PAGE_BREAK_AFTER,
 688     CSS_PROP_PAGE_BREAK_BEFORE,
 689     CSS_PROP_PAGE_BREAK_INSIDE,
 690     CSS_PROP_TEXT_ALIGN,
 691     CSS_PROP_TEXT_INDENT,
 692     CSS_PROP_WIDOWS
 693 };
 694
 695 const unsigned numBlockProperties = sizeof(blockProperties) / sizeof(blockProperties[0]);
 696
 697 PassRefPtr<CSSMutableStyleDeclaration> CSSMutableStyleDeclaration::copyBlockProperties() const
 698 {
 699     return copyPropertiesInSet(blockProperties, numBlockProperties);
 700 }
 701
 702 void CSSMutableStyleDeclaration::removeBlockProperties()
 703 {
 704     removePropertiesInSet(blockProperties, numBlockProperties);
 705 }
 706
 707 void CSSMutableStyleDeclaration::removePropertiesInSet(const int* set, unsigned length, bool notifyChanged)
 708 {
 709     bool changed = false;
 710     for (unsigned i = 0; i < length; i++) {
 711         RefPtr<CSSValue> value = getPropertyCSSValue(set[i]);
 712         if (value) {
 713             m_values.remove(CSSProperty(set[i], value.release(), false));
 714             changed = true;
 715         }
 716     }
 717     if (changed && notifyChanged)
 718         setChanged();
 719 }
 720
 721 PassRefPtr<CSSMutableStyleDeclaration> CSSMutableStyleDeclaration::makeMutable()
 722 {
 723     return this;
 724 }
 725
 726 PassRefPtr<CSSMutableStyleDeclaration> CSSMutableStyleDeclaration::copy() const
 727 {
 728     return new CSSMutableStyleDeclaration(0, m_values);
 729 }
 730
 731 } // namespace WebCore