css_value.cpp
/*
* 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;
QString 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 khtml::stringForListStyleType((khtml::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(qAlpha(m_color) ? qRed(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
}
CSSPrimitiveValue RGBColor::green() const
{
return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qGreen(m_color) : 0), CSSPrimitiveValue::CSS_DIMENSION);
}
CSSPrimitiveValue RGBColor::blue() const
{
return new CSSPrimitiveValueImpl(float(qAlpha(m_color) ? qBlue(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
DOM::CSSStyleDeclaration::cssText
DOM::DOMString cssText() const
The parsable textual representation of the declaration block (including the surrounding curly braces)...
Definition: css_value.cpp:63
DOM::RGBColor::red
CSSPrimitiveValue red() const
This attribute is used for the red value of the RGB color.
Definition: css_value.cpp:501
DOM::CSSPrimitiveValue::setStringValue
void setStringValue(unsigned short stringType, const DOM::DOMString &stringValue)
A method to set the string value with a specified unit.
Definition: css_value.cpp:377
DOM::CSSStyleDeclaration::length
unsigned long length() const
The number of properties that have been explicitly set in this declaration block. ...
Definition: css_value.cpp:135
DOM::CSSValue::cssText
DOM::DOMString cssText() const
A string representation of the current value.
Definition: css_value.cpp:201
DOM::CSSStyleDeclaration
The CSSStyleDeclaration interface represents a single CSS declaration block .
Definition: css_value.h:60
DOM::RGBColor::blue
CSSPrimitiveValue blue() const
This attribute is used for the blue value of the RGB color.
Definition: css_value.cpp:511
DOM::CSSPrimitiveValue::getCounterValue
Counter getCounterValue()
This method is used to get the Counter value.
Definition: css_value.cpp:395
DOM::Counter::separator
DOM::DOMString separator() const
This attribute is used for the separator of nested counters.
Definition: css_value.cpp:459
DOM::CSSStyleDeclaration::setCssText
void setCssText(const DOM::DOMString &)
see cssText SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable...
Definition: css_value.cpp:69
DOM::Counter::listStyle
DOM::DOMString listStyle() const
This attribute is used for the style of the list.
Definition: css_value.cpp:453
DOM::CSSStyleDeclaration::item
DOM::DOMString item(unsigned long index) const
Used to retrieve the properties that have been explicitly set in this declaration block...
Definition: css_value.cpp:146
DOM::Rect::left
CSSPrimitiveValue left() const
This attribute is used for the left of the rect.
Definition: css_value.cpp:569
DOM::DOMException
DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impos...
Definition: dom_exception.h:57
DOM::CSSPrimitiveValue::getRectValue
Rect getRectValue()
This method is used to get the Rect value.
Definition: css_value.cpp:401
DOM::CSSPrimitiveValue::getRGBColorValue
RGBColor getRGBColorValue()
This method is used to get the RGB color.
Definition: css_value.cpp:407
DOM::CSSStyleDeclaration::getPropertyValue
DOM::DOMString getPropertyValue(const DOM::DOMString &propertyName) const
Used to retrieve the value of a CSS property if it has been explicitly set within this declaration bl...
Definition: css_value.cpp:80
DOM::Rect::top
CSSPrimitiveValue top() const
This attribute is used for the top of the rect.
Definition: css_value.cpp:551
DOM::CSSStyleDeclaration::getPropertyCSSValue
CSSValue getPropertyCSSValue(const DOM::DOMString &propertyName) const
Used to retrieve the object representation of the value of a CSS property if it has been explicitly s...
Definition: css_value.cpp:93
DOM::CSSValue::setCssText
void setCssText(const DOM::DOMString &)
see cssText SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable...
Definition: css_value.cpp:207
DOM::CSSPrimitiveValue::getFloatValue
float getFloatValue(unsigned short unitType)
This method is used to get a float value in a specified unit.
Definition: css_value.cpp:368
DOM::CSSPrimitiveValue
The CSSPrimitiveValue interface represents a single CSS value .
Definition: css_value.h:373
DOM::DOMString
This class implements the basic string we use in the DOM.
Definition: dom_string.h:43
DOM::Rect::right
CSSPrimitiveValue right() const
This attribute is used for the right of the rect.
Definition: css_value.cpp:557
DOM::CSSStyleDeclaration::removeProperty
DOM::DOMString removeProperty(const DOM::DOMString &propertyName)
Used to remove a CSS property if it has been explicitly set within this declaration block...
Definition: css_value.cpp:101
DOM::CSSValue::cssValueType
unsigned short cssValueType() const
A code defining the type of the value as defined above.
Definition: css_value.cpp:213
DOM::CSSPrimitiveValue::setFloatValue
void setFloatValue(unsigned short unitType, float floatValue)
A method to set the float value with a specified unit.
Definition: css_value.cpp:357
DOM::CSSValueList::item
CSSValue item(unsigned long index)
Used to retrieve a CSS rule by ordinal index.
Definition: css_value.cpp:296
DOM::Rect
The Rect interface is used to represent any rect value.
Definition: css_value.h:642
DOM::Counter::identifier
DOM::DOMString identifier() const
This attribute is used for the identifier of the counter.
Definition: css_value.cpp:447
DOM::CSSStyleDeclaration::setProperty
void setProperty(const DOM::DOMString &propertyName, const DOM::DOMString &value, const DOM::DOMString &priority)
Used to set a property value and priority within this declaration block.
Definition: css_value.cpp:122
DOM::CSSRule
The CSSRule interface is the abstract base interface for any type of CSS statement ...
Definition: css_rule.h:52
DOM::CSSValueList::length
unsigned long length() const
The number of CSSValue s in the list.
Definition: css_value.cpp:290
DOM::RGBColor
The RGBColor interface is used to represent any RGB color value.
Definition: css_value.h:591
DOM::CSSException
This exception is raised when a specific CSS operation is impossible to perform.
Definition: css_stylesheet.h:173
DOM::CSSPrimitiveValue::getStringValue
DOM::DOMString getStringValue()
This method is used to get the string value in a specified unit.
Definition: css_value.cpp:389
DOM::CSSValue
The CSSValue interface represents a simple or a complexe value.
Definition: css_value.h:243
DOM::CSSPrimitiveValue::primitiveType
unsigned short primitiveType() const
The type of the value as defined by the constants specified above.
Definition: css_value.cpp:351
DOM::Counter
The Counter interface is used to represent any counter or counters function value.
Definition: css_value.h:699
DOM::CSSStyleDeclaration::getPropertyPriority
DOM::DOMString getPropertyPriority(const DOM::DOMString &propertyName) const
Used to retrieve the priority of a CSS property (e.g.
Definition: css_value.cpp:113
DOM::RGBColor::green
CSSPrimitiveValue green() const
This attribute is used for the green value of the RGB color.
Definition: css_value.cpp:506
DOM::CSSStyleDeclaration::parentRule
CSSRule parentRule() const
The CSS rule that contains this declaration block.
Definition: css_value.cpp:151
DOM::Rect::bottom
CSSPrimitiveValue bottom() const
This attribute is used for the bottom of the rect.
Definition: css_value.cpp:563

KDE Home | KDE Accessibility Home | Description of Access Keys