WebCore/khtml/css/css_valueimpl.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) 2002 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., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include "dom/css_value.h"
  24 #include "dom/dom_exception.h"
  25 #include "dom/dom_string.h"
  26
  27 #include "css/css_valueimpl.h"
  28 #include "css/css_ruleimpl.h"
  29 #include "css/css_stylesheetimpl.h"
  30 #include "css/cssparser.h"
  31 #include "css/cssproperties.h"
  32 #include "css/cssvalues.h"
  33 #include "css/cssstyleselector.h"
  34
  35 #include "xml/dom_stringimpl.h"
  36 #include "xml/dom_docimpl.h"
  37
  38 #include "misc/loader.h"
  39
  40 #include "rendering/font.h"
  41 #include "rendering/render_style.h"
  42
  43 #include <kdebug.h>
  44 #include <qregexp.h>
  45 #include <qpaintdevice.h>
  46 #include <qpaintdevicemetrics.h>
  47
  48 // Hack for debugging purposes
  49 extern DOM::DOMString getPropertyName(unsigned short id);
  50
  51 using khtml::FontDef;
  52 using khtml::CSSStyleSelector;
  53
  54 using namespace DOM;
  55
  56 CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent)
  57     : StyleBaseImpl(parent)
  58 {
  59     m_lstValues = 0;
  60     m_node = 0;
  61 }
  62
  63 CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent, QPtrList<CSSProperty> *lstValues)
  64     : StyleBaseImpl(parent)
  65 {
  66     m_lstValues = lstValues;
  67     m_node = 0;
  68 }
  69
  70 CSSStyleDeclarationImpl&  CSSStyleDeclarationImpl::operator= (const CSSStyleDeclarationImpl& o)
  71 {
  72     // don't attach it to the same node, just leave the current m_node value
  73     delete m_lstValues;
  74     m_lstValues = 0;
  75     if (o.m_lstValues) {
  76         m_lstValues = new QPtrList<CSSProperty>;
  77         m_lstValues->setAutoDelete( true );
  78
  79         QPtrListIterator<CSSProperty> lstValuesIt(*o.m_lstValues);
  80         for (lstValuesIt.toFirst(); lstValuesIt.current(); ++lstValuesIt)
  81             m_lstValues->append(new CSSProperty(*lstValuesIt.current()));
  82     }
  83
  84     return *this;
  85 }
  86
  87 CSSStyleDeclarationImpl::~CSSStyleDeclarationImpl()
  88 {
  89     delete m_lstValues;
  90     // we don't use refcounting for m_node, to avoid cyclic references (see ElementImpl)
  91 }
  92
  93 DOMString CSSStyleDeclarationImpl::getPropertyValue( int propertyID ) const
  94 {
  95     if(!m_lstValues) return DOMString();
  96
  97     CSSValueImpl* value = getPropertyCSSValue( propertyID );
  98     if ( value )
  99         return value->cssText();
 100
 101     // Shorthand and 4-values properties
 102     switch ( propertyID ) {
 103     case CSS_PROP_BACKGROUND_POSITION:
 104     {
 105         // ## Is this correct? The code in cssparser.cpp is confusing
 106         const int properties[2] = { CSS_PROP_BACKGROUND_POSITION_X,
 107                                     CSS_PROP_BACKGROUND_POSITION_Y };
 108         return getShortHandValue( properties, 2 );
 109     }
 110     case CSS_PROP_BACKGROUND:
 111     {
 112         const int properties[5] = { CSS_PROP_BACKGROUND_IMAGE, CSS_PROP_BACKGROUND_REPEAT,
 113                                     CSS_PROP_BACKGROUND_ATTACHMENT, CSS_PROP_BACKGROUND_POSITION,
 114                                     CSS_PROP_BACKGROUND_COLOR };
 115         return getShortHandValue( properties, 5 );
 116     }
 117     case CSS_PROP_BORDER:
 118     {
 119         const int properties[3] = { CSS_PROP_BORDER_WIDTH, CSS_PROP_BORDER_STYLE,
 120                                     CSS_PROP_BORDER_COLOR };
 121         return getShortHandValue( properties, 3 );
 122     }
 123     case CSS_PROP_BORDER_TOP:
 124     {
 125         const int properties[3] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_TOP_STYLE,
 126                                     CSS_PROP_BORDER_TOP_COLOR};
 127         return getShortHandValue( properties, 3 );
 128     }
 129     case CSS_PROP_BORDER_RIGHT:
 130     {
 131         const int properties[3] = { CSS_PROP_BORDER_RIGHT_WIDTH, CSS_PROP_BORDER_RIGHT_STYLE,
 132                                     CSS_PROP_BORDER_RIGHT_COLOR};
 133         return getShortHandValue( properties, 3 );
 134     }
 135     case CSS_PROP_BORDER_BOTTOM:
 136     {
 137         const int properties[3] = { CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_BOTTOM_STYLE,
 138                                     CSS_PROP_BORDER_BOTTOM_COLOR};
 139         return getShortHandValue( properties, 3 );
 140     }
 141     case CSS_PROP_BORDER_LEFT:
 142     {
 143         const int properties[3] = { CSS_PROP_BORDER_LEFT_WIDTH, CSS_PROP_BORDER_LEFT_STYLE,
 144                                     CSS_PROP_BORDER_LEFT_COLOR};
 145         return getShortHandValue( properties, 3 );
 146     }
 147     case CSS_PROP_OUTLINE:
 148     {
 149         const int properties[3] = { CSS_PROP_OUTLINE_WIDTH, CSS_PROP_OUTLINE_STYLE,
 150                                     CSS_PROP_OUTLINE_COLOR };
 151         return getShortHandValue( properties, 3 );
 152     }
 153     case CSS_PROP_BORDER_COLOR:
 154     {
 155         const int properties[4] = { CSS_PROP_BORDER_TOP_COLOR, CSS_PROP_BORDER_RIGHT_COLOR,
 156                                     CSS_PROP_BORDER_BOTTOM_COLOR, CSS_PROP_BORDER_LEFT_COLOR };
 157         return get4Values( properties );
 158     }
 159     case CSS_PROP_BORDER_WIDTH:
 160     {
 161         const int properties[4] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_RIGHT_WIDTH,
 162                                     CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_LEFT_WIDTH };
 163         return get4Values( properties );
 164     }
 165     case CSS_PROP_BORDER_STYLE:
 166     {
 167         const int properties[4] = { CSS_PROP_BORDER_TOP_STYLE, CSS_PROP_BORDER_RIGHT_STYLE,
 168                                     CSS_PROP_BORDER_BOTTOM_STYLE, CSS_PROP_BORDER_LEFT_STYLE };
 169         return get4Values( properties );
 170     }
 171     case CSS_PROP_MARGIN:
 172     {
 173         const int properties[4] = { CSS_PROP_MARGIN_TOP, CSS_PROP_MARGIN_RIGHT,
 174                                     CSS_PROP_MARGIN_BOTTOM, CSS_PROP_MARGIN_LEFT };
 175         return get4Values( properties );
 176     }
 177     case CSS_PROP_PADDING:
 178     {
 179         const int properties[4] = { CSS_PROP_PADDING_TOP, CSS_PROP_PADDING_RIGHT,
 180                                     CSS_PROP_PADDING_BOTTOM, CSS_PROP_PADDING_LEFT };
 181         return get4Values( properties );
 182     }
 183     case CSS_PROP_LIST_STYLE:
 184     {
 185         const int properties[3] = { CSS_PROP_LIST_STYLE_TYPE, CSS_PROP_LIST_STYLE_POSITION,
 186                                     CSS_PROP_LIST_STYLE_IMAGE };
 187         return getShortHandValue( properties, 3 );
 188     }
 189     }
 190     //kdDebug() << k_funcinfo << "property not found:" << propertyID << endl;
 191     return DOMString();
 192 }
 193
 194 DOMString CSSStyleDeclarationImpl::get4Values( const int* properties ) const
 195 {
 196     DOMString res;
 197     for ( int i = 0 ; i < 4 ; ++i ) {
 198         CSSValueImpl* value = getPropertyCSSValue( properties[i] );
 199         if ( !value ) { // apparently all 4 properties must be specified.
 200             return DOMString();
 201         }
 202         if ( i > 0 )
 203             res += " ";
 204         res += value->cssText();
 205     }
 206     return res;
 207 }
 208
 209 DOMString CSSStyleDeclarationImpl::getShortHandValue( const int* properties, int number ) const
 210 {
 211     DOMString res;
 212     for ( int i = 0 ; i < number ; ++i ) {
 213         CSSValueImpl* value = getPropertyCSSValue( properties[i] );
 214         if ( value ) { // TODO provide default value if !value
 215             if ( !res.isNull() )
 216                 res += " ";
 217             res += value->cssText();
 218         }
 219     }
 220     return res;
 221 }
 222
 223  CSSValueImpl *CSSStyleDeclarationImpl::getPropertyCSSValue( int propertyID ) const
 224 {
 225     if(!m_lstValues) return 0;
 226
 227     QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
 228     CSSProperty *current;
 229     for ( lstValuesIt.toLast(); (current = lstValuesIt.current()); --lstValuesIt )
 230         if (current->m_id == propertyID)
 231             return current->value();
 232     return 0;
 233 }
 234
 235 DOMString CSSStyleDeclarationImpl::removeProperty(int propertyID, bool notifyChanged)
 236 {
 237     if(!m_lstValues) return DOMString();
 238     DOMString value;
 239
 240     QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
 241      CSSProperty *current;
 242      for ( lstValuesIt.toLast(); (current = lstValuesIt.current()); --lstValuesIt )
 243          if (current->m_id == propertyID) {
 244              value = current->value()->cssText();
 245              m_lstValues->removeRef(current);
 246              if (notifyChanged)
 247                  setChanged();
 248              break;
 249         }
 250
 251     return value;
 252 }
 253
 254 void CSSStyleDeclarationImpl::setChanged()
 255 {
 256     if (m_node) {
 257         m_node->setChanged();
 258         return;
 259     }
 260
 261     // ### quick&dirty hack for KDE 3.0... make this MUCH better! (Dirk)
 262     for (StyleBaseImpl* stylesheet = this; stylesheet; stylesheet = stylesheet->parent())
 263         if (stylesheet->isCSSStyleSheet()) {
 264             static_cast<CSSStyleSheetImpl*>(stylesheet)->doc()->updateStyleSelector();
 265             break;
 266         }
 267 }
 268
 269 bool CSSStyleDeclarationImpl::getPropertyPriority( int propertyID ) const
 270 {
 271     if ( m_lstValues) {
 272         QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
 273         CSSProperty *current;
 274         for ( lstValuesIt.toFirst(); (current = lstValuesIt.current()); ++lstValuesIt ) {
 275             if( propertyID == current->m_id )
 276                 return current->m_bImportant;
 277         }
 278     }
 279     return false;
 280 }
 281
 282 bool CSSStyleDeclarationImpl::setProperty(int id, const DOMString &value, bool important, bool notifyChanged)
 283 {
 284     if(!m_lstValues) {
 285         m_lstValues = new QPtrList<CSSProperty>;
 286         m_lstValues->setAutoDelete(true);
 287     }
 288     removeProperty(id);
 289
 290     CSSParser parser( strictParsing );
 291     bool success = parser.parseValue(this, id, value, important);
 292     if(!success)
 293         kdDebug( 6080 ) << "CSSStyleDeclarationImpl::setProperty invalid property: [" << getPropertyName(id).string()
 294                         << "] value: [" << value.string() << "]"<< endl;
 295     else if (notifyChanged)
 296         setChanged();
 297     return success;
 298 }
 299
 300 void CSSStyleDeclarationImpl::setProperty(int id, int value, bool important, bool notifyChanged)
 301 {
 302     if(!m_lstValues) {
 303         m_lstValues = new QPtrList<CSSProperty>;
 304         m_lstValues->setAutoDelete(true);
 305     }
 306     removeProperty(id);
 307
 308     CSSValueImpl * cssValue = new CSSPrimitiveValueImpl(value);
 309     setParsedValue(id, cssValue, important, m_lstValues);
 310     if (notifyChanged)
 311         setChanged();
 312 }
 313
 314 void CSSStyleDeclarationImpl::setStringProperty(int propertyId, const DOMString &value, CSSPrimitiveValue::UnitTypes type, bool important)
 315 {
 316     if (!m_lstValues) {
 317         m_lstValues = new QPtrList<CSSProperty>;
 318         m_lstValues->setAutoDelete(true);
 319     }
 320     removeProperty(propertyId);
 321     setParsedValue(propertyId, new CSSPrimitiveValueImpl(value, type), important, m_lstValues);
 322     setChanged();
 323 }
 324
 325 void CSSStyleDeclarationImpl::setImageProperty(int propertyId, const DOMString &URL, bool important)
 326 {
 327     if (!m_lstValues) {
 328         m_lstValues = new QPtrList<CSSProperty>;
 329         m_lstValues->setAutoDelete(true);
 330     }
 331     removeProperty(propertyId);
 332     setParsedValue(propertyId, new CSSImageValueImpl(URL, this), important, m_lstValues);
 333     setChanged();
 334 }
 335
 336 void CSSStyleDeclarationImpl::setProperty ( const DOMString &propertyString)
 337 {
 338     if(!m_lstValues) {
 339         m_lstValues = new QPtrList<CSSProperty>;
 340         m_lstValues->setAutoDelete( true );
 341     }
 342
 343     CSSParser parser(strictParsing);
 344     parser.parseDeclaration(this, propertyString);
 345     setChanged();
 346 }
 347
 348 void CSSStyleDeclarationImpl::setLengthProperty(int id, const DOM::DOMString &value, bool important, bool _multiLength )
 349 {
 350     bool parseMode = strictParsing;
 351     strictParsing = false;
 352     multiLength = _multiLength;
 353     setProperty( id, value, important);
 354     strictParsing = parseMode;
 355     multiLength = false;
 356 }
 357
 358 unsigned long CSSStyleDeclarationImpl::length() const
 359 {
 360     return m_lstValues ? m_lstValues->count() : 0;
 361 }
 362
 363 DOMString CSSStyleDeclarationImpl::item( unsigned long /*index*/ )
 364 {
 365     // ###
 366     //return m_lstValues->at(index);
 367     return DOMString();
 368 }
 369
 370 CSSRuleImpl *CSSStyleDeclarationImpl::parentRule() const
 371 {
 372     return (m_parent && m_parent->isRule() ) ?
 373         static_cast<CSSRuleImpl *>(m_parent) : 0;
 374 }
 375
 376 DOM::DOMString CSSStyleDeclarationImpl::cssText() const
 377 {
 378     DOMString result;
 379
 380     if ( m_lstValues) {
 381         QPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
 382         CSSProperty *current;
 383         for ( lstValuesIt.toFirst(); (current = lstValuesIt.current()); ++lstValuesIt )
 384             result += current->cssText();
 385     }
 386
 387     return result;
 388 }
 389
 390 void CSSStyleDeclarationImpl::setCssText(const DOM::DOMString& text)
 391 {
 392     if (m_lstValues)
 393         m_lstValues->clear();
 394     else {
 395         m_lstValues = new QPtrList<CSSProperty>;
 396         m_lstValues->setAutoDelete(true);
 397     }
 398
 399     CSSParser parser(strictParsing);
 400     parser.parseDeclaration(this, text);
 401     setChanged();
 402 }
 403
 404 bool CSSStyleDeclarationImpl::parseString( const DOMString &/*string*/, bool )
 405 {
 406     return false;
 407     // ###
 408 }
 409
 410 void CSSStyleDeclarationImpl::merge(CSSStyleDeclarationImpl *other, bool argOverridesOnConflict)
 411 {
 412     for (QPtrListIterator<CSSProperty> it(*(other->values())); it.current(); ++it) {
 413         CSSProperty *property = it.current();
 414         if (getPropertyCSSValue(property->id())) {
 415             if (!argOverridesOnConflict)
 416                 continue;
 417             removeProperty(property->id());
 418         }
 419         if (!m_lstValues) {
 420             m_lstValues = new QPtrList<CSSProperty>;
 421             m_lstValues->setAutoDelete(true);
 422         }
 423         m_lstValues->append(new CSSProperty(*property));
 424     }
 425 }
 426
 427 // --------------------------------------------------------------------------------------
 428
 429 CSSValueImpl::CSSValueImpl()
 430     : StyleBaseImpl()
 431 {
 432 }
 433
 434 CSSValueImpl::~CSSValueImpl()
 435 {
 436 }
 437
 438 unsigned short CSSInheritedValueImpl::cssValueType() const
 439 {
 440     return CSSValue::CSS_INHERIT;
 441 }
 442
 443 DOM::DOMString CSSInheritedValueImpl::cssText() const
 444 {
 445     return DOMString("inherit");
 446 }
 447
 448 unsigned short CSSInitialValueImpl::cssValueType() const
 449 {
 450     return CSSValue::CSS_INITIAL;
 451 }
 452
 453 DOM::DOMString CSSInitialValueImpl::cssText() const
 454 {
 455     return DOMString("initial");
 456 }
 457
 458 // ----------------------------------------------------------------------------------------
 459
 460 CSSValueListImpl::CSSValueListImpl()
 461     : CSSValueImpl()
 462 {
 463 }
 464
 465 CSSValueListImpl::~CSSValueListImpl()
 466 {
 467     CSSValueImpl *val = m_values.first();
 468     while( val ) {
 469         val->deref();
 470         val = m_values.next();
 471     }
 472 }
 473
 474 unsigned short CSSValueListImpl::cssValueType() const
 475 {
 476     return CSSValue::CSS_VALUE_LIST;
 477 }
 478
 479 void CSSValueListImpl::append(CSSValueImpl *val)
 480 {
 481     m_values.append(val);
 482     val->ref();
 483 }
 484
 485 DOM::DOMString CSSValueListImpl::cssText() const
 486 {
 487     DOMString result = "";
 488
 489     for (QPtrListIterator<CSSValueImpl> iterator(m_values); iterator.current(); ++iterator) {
 490         if (result.length() != 0) {
 491             result += ", ";
 492         }
 493         result += iterator.current()->cssText();
 494     }
 495
 496     return result;
 497 }
 498
 499 // -------------------------------------------------------------------------------------
 500
 501 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl()
 502     : CSSValueImpl()
 503 {
 504     m_type = 0;
 505 }
 506
 507 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(int ident)
 508     : CSSValueImpl()
 509 {
 510     m_value.ident = ident;
 511     m_type = CSSPrimitiveValue::CSS_IDENT;
 512 }
 513
 514 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type)
 515 {
 516     m_value.num = num;
 517     m_type = type;
 518 }
 519
 520 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(const DOMString &str, CSSPrimitiveValue::UnitTypes type)
 521 {
 522     m_value.string = str.implementation();
 523     if(m_value.string) m_value.string->ref();
 524     m_type = type;
 525 }
 526
 527 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(const Counter &c)
 528 {
 529     m_value.counter = c.handle();
 530     if (m_value.counter)
 531         m_value.counter->ref();
 532     m_type = CSSPrimitiveValue::CSS_COUNTER;
 533 }
 534
 535 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl( RectImpl *r)
 536 {
 537     m_value.rect = r;
 538     if (m_value.rect)
 539         m_value.rect->ref();
 540     m_type = CSSPrimitiveValue::CSS_RECT;
 541 }
 542
 543 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl( DashboardRegionImpl *r)
 544 {
 545     m_value.region = r;
 546     if (m_value.region)
 547         m_value.region->ref();
 548     m_type = CSSPrimitiveValue::CSS_DASHBOARD_REGION;
 549 }
 550
 551 CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(QRgb color)
 552 {
 553     m_value.rgbcolor = color;
 554     m_type = CSSPrimitiveValue::CSS_RGBCOLOR;
 555 }
 556
 557 CSSPrimitiveValueImpl::~CSSPrimitiveValueImpl()
 558 {
 559     cleanup();
 560 }
 561
 562 void CSSPrimitiveValueImpl::cleanup()
 563 {
 564     switch(m_type) {
 565     case CSSPrimitiveValue::CSS_STRING:
 566     case CSSPrimitiveValue::CSS_URI:
 567     case CSSPrimitiveValue::CSS_ATTR:
 568         if(m_value.string) m_value.string->deref();
 569         break;
 570     case CSSPrimitiveValue::CSS_COUNTER:
 571         m_value.counter->deref();
 572         break;
 573     case CSSPrimitiveValue::CSS_RECT:
 574         m_value.rect->deref();
 575     default:
 576         break;
 577     }
 578
 579     m_type = 0;
 580 }
 581
 582 int CSSPrimitiveValueImpl::computeLength( khtml::RenderStyle *style, QPaintDeviceMetrics *devMetrics )
 583 {
 584     double result = computeLengthFloat( style, devMetrics );
 585 #if APPLE_CHANGES
 586     // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
 587     // need to go ahead and round if we're really close to the next integer value.
 588     int intResult = (int)(result + (result < 0 ? -0.01 : +0.01));
 589 #else
 590     int intResult = (int)result;
 591 #endif
 592     return intResult;
 593 }
 594
 595 int CSSPrimitiveValueImpl::computeLength( khtml::RenderStyle *style, QPaintDeviceMetrics *devMetrics,
 596                                           double multiplier )
 597 {
 598     double result = multiplier * computeLengthFloat( style, devMetrics );
 599 #if APPLE_CHANGES
 600     // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
 601     // need to go ahead and round if we're really close to the next integer value.
 602     int intResult = (int)(result + (result < 0 ? -0.01 : +0.01));
 603 #else
 604     int intResult = (int)result;
 605 #endif
 606     return intResult;
 607 }
 608
 609 double CSSPrimitiveValueImpl::computeLengthFloat( khtml::RenderStyle *style, QPaintDeviceMetrics *devMetrics,
 610                                                   bool applyZoomFactor )
 611 {
 612     unsigned short type = primitiveType();
 613
 614     double dpiY = 72.; // fallback
 615     if ( devMetrics )
 616         dpiY = devMetrics->logicalDpiY();
 617     if ( !khtml::printpainter && dpiY < 96 )
 618         dpiY = 96.;
 619
 620     double factor = 1.;
 621     switch(type)
 622     {
 623     case CSSPrimitiveValue::CSS_EMS:
 624         factor = applyZoomFactor ?
 625           style->htmlFont().getFontDef().computedSize :
 626           style->htmlFont().getFontDef().specifiedSize;
 627         break;
 628     case CSSPrimitiveValue::CSS_EXS:
 629         // FIXME: We have a bug right now where the zoom will be applied multiple times to EX units.
 630         // We really need to compute EX using fontMetrics for the original specifiedSize and not use
 631         // our actual constructed rendering font.
 632         {
 633         QFontMetrics fm = style->fontMetrics();
 634 #if APPLE_CHANGES
 635         factor = fm.xHeight();
 636 #else
 637         QRect b = fm.boundingRect('x');
 638         factor = b.height();
 639 #endif
 640         break;
 641         }
 642     case CSSPrimitiveValue::CSS_PX:
 643         break;
 644     case CSSPrimitiveValue::CSS_CM:
 645         factor = dpiY/2.54; //72dpi/(2.54 cm/in)
 646         break;
 647     case CSSPrimitiveValue::CSS_MM:
 648         factor = dpiY/25.4;
 649         break;
 650     case CSSPrimitiveValue::CSS_IN:
 651             factor = dpiY;
 652         break;
 653     case CSSPrimitiveValue::CSS_PT:
 654             factor = dpiY/72.;
 655         break;
 656     case CSSPrimitiveValue::CSS_PC:
 657         // 1 pc == 12 pt
 658             factor = dpiY*12./72.;
 659         break;
 660     default:
 661         return -1;
 662     }
 663
 664     return getFloatValue(type)*factor;
 665 }
 666
 667 void CSSPrimitiveValueImpl::setFloatValue( unsigned short unitType, double floatValue, int &exceptioncode )
 668 {
 669     exceptioncode = 0;
 670     cleanup();
 671     // ### check if property supports this type
 672     if(m_type > CSSPrimitiveValue::CSS_DIMENSION) {
 673         exceptioncode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
 674         return;
 675     }
 676     //if(m_type > CSSPrimitiveValue::CSS_DIMENSION) throw DOMException(DOMException::INVALID_ACCESS_ERR);
 677     m_value.num = floatValue;
 678     m_type = unitType;
 679 }
 680
 681 void CSSPrimitiveValueImpl::setStringValue( unsigned short stringType, const DOMString &stringValue, int &exceptioncode )
 682 {
 683     exceptioncode = 0;
 684     cleanup();
 685     //if(m_type < CSSPrimitiveValue::CSS_STRING) throw DOMException(DOMException::INVALID_ACCESS_ERR);
 686     //if(m_type > CSSPrimitiveValue::CSS_ATTR) throw DOMException(DOMException::INVALID_ACCESS_ERR);
 687     if(m_type < CSSPrimitiveValue::CSS_STRING || m_type >> CSSPrimitiveValue::CSS_ATTR) {
 688         exceptioncode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
 689         return;
 690     }
 691     if(stringType != CSSPrimitiveValue::CSS_IDENT)
 692     {
 693         m_value.string = stringValue.implementation();
 694         m_value.string->ref();
 695         m_type = stringType;
 696     }
 697     // ### parse ident
 698 }
 699
 700 DOMString CSSPrimitiveValueImpl::getStringValue() const
 701 {
 702     switch (m_type) {
 703         case CSSPrimitiveValue::CSS_STRING:
 704         case CSSPrimitiveValue::CSS_ATTR:
 705         case CSSPrimitiveValue::CSS_URI:
 706             return m_value.string;
 707         case CSSPrimitiveValue::CSS_IDENT:
 708             return getValueName(m_value.ident);
 709         default:
 710             // FIXME: The CSS 2.1 spec says you should throw an exception here.
 711             break;
 712     }
 713
 714     return DOMString();
 715 }
 716
 717 unsigned short CSSPrimitiveValueImpl::cssValueType() const
 718 {
 719     return CSSValue::CSS_PRIMITIVE_VALUE;
 720 }
 721
 722 bool CSSPrimitiveValueImpl::parseString( const DOMString &/*string*/, bool )
 723 {
 724     // ###
 725     return false;
 726 }
 727
 728 int CSSPrimitiveValueImpl::getIdent()
 729 {
 730     if(m_type != CSSPrimitiveValue::CSS_IDENT) return 0;
 731     return m_value.ident;
 732 }
 733
 734 DOM::DOMString CSSPrimitiveValueImpl::cssText() const
 735 {
 736     // ### return the original value instead of a generated one (e.g. color
 737     // name if it was specified) - check what spec says about this
 738     DOMString text;
 739     switch ( m_type ) {
 740         case CSSPrimitiveValue::CSS_UNKNOWN:
 741             // ###
 742             break;
 743         case CSSPrimitiveValue::CSS_NUMBER:
 744             text = DOMString(QString::number( (int)m_value.num ));
 745             break;
 746         case CSSPrimitiveValue::CSS_PERCENTAGE:
 747             text = DOMString(QString::number( m_value.num ) + "%");
 748             break;
 749         case CSSPrimitiveValue::CSS_EMS:
 750             text = DOMString(QString::number( m_value.num ) + "em");
 751             break;
 752         case CSSPrimitiveValue::CSS_EXS:
 753             text = DOMString(QString::number( m_value.num ) + "ex");
 754             break;
 755         case CSSPrimitiveValue::CSS_PX:
 756             text = DOMString(QString::number( m_value.num ) + "px");
 757             break;
 758         case CSSPrimitiveValue::CSS_CM:
 759             text = DOMString(QString::number( m_value.num ) + "cm");
 760             break;
 761         case CSSPrimitiveValue::CSS_MM:
 762             text = DOMString(QString::number( m_value.num ) + "mm");
 763             break;
 764         case CSSPrimitiveValue::CSS_IN:
 765             text = DOMString(QString::number( m_value.num ) + "in");
 766             break;
 767         case CSSPrimitiveValue::CSS_PT:
 768             text = DOMString(QString::number( m_value.num ) + "pt");
 769             break;
 770         case CSSPrimitiveValue::CSS_PC:
 771             text = DOMString(QString::number( m_value.num ) + "pc");
 772             break;
 773         case CSSPrimitiveValue::CSS_DEG:
 774             text = DOMString(QString::number( m_value.num ) + "deg");
 775             break;
 776         case CSSPrimitiveValue::CSS_RAD:
 777             text = DOMString(QString::number( m_value.num ) + "rad");
 778             break;
 779         case CSSPrimitiveValue::CSS_GRAD:
 780             text = DOMString(QString::number( m_value.num ) + "grad");
 781             break;
 782         case CSSPrimitiveValue::CSS_MS:
 783             text = DOMString(QString::number( m_value.num ) + "ms");
 784             break;
 785         case CSSPrimitiveValue::CSS_S:
 786             text = DOMString(QString::number( m_value.num ) + "s");
 787             break;
 788         case CSSPrimitiveValue::CSS_HZ:
 789             text = DOMString(QString::number( m_value.num ) + "hz");
 790             break;
 791         case CSSPrimitiveValue::CSS_KHZ:
 792             text = DOMString(QString::number( m_value.num ) + "khz");
 793             break;
 794         case CSSPrimitiveValue::CSS_DIMENSION:
 795             // ###
 796             break;
 797         case CSSPrimitiveValue::CSS_STRING:
 798             text = DOMString(m_value.string);
 799             break;
 800         case CSSPrimitiveValue::CSS_URI:
 801             text  = "url(";
 802             text += DOMString( m_value.string );
 803             text += ")";
 804             break;
 805         case CSSPrimitiveValue::CSS_IDENT:
 806             text = getValueName(m_value.ident);
 807             break;
 808         case CSSPrimitiveValue::CSS_ATTR:
 809             // ###
 810             break;
 811         case CSSPrimitiveValue::CSS_COUNTER:
 812             // ###
 813             break;
 814         case CSSPrimitiveValue::CSS_RECT: {
 815             RectImpl* rectVal = getRectValue();
 816             text = "rect(";
 817             text += rectVal->top()->cssText() + " ";
 818             text += rectVal->right()->cssText() + " ";
 819             text += rectVal->bottom()->cssText() + " ";
 820             text += rectVal->left()->cssText() + ")";
 821             break;
 822         }
 823         case CSSPrimitiveValue::CSS_RGBCOLOR: {
 824             QColor color(m_value.rgbcolor);
 825             if (qAlpha(m_value.rgbcolor) < 0xFF)
 826                 text = "rgba(";
 827             else
 828                 text = "rgb(";
 829             text += QString::number(color.red()) + ", ";
 830             text += QString::number(color.green()) + ", ";
 831             text += QString::number(color.blue());
 832             if (qAlpha(m_value.rgbcolor) < 0xFF)
 833                 text += ", " + QString::number((float)qAlpha(m_value.rgbcolor) / 0xFF);
 834             text += ")";
 835             break;
 836         }
 837 #if APPLE_CHANGES
 838         case CSSPrimitiveValue::CSS_DASHBOARD_REGION: {
 839             DashboardRegionImpl *region = getDashboardRegionValue();
 840             while (region) {
 841                 text = "dashboard-region(";
 842                 text += region->m_label;
 843                 if (region->m_isCircle){
 844                     text += " circle ";
 845                 }
 846                 else if (region->m_isRectangle){
 847                     text += " rectangle ";
 848                 }
 849                 else
 850                     break;
 851                 text += region->top()->cssText() + " ";
 852                 text += region->right()->cssText() + " ";
 853                 text += region->bottom()->cssText() + " ";
 854                 text += region->left()->cssText();
 855                 text += ")";
 856                 region = region->m_next;
 857             }
 858             break;
 859         }
 860 #endif
 861     }
 862     return text;
 863 }
 864
 865 // -----------------------------------------------------------------
 866
 867 RectImpl::RectImpl()
 868 {
 869     m_top = 0;
 870     m_right = 0;
 871     m_bottom = 0;
 872     m_left = 0;
 873 }
 874
 875 RectImpl::~RectImpl()
 876 {
 877     if (m_top) m_top->deref();
 878     if (m_right) m_right->deref();
 879     if (m_bottom) m_bottom->deref();
 880     if (m_left) m_left->deref();
 881 }
 882
 883 void RectImpl::setTop( CSSPrimitiveValueImpl *top )
 884 {
 885     if( top ) top->ref();
 886     if ( m_top ) m_top->deref();
 887     m_top = top;
 888 }
 889
 890 void RectImpl::setRight( CSSPrimitiveValueImpl *right )
 891 {
 892     if( right ) right->ref();
 893     if ( m_right ) m_right->deref();
 894     m_right = right;
 895 }
 896
 897 void RectImpl::setBottom( CSSPrimitiveValueImpl *bottom )
 898 {
 899     if( bottom ) bottom->ref();
 900     if ( m_bottom ) m_bottom->deref();
 901     m_bottom = bottom;
 902 }
 903
 904 void RectImpl::setLeft( CSSPrimitiveValueImpl *left )
 905 {
 906     if( left ) left->ref();
 907     if ( m_left ) m_left->deref();
 908     m_left = left;
 909 }
 910
 911 // -----------------------------------------------------------------
 912
 913 CSSImageValueImpl::CSSImageValueImpl(const DOMString &url, StyleBaseImpl *style)
 914     : CSSPrimitiveValueImpl(url, CSSPrimitiveValue::CSS_URI), m_image(0), m_accessedImage(false)
 915 {
 916 }
 917
 918 CSSImageValueImpl::CSSImageValueImpl()
 919     : CSSPrimitiveValueImpl(CSS_VAL_NONE), m_image(0), m_accessedImage(true)
 920 {
 921 }
 922
 923 CSSImageValueImpl::~CSSImageValueImpl()
 924 {
 925     if(m_image) m_image->deref(this);
 926 }
 927
 928 khtml::CachedImage* CSSImageValueImpl::image(khtml::DocLoader* loader)
 929 {
 930     if (!m_accessedImage) {
 931         m_accessedImage = true;
 932
 933         if (loader)
 934             m_image = loader->requestImage(getStringValue());
 935         else
 936             m_image = khtml::Cache::requestImage(0, getStringValue());
 937
 938         if(m_image) m_image->ref(this);
 939     }
 940
 941     return m_image;
 942 }
 943
 944 // ------------------------------------------------------------------------
 945
 946 FontFamilyValueImpl::FontFamilyValueImpl( const QString &string)
 947 : CSSPrimitiveValueImpl( DOMString(), CSSPrimitiveValue::CSS_STRING)
 948 {
 949     static const QRegExp parenReg(" \\(.*\\)$");
 950     static const QRegExp braceReg(" \\[.*\\]$");
 951
 952 #if APPLE_CHANGES
 953     parsedFontName = string;
 954     // a language tag is often added in braces at the end. Remove it.
 955     parsedFontName.replace(parenReg, "");
 956     // remove [Xft] qualifiers
 957     parsedFontName.replace(braceReg, "");
 958 #else
 959     const QString &available = KHTMLSettings::availableFamilies();
 960
 961     QString face = string.lower();
 962     // a languge tag is often added in braces at the end. Remove it.
 963     face = face.replace(parenReg, "");
 964     // remove [Xft] qualifiers
 965     face = face.replace(braceReg, "");
 966     //kdDebug(0) << "searching for face '" << face << "'" << endl;
 967
 968     int pos = available.find( face, 0, false );
 969     if( pos == -1 ) {
 970         QString str = face;
 971         int p = face.find(' ');
 972         // Arial Blk --> Arial
 973         // MS Sans Serif --> Sans Serif
 974         if ( p != -1 ) {
 975             if(p > 0 && (int)str.length() - p > p + 1)
 976                 str = str.mid( p+1 );
 977             else
 978                 str.truncate( p );
 979             pos = available.find( str, 0, false);
 980         }
 981     }
 982
 983     if ( pos != -1 ) {
 984         int pos1 = available.findRev( ',', pos ) + 1;
 985         pos = available.find( ',', pos );
 986         if ( pos == -1 )
 987             pos = available.length();
 988         parsedFontName = available.mid( pos1, pos - pos1 );
 989     }
 990 #endif // !APPLE_CHANGES
 991 }
 992
 993 DOM::DOMString FontFamilyValueImpl::cssText() const
 994 {
 995     return parsedFontName;
 996 }
 997
 998 FontValueImpl::FontValueImpl()
 999     : style(0), variant(0), weight(0), size(0), lineHeight(0), family(0)
