00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
#include "dom/css_rule.h"
00024
#include "dom/dom_exception.h"
00025
00026
#include "css/css_renderstyledeclarationimpl.h"
00027
#include "css/css_valueimpl.h"
00028
00029
namespace DOM {
00030
00031 CSSStyleDeclaration::CSSStyleDeclaration()
00032 {
00033 impl = 0;
00034 }
00035
00036 CSSStyleDeclaration::CSSStyleDeclaration(
const CSSStyleDeclaration &other)
00037 {
00038 impl = other.
impl;
00039
if(impl) impl->ref();
00040 }
00041
00042 CSSStyleDeclaration::CSSStyleDeclaration(CSSStyleDeclarationImpl *i)
00043 {
00044 impl = i;
00045
if(impl) impl->ref();
00046 }
00047
00048
CSSStyleDeclaration &CSSStyleDeclaration::operator = (
const CSSStyleDeclaration &other)
00049 {
00050
if ( impl != other.
impl ) {
00051
if(impl) impl->deref();
00052 impl = other.
impl;
00053
if(impl) impl->ref();
00054 }
00055
return *
this;
00056 }
00057
00058 CSSStyleDeclaration::~CSSStyleDeclaration()
00059 {
00060
if(impl) impl->deref();
00061 }
00062
00063 DOMString CSSStyleDeclaration::cssText()
const
00064
{
00065
if(!impl)
return DOMString();
00066
return static_cast<CSSStyleDeclarationImpl *>(impl)->cssText();
00067 }
00068
00069 void CSSStyleDeclaration::setCssText(
const DOMString &value )
00070 {
00071
if(!impl)
return;
00072 impl->setCssText(value);
00073 }
00074
00075
DOMString CSSStyleDeclaration::getPropertyValue(
const DOMString &propertyName )
00076 {
00077
return const_cast<const CSSStyleDeclaration*>(
this )->getPropertyValue( propertyName );
00078 }
00079
00080 DOMString CSSStyleDeclaration::getPropertyValue(
const DOMString &propertyName )
const
00081
{
00082
if(!impl)
return DOMString();
00083
int id = getPropertyID(propertyName.
string().
ascii(), propertyName.
length());
00084
if (!
id)
return DOMString();
00085
return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyValue(
id);
00086 }
00087
00088
CSSValue CSSStyleDeclaration::getPropertyCSSValue(
const DOMString &propertyName )
00089 {
00090
return const_cast<const CSSStyleDeclaration*>(
this )->getPropertyCSSValue( propertyName );
00091 }
00092
00093 CSSValue CSSStyleDeclaration::getPropertyCSSValue(
const DOMString &propertyName )
const
00094
{
00095
if(!impl)
return 0;
00096
int id = getPropertyID(propertyName.
string().
ascii(), propertyName.
length());
00097
if (!
id)
return 0;
00098
return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyCSSValue(
id);
00099 }
00100
00101 DOMString CSSStyleDeclaration::removeProperty(
const DOMString &property )
00102 {
00103
int id = getPropertyID(property.
string().
ascii(), property.
length());
00104
if(!impl || !
id)
return DOMString();
00105
return static_cast<CSSStyleDeclarationImpl *>(impl)->removeProperty(
id );
00106 }
00107
00108
DOMString CSSStyleDeclaration::getPropertyPriority(
const DOMString &propertyName )
00109 {
00110
return const_cast<const CSSStyleDeclaration*>(
this )->getPropertyPriority( propertyName );
00111 }
00112
00113 DOMString CSSStyleDeclaration::getPropertyPriority(
const DOMString &propertyName )
const
00114
{
00115
int id = getPropertyID(propertyName.
string().
ascii(), propertyName.
length());
00116
if(!impl || !
id)
return DOMString();
00117
if (impl->getPropertyPriority(
id))
00118
return DOMString(
"important");
00119
return DOMString();
00120 }
00121
00122 void CSSStyleDeclaration::setProperty(
const DOMString &propName,
const DOMString &value,
const DOMString &priority )
00123 {
00124
if(!impl)
return;
00125
int id = getPropertyID(propName.
string().
lower().ascii(), propName.
length());
00126
if (!
id)
return;
00127
bool important =
false;
00128
QString str = priority.
string();
00129
if (str.
find(
"important", 0,
false) != -1)
00130 important =
true;
00131
00132 static_cast<CSSStyleDeclarationImpl *>(impl)->setProperty(
id, value, important );
00133 }
00134
00135 unsigned long CSSStyleDeclaration::length()
const
00136
{
00137
if(!impl)
return 0;
00138
return static_cast<CSSStyleDeclarationImpl *>(impl)->length();
00139 }
00140
00141
DOMString CSSStyleDeclaration::item(
unsigned long index )
00142 {
00143
return const_cast<const CSSStyleDeclaration*>(
this )->item( index );
00144 }
00145
00146 DOMString CSSStyleDeclaration::item(
unsigned long index )
const
00147
{
00148
if(!impl)
return DOMString();
00149
return static_cast<CSSStyleDeclarationImpl *>(impl)->item( index );
00150 }
00151 CSSRule CSSStyleDeclaration::parentRule()
const
00152
{
00153
if(!impl)
return 0;
00154
return static_cast<CSSStyleDeclarationImpl *>(impl)->
parentRule();
00155 }
00156
00157 CSSStyleDeclarationImpl *CSSStyleDeclaration::handle()
const
00158
{
00159
return impl;
00160 }
00161
00162
bool CSSStyleDeclaration::isNull()
const
00163
{
00164
return (impl == 0);
00165 }
00166
00167
00168
00169 CSSValue::CSSValue()
00170 {
00171 impl = 0;
00172 }
00173
00174 CSSValue::CSSValue(
const CSSValue &other)
00175 {
00176 impl = other.
impl;
00177
if(impl) impl->ref();
00178 }
00179
00180 CSSValue::CSSValue(CSSValueImpl *i)
00181 {
00182 impl = i;
00183
if(impl) impl->ref();
00184 }
00185
00186
CSSValue &CSSValue::operator = (
const CSSValue &other)
00187 {
00188
if ( impl != other.
impl ) {
00189
if(impl) impl->deref();
00190 impl = other.
impl;
00191
if(impl) impl->ref();
00192 }
00193
return *
this;
00194 }
00195
00196 CSSValue::~CSSValue()
00197 {
00198
if(impl) impl->deref();
00199 }
00200
00201 DOMString CSSValue::cssText()
const
00202
{
00203
if(!impl)
return DOMString();
00204
return ((CSSValueImpl *)impl)->cssText();
00205 }
00206
00207 void CSSValue::setCssText(
const DOMString & )
00208 {
00209
if(!impl)
return;
00210 ((CSSValueImpl *)impl)->cssText();
00211 }
00212
00213 unsigned short CSSValue::cssValueType()
const
00214
{
00215
if(!impl)
return 0;
00216
return ((CSSValueImpl *)impl)->cssValueType();
00217 }
00218
00219
bool CSSValue::isCSSValueList()
const
00220
{
00221
if(!impl)
return false;
00222
return ((CSSValueImpl *)impl)->isValueList();
00223 }
00224
00225
bool CSSValue::isCSSPrimitiveValue()
const
00226
{
00227
if(!impl)
return false;
00228
return ((CSSValueImpl *)impl)->isPrimitiveValue();
00229 }
00230
00231 CSSValueImpl *CSSValue::handle()
const
00232
{
00233
return impl;
00234 }
00235
00236
bool CSSValue::isNull()
const
00237
{
00238
return (impl == 0);
00239 }
00240
00241
00242
00243 CSSValueList::CSSValueList() :
CSSValue()
00244 {
00245 }
00246
00247 CSSValueList::CSSValueList(
const CSSValueList &other) :
CSSValue(other)
00248 {
00249 }
00250
00251 CSSValueList::CSSValueList(
const CSSValue &other)
00252 {
00253 impl = 0;
00254 operator=(other);
00255 }
00256
00257 CSSValueList::CSSValueList(CSSValueListImpl *impl) :
CSSValue(impl)
00258 {
00259 }
00260
00261
CSSValueList &CSSValueList::operator = (
const CSSValueList &other)
00262 {
00263
if ( impl != other.
impl ) {
00264
if (impl) impl->deref();
00265 impl = other.
handle();
00266
if (impl) impl->ref();
00267 }
00268
return *
this;
00269 }
00270
00271
CSSValueList &CSSValueList::operator = (
const CSSValue &other)
00272 {
00273 CSSValueImpl *ohandle = other.
handle() ;
00274
if ( impl != ohandle ) {
00275
if (impl) impl->deref();
00276
if (!other.
isNull() && !other.
isCSSValueList()) {
00277 impl = 0;
00278 }
else {
00279 impl = ohandle;
00280
if (impl) impl->ref();
00281 }
00282 }
00283
return *
this;
00284 }
00285
00286 CSSValueList::~CSSValueList()
00287 {
00288 }
00289
00290 unsigned long CSSValueList::length()
const
00291
{
00292
if(!impl)
return 0;
00293
return ((CSSValueListImpl *)impl)->length();
00294 }
00295
00296 CSSValue CSSValueList::item(
unsigned long index )
00297 {
00298
if(!impl)
return 0;
00299
return ((CSSValueListImpl *)impl)->item( index );
00300 }
00301
00302
00303
00304 CSSPrimitiveValue::CSSPrimitiveValue() :
CSSValue()
00305 {
00306 }
00307
00308 CSSPrimitiveValue::CSSPrimitiveValue(
const CSSPrimitiveValue &other) :
CSSValue(other)
00309 {
00310 }
00311
00312 CSSPrimitiveValue::CSSPrimitiveValue(
const CSSValue &other) :
CSSValue(other)
00313 {
00314 impl = 0;
00315 operator=(other);
00316 }
00317
00318 CSSPrimitiveValue::CSSPrimitiveValue(CSSPrimitiveValueImpl *impl) :
CSSValue(impl)
00319 {
00320 }
00321
00322 CSSPrimitiveValue &CSSPrimitiveValue::operator = (
const CSSPrimitiveValue &other)
00323 {
00324
if ( impl != other.impl ) {
00325
if (impl) impl->deref();
00326 impl = other.handle();
00327
if (impl) impl->ref();
00328 }
00329
return *
this;
00330 }
00331
00332 CSSPrimitiveValue &CSSPrimitiveValue::operator = (
const CSSValue &other)
00333 {
00334 CSSValueImpl *ohandle = other.
handle();
00335
if ( impl != ohandle ) {
00336
if (impl) impl->deref();
00337
if (!other.
isNull() && !other.
isCSSPrimitiveValue()) {
00338 impl = 0;
00339 }
else {
00340 impl = ohandle;
00341
if (impl) impl->ref();
00342 }
00343 }
00344
return *
this;
00345 }
00346
00347 CSSPrimitiveValue::~CSSPrimitiveValue()
00348 {
00349 }
00350
00351 unsigned short CSSPrimitiveValue::primitiveType()
const
00352
{
00353
if(!impl)
return 0;
00354
return ((CSSPrimitiveValueImpl *)impl)->primitiveType();
00355 }
00356
00357 void CSSPrimitiveValue::setFloatValue(
unsigned short unitType,
float floatValue )
00358 {
00359
if(!impl)
return;
00360
int exceptioncode = 0;
00361 ((CSSPrimitiveValueImpl *)impl)->setFloatValue( unitType, floatValue, exceptioncode );
00362
if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
00363
throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
00364
if ( exceptioncode )
00365
throw DOMException( exceptioncode );
00366 }
00367
00368 float CSSPrimitiveValue::getFloatValue(
unsigned short unitType )
00369 {
00370
if(!impl)
return 0;
00371
00372
if(
primitiveType() != unitType)
00373
throw CSSException(CSSException::SYNTAX_ERR);
00374
return ((CSSPrimitiveValueImpl *)impl)->floatValue( unitType );
00375 }
00376
00377 void CSSPrimitiveValue::setStringValue(
unsigned short stringType,
const DOMString &stringValue )
00378 {
00379
int exceptioncode = 0;
00380
if(impl)
00381 ((CSSPrimitiveValueImpl *)impl)->setStringValue( stringType, stringValue, exceptioncode );
00382
if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
00383
throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
00384
if ( exceptioncode )
00385
throw DOMException( exceptioncode );
00386
00387 }
00388
00389 DOMString CSSPrimitiveValue::getStringValue( )
00390 {
00391
if(!impl)
return DOMString();
00392
return ((CSSPrimitiveValueImpl *)impl)->getStringValue( );
00393 }
00394
00395 Counter CSSPrimitiveValue::getCounterValue( )
00396 {
00397
if(!impl)
return Counter();
00398
return ((CSSPrimitiveValueImpl *)impl)->getCounterValue( );
00399 }
00400
00401 Rect CSSPrimitiveValue::getRectValue( )
00402 {
00403
if(!impl)
return Rect();
00404
return ((CSSPrimitiveValueImpl *)impl)->getRectValue( );
00405 }
00406
00407 RGBColor CSSPrimitiveValue::getRGBColorValue( )
00408 {
00409
00410
return RGBColor();
00411
00412
00413 }
00414
00415
00416
00417 Counter::Counter()
00418 {
00419 }
00420
00421 Counter::Counter(
const Counter &)
00422 {
00423 impl = 0;
00424 }
00425
00426 Counter &Counter::operator = (
const Counter &other)
00427 {
00428
if ( impl != other.impl ) {
00429
if (impl) impl->deref();
00430 impl = other.impl;
00431
if (impl) impl->ref();
00432 }
00433
return *
this;
00434 }
00435
00436 Counter::Counter(CounterImpl *i)
00437 {
00438 impl = i;
00439
if (impl) impl->ref();
00440 }
00441
00442 Counter::~Counter()
00443 {
00444
if (impl) impl->deref();
00445 }
00446
00447 DOMString Counter::identifier()
const
00448
{
00449
if (!impl)
return DOMString();
00450
return impl->identifier();
00451 }
00452
00453 DOMString Counter::listStyle()
const
00454
{
00455
if (!impl)
return DOMString();
00456
return khtml::stringForListStyleType((khtml::EListStyleType)impl->listStyle());
00457 }
00458
00459 DOMString Counter::separator()
const
00460
{
00461
if (!impl)
return DOMString();
00462
return impl->separator();
00463 }
00464
00465 CounterImpl *Counter::handle()
const
00466
{
00467
return impl;
00468 }
00469
00470
bool Counter::isNull()
const
00471
{
00472
return (impl == 0);
00473 }
00474
00475
00476
00477 RGBColor::RGBColor()
00478 {
00479 }
00480
00481 RGBColor::RGBColor(
const RGBColor &other)
00482 {
00483 m_color = other.m_color;
00484 }
00485
00486 RGBColor::RGBColor(QRgb color)
00487 {
00488 m_color = color;
00489 }
00490
00491 RGBColor &RGBColor::operator = (
const RGBColor &other)
00492 {
00493 m_color = other.m_color;
00494
return *
this;
00495 }
00496
00497 RGBColor::~RGBColor()
00498 {
00499 }
00500
00501 CSSPrimitiveValue RGBColor::red()
const
00502
{
00503
return new CSSPrimitiveValueImpl(
float(qAlpha(m_color) ? qRed(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
00504 }
00505
00506 CSSPrimitiveValue RGBColor::green()
const
00507
{
00508
return new CSSPrimitiveValueImpl(
float(qAlpha(m_color) ? qGreen(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
00509 }
00510
00511 CSSPrimitiveValue RGBColor::blue()
const
00512
{
00513
return new CSSPrimitiveValueImpl(
float(qAlpha(m_color) ? qBlue(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
00514 }
00515
00516
00517
00518
00519 Rect::Rect()
00520 {
00521 impl = 0;
00522 }
00523
00524 Rect::Rect(
const Rect &other)
00525 {
00526 impl = other.impl;
00527
if (impl) impl->ref();
00528 }
00529
00530 Rect::Rect(RectImpl *i)
00531 {
00532 impl = i;
00533
if (impl) impl->ref();
00534 }
00535
00536 Rect &Rect::operator = (
const Rect &other)
00537 {
00538
if ( impl != other.impl ) {
00539
if (impl) impl->deref();
00540 impl = other.impl;
00541
if (impl) impl->ref();
00542 }
00543
return *
this;
00544 }
00545
00546 Rect::~Rect()
00547 {
00548
if (impl) impl->deref();
00549 }
00550
00551 CSSPrimitiveValue Rect::top()
const
00552
{
00553
if (!impl)
return 0;
00554
return impl->top();
00555 }
00556
00557 CSSPrimitiveValue Rect::right()
const
00558
{
00559
if (!impl)
return 0;
00560
return impl->right();
00561 }
00562
00563 CSSPrimitiveValue Rect::bottom()
const
00564
{
00565
if (!impl)
return 0;
00566
return impl->bottom();
00567 }
00568
00569 CSSPrimitiveValue Rect::left()
const
00570
{
00571
if (!impl)
return 0;
00572
return impl->left();
00573 }
00574
00575 RectImpl *Rect::handle()
const
00576
{
00577
return impl;
00578 }
00579
00580
bool Rect::isNull()
const
00581
{
00582
return (impl == 0);
00583 }
00584
00585 }
00586
00587