# khtml Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Source Files

# css_value.cpp

    00001 /*
    00002  * This file is part of the DOM implementation for KDE.
    00003  *
    00004  * (C) 1999 Lars Knoll (knoll@kde.org)
    00005  *
    00006  * This library is free software; you can redistribute it and/or
    00007  * modify it under the terms of the GNU Library General Public
    00008  * License as published by the Free Software Foundation; either
    00009  * version 2 of the License, or (at your option) any later version.
    00010  *
    00011  * This library is distributed in the hope that it will be useful,
    00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00014  * Library General Public License for more details.
    00015  *
    00016  * You should have received a copy of the GNU Library General Public License
    00017  * along with this library; see the file COPYING.LIB.  If not, write to
    00018  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00019  * Boston, MA 02111-1307, USA.
    00020  *
    00021  * $Id: css_value.cpp,v 1.21.2.2 2003/10/05 12:59:42 mueller Exp $
    00022  */
    00023
    00024 #include "dom/css_rule.h"
    00025 #include "dom/dom_exception.h"
    00026
    00027 #include "css/css_valueimpl.h"
    00028
    00029 using 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
    00152 CSSRule CSSStyleDeclaration::parentRule() const
    00153 {
    00154     if(!impl) return 0;
    00155     return static_cast<CSSStyleDeclarationImpl *>(impl)->parentRule();
    00156 }
    00157
    00158 CSSStyleDeclarationImpl *CSSStyleDeclaration::handle() const
    00159 {
    00160     return impl;
    00161 }
    00162
    00163 bool CSSStyleDeclaration::isNull() const
    00164 {
    00165     return (impl == 0);
    00166 }
    00167
    00168 // ----------------------------------------------------------
    00169
    00170 CSSValue::CSSValue()
    00171 {
    00172     impl = 0;
    00173 }
    00174
    00175 CSSValue::CSSValue(const CSSValue &other)
    00176 {
    00177     impl = other.impl;
    00178     if(impl) impl->ref();
    00179 }
    00180
    00181 CSSValue::CSSValue(CSSValueImpl *i)
    00182 {
    00183     impl = i;
    00184     if(impl) impl->ref();
    00185 }
    00186
    00187 CSSValue &CSSValue::operator = (const CSSValue &other)
    00188 {
    00189     if ( impl != other.impl ) {
    00190         if(impl) impl->deref();
    00191         impl = other.impl;
    00192         if(impl) impl->ref();
    00193     }
    00194     return *this;
    00195 }
    00196
    00197 CSSValue::~CSSValue()
    00198 {
    00199     if(impl) impl->deref();
    00200 }
    00201
    00202 DOMString CSSValue::cssText() const
    00203 {
    00204     if(!impl) return DOMString();
    00205     return ((CSSValueImpl *)impl)->cssText();
    00206 }
    00207
    00208 void CSSValue::setCssText( const DOMString &/*value*/ )
    00209 {
    00210     if(!impl) return;
    00211     ((CSSValueImpl *)impl)->cssText();
    00212 }
    00213
    00214 unsigned short CSSValue::cssValueType() const
    00215 {
    00216     if(!impl) return 0;
    00217     return ((CSSValueImpl *)impl)->cssValueType();
    00218 }
    00219
    00220 bool CSSValue::isCSSValueList() const
    00221 {
    00222     if(!impl) return false;
    00223     return ((CSSValueImpl *)impl)->isValueList();
    00224 }
    00225
    00226 bool CSSValue::isCSSPrimitiveValue() const
    00227 {
    00228     if(!impl) return false;
    00229     return ((CSSValueImpl *)impl)->isPrimitiveValue();
    00230 }
    00231
    00232 CSSValueImpl *CSSValue::handle() const
    00233 {
    00234     return impl;
    00235 }
    00236
    00237 bool CSSValue::isNull() const
    00238 {
    00239     return (impl == 0);
    00240 }
    00241
    00242 // ----------------------------------------------------------
    00243
    00244 CSSValueList::CSSValueList() : CSSValue()
    00245 {
    00246 }
    00247
    00248 CSSValueList::CSSValueList(const CSSValueList &other) : CSSValue(other)
    00249 {
    00250 }
    00251
    00252 CSSValueList::CSSValueList(const CSSValue &other)
    00253 {
    00254    impl = 0;
    00255    operator=(other);
    00256 }
    00257
    00258 CSSValueList::CSSValueList(CSSValueListImpl *impl) : CSSValue(impl)
    00259 {
    00260 }
    00261
    00262 CSSValueList &CSSValueList::operator = (const CSSValueList &other)
    00263 {
    00264     if ( impl != other.impl ) {
    00265         if (impl) impl->deref();
    00266         impl = other.handle();
    00267         if (impl) impl->ref();
    00268     }
    00269     return *this;
    00270 }
    00271
    00272 CSSValueList &CSSValueList::operator = (const CSSValue &other)
    00273 {
    00274     CSSValueImpl *ohandle = other.handle() ;
    00275     if ( impl != ohandle ) {
    00276         if (impl) impl->deref();
    00277         if (!other.isNull() && !other.isCSSValueList()) {
    00278             impl = 0;
    00279         } else {
    00280             impl = ohandle;
    00281             if (impl) impl->ref();
    00282         }
    00283     }
    00284     return *this;
    00285 }
    00286
    00287 CSSValueList::~CSSValueList()
    00288 {
    00289 }
    00290
    00291 unsigned long CSSValueList::length() const
    00292 {
    00293     if(!impl) return 0;
    00294     return ((CSSValueListImpl *)impl)->length();
    00295 }
    00296
    00297 CSSValue CSSValueList::item( unsigned long index )
    00298 {
    00299     if(!impl) return 0;
    00300     return ((CSSValueListImpl *)impl)->item( index );
    00301 }
    00302
    00303 // ----------------------------------------------------------
    00304
    00305 CSSPrimitiveValue::CSSPrimitiveValue() : CSSValue()
    00306 {
    00307 }
    00308
    00309 CSSPrimitiveValue::CSSPrimitiveValue(const CSSPrimitiveValue &other) : CSSValue(other)
    00310 {
    00311 }
    00312
    00313 CSSPrimitiveValue::CSSPrimitiveValue(const CSSValue &other) : CSSValue(other)
    00314 {
    00315     impl = 0;
    00316     operator=(other);
    00317 }
    00318
    00319 CSSPrimitiveValue::CSSPrimitiveValue(CSSPrimitiveValueImpl *impl) : CSSValue(impl)
    00320 {
    00321 }
    00322
    00323 CSSPrimitiveValue &CSSPrimitiveValue::operator = (const CSSPrimitiveValue &other)
    00324 {
    00325     if ( impl != other.impl ) {
    00326         if (impl) impl->deref();
    00327         impl = other.handle();
    00328         if (impl) impl->ref();
    00329     }
    00330     return *this;
    00331 }
    00332
    00333 CSSPrimitiveValue &CSSPrimitiveValue::operator = (const CSSValue &other)
    00334 {
    00335     CSSValueImpl *ohandle = other.handle();
    00336     if ( impl != ohandle ) {
    00337         if (impl) impl->deref();
    00338         if (!other.isNull() && !other.isCSSPrimitiveValue()) {
    00339             impl = 0;
    00340         } else {
    00341             impl = ohandle;
    00342             if (impl) impl->ref();
    00343         }
    00344     }
    00345     return *this;
    00346 }
    00347
    00348 CSSPrimitiveValue::~CSSPrimitiveValue()
    00349 {
    00350 }
    00351
    00352 unsigned short CSSPrimitiveValue::primitiveType() const
    00353 {
    00354     if(!impl) return 0;
    00355     return ((CSSPrimitiveValueImpl *)impl)->primitiveType();
    00356 }
    00357
    00358 void CSSPrimitiveValue::setFloatValue( unsigned short unitType, float floatValue )
    00359 {
    00360     if(!impl) return;
    00361     int exceptioncode = 0;
    00362     ((CSSPrimitiveValueImpl *)impl)->setFloatValue( unitType, floatValue, exceptioncode );
    00363     if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
    00364         throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
    00365     if ( exceptioncode )
    00366         throw DOMException( exceptioncode );
    00367 }
    00368
    00369 float CSSPrimitiveValue::getFloatValue( unsigned short unitType )
    00370 {
    00371     if(!impl) return 0;
    00372     // ### add unit conversion
    00373     if(primitiveType() != unitType)
    00374         throw CSSException(CSSException::SYNTAX_ERR);
    00375     return ((CSSPrimitiveValueImpl *)impl)->getFloatValue( unitType );
    00376 }
    00377
    00378 void CSSPrimitiveValue::setStringValue( unsigned short stringType, const DOMString &stringValue )
    00379 {
    00380     int exceptioncode = 0;
    00381     if(impl)
    00382         ((CSSPrimitiveValueImpl *)impl)->setStringValue( stringType, stringValue, exceptioncode );
    00383     if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET )
    00384         throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET );
    00385     if ( exceptioncode )
    00386         throw DOMException( exceptioncode );
    00387
    00388 }
    00389
    00390 DOMString CSSPrimitiveValue::getStringValue(  )
    00391 {
    00392     if(!impl) return DOMString();
    00393     return ((CSSPrimitiveValueImpl *)impl)->getStringValue(  );
    00394 }
    00395
    00396 Counter CSSPrimitiveValue::getCounterValue(  )
    00397 {
    00398     if(!impl) return Counter();
    00399     return ((CSSPrimitiveValueImpl *)impl)->getCounterValue(  );
    00400 }
    00401
    00402 Rect CSSPrimitiveValue::getRectValue(  )
    00403 {
    00404     if(!impl) return Rect();
    00405     return ((CSSPrimitiveValueImpl *)impl)->getRectValue(  );
    00406 }
    00407
    00408 RGBColor CSSPrimitiveValue::getRGBColorValue(  )
    00409 {
    00410     // ###
    00411     return RGBColor();
    00412     //if(!impl) return RGBColor();
    00413     //return ((CSSPrimitiveValueImpl *)impl)->getRGBColorValue(  );
    00414 }
    00415
    00416 // -------------------------------------------------------------------
    00417
    00418 Counter::Counter()
    00419 {
    00420 }
    00421
    00422 Counter::Counter(const Counter &/*other*/)
    00423 {
    00424     impl = 0;
    00425 }
    00426
    00427 Counter &Counter::operator = (const Counter &other)
    00428 {
    00429     if ( impl != other.impl ) {
    00430         if (impl) impl->deref();
    00431         impl = other.impl;
    00432         if (impl) impl->ref();
    00433     }
    00434     return *this;
    00435 }
    00436
    00437 Counter::Counter(CounterImpl *i)
    00438 {
    00439     impl = i;
    00440     if (impl) impl->ref();
    00441 }
    00442
    00443 Counter::~Counter()
    00444 {
    00445     if (impl) impl->deref();
    00446 }
    00447
    00448 DOMString Counter::identifier() const
    00449 {
    00450   if (!impl) return DOMString();
    00451   return impl->identifier();
    00452 }
    00453
    00454 DOMString Counter::listStyle() const
    00455 {
    00456   if (!impl) return DOMString();
    00457   return impl->listStyle();
    00458 }
    00459
    00460 DOMString Counter::separator() const
    00461 {
    00462   if (!impl) return DOMString();
    00463   return impl->separator();
    00464 }
    00465
    00466 CounterImpl *Counter::handle() const
    00467 {
    00468     return impl;
    00469 }
    00470
    00471 bool Counter::isNull() const
    00472 {
    00473     return (impl == 0);
    00474 }
    00475
    00476 // --------------------------------------------------------------------
    00477
    00478 RGBColor::RGBColor()
    00479 {
    00480 }
    00481
    00482 RGBColor::RGBColor(const RGBColor &other)
    00483 {
    00484     m_color = other.m_color;
    00485 }
    00486
    00487 RGBColor::RGBColor(QRgb color)
    00488 {
    00489     m_color = color;
    00490 }
    00491
    00492 RGBColor &RGBColor::operator = (const RGBColor &other)
    00493 {
    00494     m_color = other.m_color;
    00495     return *this;
    00496 }
    00497
    00498 RGBColor::~RGBColor()
    00499 {
    00500 }
    00501
    00502 CSSPrimitiveValue RGBColor::red() const
    00503 {
    00504     return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qRed(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
    00505 }
    00506
    00507 CSSPrimitiveValue RGBColor::green() const
    00508 {
    00509     return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qGreen(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
    00510 }
    00511
    00512 CSSPrimitiveValue RGBColor::blue() const
    00513 {
    00514     return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qBlue(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
    00515 }
    00516
    00517
    00518 // ---------------------------------------------------------------------
    00519
    00520 Rect::Rect()
    00521 {
    00522     impl = 0;
    00523 }
    00524
    00525 Rect::Rect(const Rect &other)
    00526 {
    00527     impl = other.impl;
    00528     if (impl) impl->ref();
    00529 }
    00530
    00531 Rect::Rect(RectImpl *i)
    00532 {
    00533     impl = i;
    00534     if (impl) impl->ref();
    00535 }
    00536
    00537 Rect &Rect::operator = (const Rect &other)
    00538 {
    00539     if ( impl != other.impl ) {
    00540         if (impl) impl->deref();
    00541         impl = other.impl;
    00542         if (impl) impl->ref();
    00543     }
    00544     return *this;
    00545 }
    00546
    00547 Rect::~Rect()
    00548 {
    00549     if (impl) impl->deref();
    00550 }
    00551
    00552 CSSPrimitiveValue Rect::top() const
    00553 {
    00554     if (!impl) return 0;
    00555     return impl->top();
    00556 }
    00557
    00558 CSSPrimitiveValue Rect::right() const
    00559 {
    00560     if (!impl) return 0;
    00561     return impl->right();
    00562 }
    00563
    00564 CSSPrimitiveValue Rect::bottom() const
    00565 {
    00566     if (!impl) return 0;
    00567     return impl->bottom();
    00568 }
    00569
    00570 CSSPrimitiveValue Rect::left() const
    00571 {
    00572     if (!impl) return 0;
    00573     return impl->left();
    00574 }
    00575
    00576 RectImpl *Rect::handle() const
    00577 {
    00578     return impl;
    00579 }
    00580
    00581 bool Rect::isNull() const
    00582 {
    00583     return (impl == 0);
    00584 }
    00585
    00586

This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:33:33 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001