khtml/dom/css_value.cpp

   1 /*
   2  * This file is part of the DOM implementation for KDE.
   3  *
   4  * Copyright 1999 Lars Knoll (knoll@kde.org)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #include "dom/css_rule.h"
  24 #include "dom/dom_exception.h"
  25
  26 #include "css/css_renderstyledeclarationimpl.h"
  27 #include "css/css_valueimpl.h"
  28
  29 namespace DOM {
  30
  31 CSSStyleDeclaration::CSSStyleDeclaration()
  32 {
  33     impl = 0;
  34 }
  35
  36 CSSStyleDeclaration::CSSStyleDeclaration(const CSSStyleDeclaration &other)
  37 {
  38     impl = other.impl;
  39     if(impl) impl->ref();
  40 }
  41
  42 CSSStyleDeclaration::CSSStyleDeclaration(CSSStyleDeclarationImpl *i)
  43 {
  44     impl = i;
  45     if(impl) impl->ref();
  46 }
  47
  48 CSSStyleDeclaration &CSSStyleDeclaration::operator = (const CSSStyleDeclaration &other)
  49 {
  50     if ( impl != other.impl ) {
  51         if(impl) impl->deref();
  52         impl = other.impl;
  53         if(impl) impl->ref();
  54     }
  55     return *this;
  56 }
  57
  58 CSSStyleDeclaration::~CSSStyleDeclaration()
  59 {
  60     if(impl) impl->deref();
  61 }
  62
  63 DOMString CSSStyleDeclaration::cssText() const
  64 {
  65     if(!impl) return DOMString();
  66     return static_cast<CSSStyleDeclarationImpl *>(impl)->cssText();
  67 }
  68
  69 void CSSStyleDeclaration::setCssText( const DOMString &value )
  70 {
  71     if(!impl) return;
  72     impl->setCssText(value);
  73 }
  74
  75 DOMString CSSStyleDeclaration::getPropertyValue( const DOMString &propertyName ) const
  76 {
  77     if(!impl) return DOMString();
  78     return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyValue(propertyName);
  79 }
  80
  81 CSSValue CSSStyleDeclaration::getPropertyCSSValue( const DOMString &propertyName ) const
  82 {
  83     if(!impl) return 0;
  84     return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyCSSValue(propertyName);
  85 }
  86
  87 DOMString CSSStyleDeclaration::removeProperty( const DOMString &propertyName )
  88 {
  89     if(!impl) return DOMString();
  90     return static_cast<CSSStyleDeclarationImpl *>(impl)->removeProperty(propertyName);
  91 }
  92
  93 DOMString CSSStyleDeclaration::getPropertyPriority( const DOMString &propertyName ) const
  94 {
  95     if(!impl) return DOMString();
  96     return impl->getPropertyPriority(propertyName);
  97 }
  98
  99 void CSSStyleDeclaration::setProperty( const DOMString &propName, const DOMString &value, const DOMString &priority )
 100 {
 101     if(!impl) return;
 102     static_cast<CSSStyleDeclarationImpl *>(impl)->setProperty( propName, value, priority );
 103 }
 104
 105 unsigned long CSSStyleDeclaration::length() const
 106 {
 107     if(!impl) return 0;
 108     return static_cast<CSSStyleDeclarationImpl *>(impl)->length();
 109 }
 110
 111 DOMString CSSStyleDeclaration::item( unsigned long index )
 112 {
 113     return const_cast<const CSSStyleDeclaration*>( this )->item( index );
 114 }
 115
 116 DOMString CSSStyleDeclaration::item( unsigned long index ) const
 117 {
 118     if(!impl) return DOMString();
 119     return static_cast<CSSStyleDeclarationImpl *>(impl)->item( index );
 120 }
 121 CSSRule CSSStyleDeclaration::parentRule() const
 122 {
 123     if(!impl) return 0;
 124     return static_cast<CSSStyleDeclarationImpl *>(impl)->parentRule();
 125 }
 126
 127 CSSStyleDeclarationImpl *CSSStyleDeclaration::handle() const
 128 {
 129     return impl;
 130 }
 131
 132 bool CSSStyleDeclaration::isNull() const
 133 {
 134     return (impl == 0);
 135 }
 136
 137 // ----------------------------------------------------------
 138
 139 CSSValue::CSSValue()
 140 {
 141     impl = 0;
 142 }
 143
 144 CSSValue::CSSValue(const CSSValue &other)
 145 {
 146     impl = other.impl;
 147     if(impl) impl->ref();
 148 }
 149
 150 CSSValue::CSSValue(CSSValueImpl *i)
 151 {
 152     impl = i;
 153     if(impl) impl->ref();
 154 }
 155
 156 CSSValue &CSSValue::operator = (const CSSValue &other)
 157 {
 158     if ( impl != other.impl ) {
 159         if(impl) impl->deref();
 160         impl = other.impl;
 161         if(impl) impl->ref();
 162     }
 163     return *this;
 164 }
 165
 166 CSSValue::~CSSValue()
 167 {
 168     if(impl) impl->deref();
 169 }
 170
 171 DOMString CSSValue::cssText() const
 172 {
 173     if(!impl) return DOMString();
 174     return ((CSSValueImpl *)impl)->cssText();
 175 }
 176
 177 void CSSValue::setCssText(const DOMString &value)
 178 {
 179     if(!impl) return;
 180     ((CSSValueImpl *)impl)->setCssText(value);
 181 }
 182
 183 unsigned short CSSValue::cssValueType() const
 184 {
 185     if(!impl) return 0;
 186     return ((CSSValueImpl *)impl)->cssValueType();
 187 }
 188
 189 bool CSSValue::isCSSValueList() const
 190 {
 191     if(!impl) return false;
 192     return ((CSSValueImpl *)impl)->isValueList();
 193 }
 194
 195 bool CSSValue::isCSSPrimitiveValue() const
 196 {
 197     if(!impl) return false;
 198     return ((CSSValueImpl *)impl)->isPrimitiveValue();
 199 }
 200
 201 CSSValueImpl *CSSValue::handle() const
 202 {
 203     return impl;
 204 }
 205
 206 bool CSSValue::isNull() const
 207 {
 208     return (impl == 0);
 209 }
 210
 211 // ----------------------------------------------------------
 212
 213 CSSValueList::CSSValueList() : CSSValue()
 214 {
 215 }
 216
 217 CSSValueList::CSSValueList(const CSSValueList &other) : CSSValue(other)
 218 {
 219 }
 220
 221 CSSValueList::CSSValueList(const CSSValue &other)
 222 {
 223    impl = 0;
 224    operator=(other);
 225 }
 226
 227 CSSValueList::CSSValueList(CSSValueListImpl *impl) : CSSValue(impl)
 228 {
 229 }
 230
 231 CSSValueList &CSSValueList::operator = (const CSSValueList &other)
 232 {
 233     if ( impl != other.impl ) {
 234         if (impl) impl->deref();
 235         impl = other.handle();
 236         if (impl) impl->ref();
 237     }
 238     return *this;
 239 }
 240
 241 CSSValueList &CSSValueList::operator = (const CSSValue &other)
 242 {
 243     CSSValueImpl *ohandle = other.handle() ;
 244     if ( impl != ohandle ) {
 245         if (impl) impl->deref();
 246         if (!other.isNull() && !other.isCSSValueList()) {
 247             impl = 0;
 248         } else {
 249             impl = ohandle;
 250             if (impl) impl->ref();
 251         }
 252     }
 253     return *this;
 254 }
 255
 256 CSSValueList::~CSSValueList()
 257 {
 258 }
 259
 260 unsigned long CSSValueList::length() const
 261 {
 262     if(!impl) return 0;
 263     return ((CSSValueListImpl *)impl)->length();
 264 }
 265
 266 CSSValue CSSValueList::item( unsigned long index )
 267 {
 268     if(!impl) return 0;
 269     return ((CSSValueListImpl *)impl)->item( index );
 270 }
 271
 272 // ----------------------------------------------------------
 273
 274 CSSPrimitiveValue::CSSPrimitiveValue() : CSSValue()
 275 {
 276 }
 277
 278 CSSPrimitiveValue::CSSPrimitiveValue(const CSSPrimitiveValue &other) : CSSValue(other)
 279 {
 280 }
 281
 282 CSSPrimitiveValue::CSSPrimitiveValue(const CSSValue &other) : CSSValue(other)
 283 {
 284     impl = 0;
 285     operator=(other);
 286 }
 287
 288 CSSPrimitiveValue::CSSPrimitiveValue(CSSPrimitiveValueImpl *impl) : CSSValue(impl)
 289 {
 290 }
 291
 292 CSSPrimitiveValue &CSSPrimitiveValue::operator = (const CSSPrimitiveValue &other)
 293 {
 294     if ( impl != other.impl ) {
 295         if (impl) impl->deref();
 296         impl = other.handle();
 297         if (impl) impl->ref();
 298     }
 299     return *this;
 300 }
 301
 302 CSSPrimitiveValue &CSSPrimitiveValue::operator = (const CSSValue &other)
 303 {
 304     CSSValueImpl *ohandle = other.handle();
 305     if ( impl != ohandle ) {
 306         if (impl) impl->deref();
 307         if (!other.isNull() && !other.isCSSPrimitiveValue()) {
 308             impl = 0;
 309         } else {
 310             impl = ohandle;
 311             if (impl) impl->ref();
 312         }
 313     }
 314     return *this;
 315 }
 316
 317 CSSPrimitiveValue::~CSSPrimitiveValue()
 318 {
 319 }
 320
 321 unsigned short CSSPrimitiveValue::primitiveType() const
 322 {
 323     if(!impl) return 0;
 324     return ((CSSPrimitiveValueImpl *)impl)->primitiveType();
 325 }
 326
 327 void CSSPrimitiveValue::setFloatValue( unsigned short unitType, float floatValue )
 328 {
 329     if(!impl) return;
 330     int exceptioncode = 0;
 331     ((CSSPrimitiveValueImpl *)impl)->setFloatValue( unitType, floatValue, exceptioncode );
 332     if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
 333         throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
 334     if ( exceptioncode )
 335         throw DOMException( exceptioncode );
 336 }
 337
 338 float CSSPrimitiveValue::getFloatValue( unsigned short unitType ) const
 339 {
 340     if(!impl) return 0;
 341     // ### add unit conversion
 342     if(primitiveType() != unitType)
 343         throw CSSException(CSSException::SYNTAX_ERR);
 344     return ((CSSPrimitiveValueImpl *)impl)->floatValue( unitType );
 345 }
 346
 347 void CSSPrimitiveValue::setStringValue( unsigned short stringType, const DOMString &stringValue )
 348 {
 349     int exceptioncode = 0;
 350     if(impl)
 351         ((CSSPrimitiveValueImpl *)impl)->setStringValue( stringType, stringValue, exceptioncode );
 352     if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
 353         throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
 354     if ( exceptioncode )
 355         throw DOMException( exceptioncode );
 356
 357 }
 358
 359 DOMString CSSPrimitiveValue::getStringValue(  ) const
 360 {
 361     if(!impl) return DOMString();
 362     return ((CSSPrimitiveValueImpl *)impl)->getStringValue(  );
 363 }
 364
 365 Counter CSSPrimitiveValue::getCounterValue(  ) const
 366 {
 367     if(!impl) return Counter();
 368     return ((CSSPrimitiveValueImpl *)impl)->getCounterValue(  );
 369 }
 370
 371 Rect CSSPrimitiveValue::getRectValue(  ) const
 372 {
 373     if(!impl) return Rect();
 374     return ((CSSPrimitiveValueImpl *)impl)->getRectValue(  );
 375 }
 376
 377 RGBColor CSSPrimitiveValue::getRGBColorValue(  ) const
 378 {
 379     // ###
 380     return RGBColor();
 381     //if(!impl) return RGBColor();
 382     //return ((CSSPrimitiveValueImpl *)impl)->getRGBColorValue(  );
 383 }
 384
 385 // -------------------------------------------------------------------
 386
 387 Counter::Counter()
 388 {
 389 }
 390
 391 Counter::Counter(const Counter &/*other*/)
 392 {
 393     impl = 0;
 394 }
 395
 396 Counter &Counter::operator = (const Counter &other)
 397 {
 398     if ( impl != other.impl ) {
 399         if (impl) impl->deref();
 400         impl = other.impl;
 401         if (impl) impl->ref();
 402     }
 403     return *this;
 404 }
 405
 406 Counter::Counter(CounterImpl *i)
 407 {
 408     impl = i;
 409     if (impl) impl->ref();
 410 }
 411
 412 Counter::~Counter()
 413 {
 414     if (impl) impl->deref();
 415 }
 416
 417 DOMString Counter::identifier() const
 418 {
 419   if (!impl) return DOMString();
 420   return impl->identifier();
 421 }
 422
 423 DOMString Counter::listStyle() const
 424 {
 425   if (!impl) return DOMString();
 426   return khtml::stringForListStyleType((khtml::EListStyleType)impl->listStyle());
 427 }
 428
 429 DOMString Counter::separator() const
 430 {
 431   if (!impl) return DOMString();
 432   return impl->separator();
 433 }
 434
 435 CounterImpl *Counter::handle() const
 436 {
 437     return impl;
 438 }
 439
 440 bool Counter::isNull() const
 441 {
 442     return (impl == 0);
 443 }
 444
 445 // --------------------------------------------------------------------
 446
 447 RGBColor::RGBColor()
 448 {
 449 }
 450
 451 RGBColor::RGBColor(const RGBColor &other)
 452 {
 453     m_color = other.m_color;
 454 }
 455
 456 RGBColor::RGBColor(QRgb color)
 457 {
 458     m_color = color;
 459 }
 460
 461 RGBColor &RGBColor::operator = (const RGBColor &other)
 462 {
 463     m_color = other.m_color;
 464     return *this;
 465 }
 466
 467 RGBColor::~RGBColor()
 468 {
 469 }
 470
 471 CSSPrimitiveValue RGBColor::red() const
 472 {
 473     return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qRed(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
 474 }
 475
 476 CSSPrimitiveValue RGBColor::green() const
 477 {
 478     return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qGreen(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
 479 }
 480
 481 CSSPrimitiveValue RGBColor::blue() const
 482 {
 483     return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qBlue(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
 484 }
 485
 486
 487 // ---------------------------------------------------------------------
 488
 489 Rect::Rect()
 490 {
 491     impl = 0;
 492 }
 493
 494 Rect::Rect(const Rect &other)
 495 {
 496     impl = other.impl;
 497     if (impl) impl->ref();
 498 }
 499
 500 Rect::Rect(RectImpl *i)
 501 {
 502     impl = i;
 503     if (impl) impl->ref();
 504 }
 505
 506 Rect &Rect::operator = (const Rect &other)
 507 {
 508     if ( impl != other.impl ) {
 509         if (impl) impl->deref();
 510         impl = other.impl;
 511         if (impl) impl->ref();
 512     }
 513     return *this;
 514 }
 515
 516 Rect::~Rect()
 517 {
 518     if (impl) impl->deref();
 519 }
 520
 521 CSSPrimitiveValue Rect::top() const
 522 {
 523     if (!impl) return 0;
 524     return impl->top();
 525 }
 526
 527 CSSPrimitiveValue Rect::right() const
 528 {
 529     if (!impl) return 0;
 530     return impl->right();
 531 }
 532
 533 CSSPrimitiveValue Rect::bottom() const
 534 {
 535     if (!impl) return 0;
 536     return impl->bottom();
 537 }
 538
 539 CSSPrimitiveValue Rect::left() const
 540 {
 541     if (!impl) return 0;
 542     return impl->left();
 543 }
 544
 545 RectImpl *Rect::handle() const
 546 {
 547     return impl;
 548 }
 549
 550 bool Rect::isNull() const
 551 {
 552     return (impl == 0);
 553 }
 554
 555 } // namespace
 556
 557