diff options
Diffstat (limited to 'tdehtml/dom/css_value.cpp')
| -rw-r--r-- | tdehtml/dom/css_value.cpp | 587 |
1 files changed, 587 insertions, 0 deletions
diff --git a/tdehtml/dom/css_value.cpp b/tdehtml/dom/css_value.cpp new file mode 100644 index 000000000..4e365644a --- /dev/null +++ b/tdehtml/dom/css_value.cpp @@ -0,0 +1,587 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * (C) 1999 Lars Knoll (knoll@kde.org) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#include "dom/css_rule.h" +#include "dom/dom_exception.h" + +#include "css/css_renderstyledeclarationimpl.h" +#include "css/css_valueimpl.h" + +namespace DOM { + +CSSStyleDeclaration::CSSStyleDeclaration() +{ + impl = 0; +} + +CSSStyleDeclaration::CSSStyleDeclaration(const CSSStyleDeclaration &other) +{ + impl = other.impl; + if(impl) impl->ref(); +} + +CSSStyleDeclaration::CSSStyleDeclaration(CSSStyleDeclarationImpl *i) +{ + impl = i; + if(impl) impl->ref(); +} + +CSSStyleDeclaration &CSSStyleDeclaration::operator = (const CSSStyleDeclaration &other) +{ + if ( impl != other.impl ) { + if(impl) impl->deref(); + impl = other.impl; + if(impl) impl->ref(); + } + return *this; +} + +CSSStyleDeclaration::~CSSStyleDeclaration() +{ + if(impl) impl->deref(); +} + +DOMString CSSStyleDeclaration::cssText() const +{ + if(!impl) return DOMString(); + return static_cast<CSSStyleDeclarationImpl *>(impl)->cssText(); +} + +void CSSStyleDeclaration::setCssText( const DOMString &value ) +{ + if(!impl) return; + impl->setCssText(value); +} + +DOMString CSSStyleDeclaration::getPropertyValue( const DOMString &propertyName ) +{ + return const_cast<const CSSStyleDeclaration*>( this )->getPropertyValue( propertyName ); +} + +DOMString CSSStyleDeclaration::getPropertyValue( const DOMString &propertyName ) const +{ + if(!impl) return DOMString(); + int id = getPropertyID(propertyName.string().ascii(), propertyName.length()); + if (!id) return DOMString(); + return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyValue(id); +} + +CSSValue CSSStyleDeclaration::getPropertyCSSValue( const DOMString &propertyName ) +{ + return const_cast<const CSSStyleDeclaration*>( this )->getPropertyCSSValue( propertyName ); +} + +CSSValue CSSStyleDeclaration::getPropertyCSSValue( const DOMString &propertyName ) const +{ + if(!impl) return 0; + int id = getPropertyID(propertyName.string().ascii(), propertyName.length()); + if (!id) return 0; + return static_cast<CSSStyleDeclarationImpl *>(impl)->getPropertyCSSValue(id); +} + +DOMString CSSStyleDeclaration::removeProperty( const DOMString &property ) +{ + int id = getPropertyID(property.string().ascii(), property.length()); + if(!impl || !id) return DOMString(); + return static_cast<CSSStyleDeclarationImpl *>(impl)->removeProperty( id ); +} + +DOMString CSSStyleDeclaration::getPropertyPriority( const DOMString &propertyName ) +{ + return const_cast<const CSSStyleDeclaration*>( this )->getPropertyPriority( propertyName ); +} + +DOMString CSSStyleDeclaration::getPropertyPriority( const DOMString &propertyName ) const +{ + int id = getPropertyID(propertyName.string().ascii(), propertyName.length()); + if(!impl || !id) return DOMString(); + if (impl->getPropertyPriority(id)) + return DOMString("important"); + return DOMString(); +} + +void CSSStyleDeclaration::setProperty( const DOMString &propName, const DOMString &value, const DOMString &priority ) +{ + if(!impl) return; + int id = getPropertyID(propName.string().lower().ascii(), propName.length()); + if (!id) return; + bool important = false; + TQString str = priority.string(); + if (str.find("important", 0, false) != -1) + important = true; + + static_cast<CSSStyleDeclarationImpl *>(impl)->setProperty( id, value, important ); +} + +unsigned long CSSStyleDeclaration::length() const +{ + if(!impl) return 0; + return static_cast<CSSStyleDeclarationImpl *>(impl)->length(); +} + +DOMString CSSStyleDeclaration::item( unsigned long index ) +{ + return const_cast<const CSSStyleDeclaration*>( this )->item( index ); +} + +DOMString CSSStyleDeclaration::item( unsigned long index ) const +{ + if(!impl) return DOMString(); + return static_cast<CSSStyleDeclarationImpl *>(impl)->item( index ); +} +CSSRule CSSStyleDeclaration::parentRule() const +{ + if(!impl) return 0; + return static_cast<CSSStyleDeclarationImpl *>(impl)->parentRule(); +} + +CSSStyleDeclarationImpl *CSSStyleDeclaration::handle() const +{ + return impl; +} + +bool CSSStyleDeclaration::isNull() const +{ + return (impl == 0); +} + +// ---------------------------------------------------------- + +CSSValue::CSSValue() +{ + impl = 0; +} + +CSSValue::CSSValue(const CSSValue &other) +{ + impl = other.impl; + if(impl) impl->ref(); +} + +CSSValue::CSSValue(CSSValueImpl *i) +{ + impl = i; + if(impl) impl->ref(); +} + +CSSValue &CSSValue::operator = (const CSSValue &other) +{ + if ( impl != other.impl ) { + if(impl) impl->deref(); + impl = other.impl; + if(impl) impl->ref(); + } + return *this; +} + +CSSValue::~CSSValue() +{ + if(impl) impl->deref(); +} + +DOMString CSSValue::cssText() const +{ + if(!impl) return DOMString(); + return ((CSSValueImpl *)impl)->cssText(); +} + +void CSSValue::setCssText( const DOMString &/*value*/ ) +{ + if(!impl) return; + ((CSSValueImpl *)impl)->cssText(); +} + +unsigned short CSSValue::cssValueType() const +{ + if(!impl) return 0; + return ((CSSValueImpl *)impl)->cssValueType(); +} + +bool CSSValue::isCSSValueList() const +{ + if(!impl) return false; + return ((CSSValueImpl *)impl)->isValueList(); +} + +bool CSSValue::isCSSPrimitiveValue() const +{ + if(!impl) return false; + return ((CSSValueImpl *)impl)->isPrimitiveValue(); +} + +CSSValueImpl *CSSValue::handle() const +{ + return impl; +} + +bool CSSValue::isNull() const +{ + return (impl == 0); +} + +// ---------------------------------------------------------- + +CSSValueList::CSSValueList() : CSSValue() +{ +} + +CSSValueList::CSSValueList(const CSSValueList &other) : CSSValue(other) +{ +} + +CSSValueList::CSSValueList(const CSSValue &other) +{ + impl = 0; + operator=(other); +} + +CSSValueList::CSSValueList(CSSValueListImpl *impl) : CSSValue(impl) +{ +} + +CSSValueList &CSSValueList::operator = (const CSSValueList &other) +{ + if ( impl != other.impl ) { + if (impl) impl->deref(); + impl = other.handle(); + if (impl) impl->ref(); + } + return *this; +} + +CSSValueList &CSSValueList::operator = (const CSSValue &other) +{ + CSSValueImpl *ohandle = other.handle() ; + if ( impl != ohandle ) { + if (impl) impl->deref(); + if (!other.isNull() && !other.isCSSValueList()) { + impl = 0; + } else { + impl = ohandle; + if (impl) impl->ref(); + } + } + return *this; +} + +CSSValueList::~CSSValueList() +{ +} + +unsigned long CSSValueList::length() const +{ + if(!impl) return 0; + return ((CSSValueListImpl *)impl)->length(); +} + +CSSValue CSSValueList::item( unsigned long index ) +{ + if(!impl) return 0; + return ((CSSValueListImpl *)impl)->item( index ); +} + +// ---------------------------------------------------------- + +CSSPrimitiveValue::CSSPrimitiveValue() : CSSValue() +{ +} + +CSSPrimitiveValue::CSSPrimitiveValue(const CSSPrimitiveValue &other) : CSSValue(other) +{ +} + +CSSPrimitiveValue::CSSPrimitiveValue(const CSSValue &other) : CSSValue(other) +{ + impl = 0; + operator=(other); +} + +CSSPrimitiveValue::CSSPrimitiveValue(CSSPrimitiveValueImpl *impl) : CSSValue(impl) +{ +} + +CSSPrimitiveValue &CSSPrimitiveValue::operator = (const CSSPrimitiveValue &other) +{ + if ( impl != other.impl ) { + if (impl) impl->deref(); + impl = other.handle(); + if (impl) impl->ref(); + } + return *this; +} + +CSSPrimitiveValue &CSSPrimitiveValue::operator = (const CSSValue &other) +{ + CSSValueImpl *ohandle = other.handle(); + if ( impl != ohandle ) { + if (impl) impl->deref(); + if (!other.isNull() && !other.isCSSPrimitiveValue()) { + impl = 0; + } else { + impl = ohandle; + if (impl) impl->ref(); + } + } + return *this; +} + +CSSPrimitiveValue::~CSSPrimitiveValue() +{ +} + +unsigned short CSSPrimitiveValue::primitiveType() const +{ + if(!impl) return 0; + return ((CSSPrimitiveValueImpl *)impl)->primitiveType(); +} + +void CSSPrimitiveValue::setFloatValue( unsigned short unitType, float floatValue ) +{ + if(!impl) return; + int exceptioncode = 0; + ((CSSPrimitiveValueImpl *)impl)->setFloatValue( unitType, floatValue, exceptioncode ); + if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET ) + throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET ); + if ( exceptioncode ) + throw DOMException( exceptioncode ); +} + +float CSSPrimitiveValue::getFloatValue( unsigned short unitType ) +{ + if(!impl) return 0; + // ### add unit conversion + if(primitiveType() != unitType) + throw CSSException(CSSException::SYNTAX_ERR); + return ((CSSPrimitiveValueImpl *)impl)->floatValue( unitType ); +} + +void CSSPrimitiveValue::setStringValue( unsigned short stringType, const DOMString &stringValue ) +{ + int exceptioncode = 0; + if(impl) + ((CSSPrimitiveValueImpl *)impl)->setStringValue( stringType, stringValue, exceptioncode ); + if ( exceptioncode >= CSSException::_EXCEPTION_OFFSET ) + throw CSSException( exceptioncode - CSSException::_EXCEPTION_OFFSET ); + if ( exceptioncode ) + throw DOMException( exceptioncode ); + +} + +DOMString CSSPrimitiveValue::getStringValue( ) +{ + if(!impl) return DOMString(); + return ((CSSPrimitiveValueImpl *)impl)->getStringValue( ); +} + +Counter CSSPrimitiveValue::getCounterValue( ) +{ + if(!impl) return Counter(); + return ((CSSPrimitiveValueImpl *)impl)->getCounterValue( ); +} + +Rect CSSPrimitiveValue::getRectValue( ) +{ + if(!impl) return Rect(); + return ((CSSPrimitiveValueImpl *)impl)->getRectValue( ); +} + +RGBColor CSSPrimitiveValue::getRGBColorValue( ) +{ + // ### + return RGBColor(); + //if(!impl) return RGBColor(); + //return ((CSSPrimitiveValueImpl *)impl)->getRGBColorValue( ); +} + +// ------------------------------------------------------------------- + +Counter::Counter() +{ +} + +Counter::Counter(const Counter &/*other*/) +{ + impl = 0; +} + +Counter &Counter::operator = (const Counter &other) +{ + if ( impl != other.impl ) { + if (impl) impl->deref(); + impl = other.impl; + if (impl) impl->ref(); + } + return *this; +} + +Counter::Counter(CounterImpl *i) +{ + impl = i; + if (impl) impl->ref(); +} + +Counter::~Counter() +{ + if (impl) impl->deref(); +} + +DOMString Counter::identifier() const +{ + if (!impl) return DOMString(); + return impl->identifier(); +} + +DOMString Counter::listStyle() const +{ + if (!impl) return DOMString(); + return tdehtml::stringForListStyleType((tdehtml::EListStyleType)impl->listStyle()); +} + +DOMString Counter::separator() const +{ + if (!impl) return DOMString(); + return impl->separator(); +} + +CounterImpl *Counter::handle() const +{ + return impl; +} + +bool Counter::isNull() const +{ + return (impl == 0); +} + +// -------------------------------------------------------------------- + +RGBColor::RGBColor() +{ +} + +RGBColor::RGBColor(const RGBColor &other) +{ + m_color = other.m_color; +} + +RGBColor::RGBColor(QRgb color) +{ + m_color = color; +} + +RGBColor &RGBColor::operator = (const RGBColor &other) +{ + m_color = other.m_color; + return *this; +} + +RGBColor::~RGBColor() +{ +} + +CSSPrimitiveValue RGBColor::red() const +{ + return new CSSPrimitiveValueImpl(float(tqAlpha(m_color) ? tqRed(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION); +} + +CSSPrimitiveValue RGBColor::green() const +{ + return new CSSPrimitiveValueImpl(float(tqAlpha(m_color) ? tqGreen(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION); +} + +CSSPrimitiveValue RGBColor::blue() const +{ + return new CSSPrimitiveValueImpl(float(tqAlpha(m_color) ? tqBlue(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION); +} + + +// --------------------------------------------------------------------- + +Rect::Rect() +{ + impl = 0; +} + +Rect::Rect(const Rect &other) +{ + impl = other.impl; + if (impl) impl->ref(); +} + +Rect::Rect(RectImpl *i) +{ + impl = i; + if (impl) impl->ref(); +} + +Rect &Rect::operator = (const Rect &other) +{ + if ( impl != other.impl ) { + if (impl) impl->deref(); + impl = other.impl; + if (impl) impl->ref(); + } + return *this; +} + +Rect::~Rect() +{ + if (impl) impl->deref(); +} + +CSSPrimitiveValue Rect::top() const +{ + if (!impl) return 0; + return impl->top(); +} + +CSSPrimitiveValue Rect::right() const +{ + if (!impl) return 0; + return impl->right(); +} + +CSSPrimitiveValue Rect::bottom() const +{ + if (!impl) return 0; + return impl->bottom(); +} + +CSSPrimitiveValue Rect::left() const +{ + if (!impl) return 0; + return impl->left(); +} + +RectImpl *Rect::handle() const +{ + return impl; +} + +bool Rect::isNull() const +{ + return (impl == 0); +} + +} // namespace + + |