1000 {
1001 }
1002
1003 FontValueImpl::~FontValueImpl()
1004 {
1005     delete style;
1006     delete variant;
1007     delete weight;
1008     delete size;
1009     delete lineHeight;
1010     delete family;
1011 }
1012
1013 DOMString FontValueImpl::cssText() const
1014 {
1015     // font variant weight size / line-height family
1016
1017     DOMString result("");
1018
1019     if (style) {
1020         result += style->cssText();
1021     }
1022     if (variant) {
1023         if (result.length() > 0) {
1024             result += " ";
1025         }
1026         result += variant->cssText();
1027     }
1028     if (weight) {
1029         if (result.length() > 0) {
1030             result += " ";
1031         }
1032         result += weight->cssText();
1033     }
1034     if (size) {
1035         if (result.length() > 0) {
1036             result += " ";
1037         }
1038         result += size->cssText();
1039     }
1040     if (lineHeight) {
1041         if (!size) {
1042             result += " ";
1043         }
1044         result += "/";
1045         result += lineHeight->cssText();
1046     }
1047     if (family) {
1048         if (result.length() > 0) {
1049             result += " ";
1050         }
1051         result += family->cssText();
1052     }
1053
1054     return result;
1055 }
1056
1057
1058 // Used for text-shadow and box-shadow
1059 ShadowValueImpl::ShadowValueImpl(CSSPrimitiveValueImpl* _x, CSSPrimitiveValueImpl* _y,
1060                                  CSSPrimitiveValueImpl* _blur, CSSPrimitiveValueImpl* _color)
1061 :x(_x), y(_y), blur(_blur), color(_color)
1062 {}
1063
1064 ShadowValueImpl::~ShadowValueImpl()
1065 {
1066     delete x;
1067     delete y;
1068     delete blur;
1069     delete color;
1070 }
1071
1072 DOMString ShadowValueImpl::cssText() const
1073 {
1074     DOMString text("");
1075     if (color) {
1076         text += color->cssText();
1077     }
1078     if (x) {
1079         if (text.length() > 0) {
1080             text += " ";
1081         }
1082         text += x->cssText();
1083     }
1084     if (y) {
1085         if (text.length() > 0) {
1086             text += " ";
1087         }
1088         text += y->cssText();
1089     }
1090     if (blur) {
1091         if (text.length() > 0) {
1092             text += " ";
1093         }
1094         text += blur->cssText();
1095     }
1096
1097     return text;
1098 }
1099
1100 // Used for box-flex-transition-group
1101 FlexGroupTransitionValueImpl::FlexGroupTransitionValueImpl()
1102 :autoValue(true), group1(0), group2(0), length(0)
1103 {}
1104
1105 FlexGroupTransitionValueImpl::FlexGroupTransitionValueImpl(unsigned int _group1,
1106                                                            unsigned int _group2,
1107                                                            CSSPrimitiveValueImpl* _length)
1108 :autoValue(false), group1(_group1), group2(_group2), length(_length)
1109 {}
1110
1111 FlexGroupTransitionValueImpl::~FlexGroupTransitionValueImpl()
1112 {
1113     delete length;
1114 }
1115
1116 DOMString FlexGroupTransitionValueImpl::cssText() const
1117 {
1118     DOMString text(QString::number(group1));
1119     if (group2) {
1120         text += "/";
1121         text += QString::number(group2);
1122     }
1123     if (length) {
1124         text += " ";
1125         text += length->cssText();
1126     }
1127     return text;
1128 }
1129
1130 DOMString CSSProperty::cssText() const
1131 {
1132     return getPropertyName(m_id) + DOMString(": ") + m_value->cssText() + (m_bImportant ? DOMString(" !important") : DOMString()) + DOMString("; ");
1133 }