css_extensions.cpp

konqueror3 embedded版本, KDE环境下的当家浏览器的嵌入式版本源码包.

/**
 * This file is part of the DOM implementation for KDE.
 *
 * (C) 1999 Lars Knoll ([e-mail])
 *
 * 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_exception.h"
#include "dom_string.h"

#include "css_extensions.h"
#include "css_extensionsimpl.h"
using namespace DOM;


CSS2Azimuth::CSS2Azimuth() : CSSValue()
{
}

CSS2Azimuth::CSS2Azimuth(const CSS2Azimuth &other) : CSSValue(other)
{
}

CSS2Azimuth::CSS2Azimuth(CSS2AzimuthImpl *impl) : CSSValue(impl)
{
}

CSS2Azimuth &CSS2Azimuth::operator = (const CSS2Azimuth &other)
{
    CSSValue::operator = (other);
    return *this;
}

CSS2Azimuth::~CSS2Azimuth()
{
}

unsigned short CSS2Azimuth::azimuthType() const
{
    if(!impl) return 0;
    return ((CSS2AzimuthImpl *)impl)->azimuthType();
}

DOMString CSS2Azimuth::identifier() const
{
    if(!impl) return 0;
    return ((CSS2AzimuthImpl *)impl)->identifier();
}

bool CSS2Azimuth::behind() const
{
    if(!impl) return 0;
    return ((CSS2AzimuthImpl *)impl)->behind();
}

void CSS2Azimuth::setAngleValue( const unsigned short unitType, const float floatValue )
{
    if(impl)
        ((CSS2AzimuthImpl *)impl)->setAngleValue( unitType, floatValue );
}

float CSS2Azimuth::getAngleValue( const unsigned short unitType )
{
    if(!impl) return 0;
    return ((CSS2AzimuthImpl *)impl)->getAngleValue( unitType );
}

void CSS2Azimuth::setIdentifier( const DOMString &identifier, const bool behind )
{
    if(impl)
        ((CSS2AzimuthImpl *)impl)->setIdentifier( identifier, behind );
}



CSS2BackgroundPosition::CSS2BackgroundPosition() : CSSValue()
{
}

CSS2BackgroundPosition::CSS2BackgroundPosition(const CSS2BackgroundPosition &other) : CSSValue(other)
{
}

CSS2BackgroundPosition::CSS2BackgroundPosition(CSS2BackgroundPositionImpl *impl) : CSSValue(impl)
{
}

CSS2BackgroundPosition &CSS2BackgroundPosition::operator = (const CSS2BackgroundPosition &other)
{
    CSSValue::operator = (other);
    return *this;
}

CSS2BackgroundPosition::~CSS2BackgroundPosition()
{
}

unsigned short CSS2BackgroundPosition::horizontalType() const
{
    if(!impl) return 0;
    return ((CSS2BackgroundPositionImpl *)impl)->horizontalType();
}

unsigned short CSS2BackgroundPosition::verticalType() const
{
    if(!impl) return 0;
    return ((CSS2BackgroundPositionImpl *)impl)->verticalType();
}

DOMString CSS2BackgroundPosition::horizontalIdentifier() const
{
    if(!impl) return 0;
    return ((CSS2BackgroundPositionImpl *)impl)->horizontalIdentifier();
}

DOMString CSS2BackgroundPosition::verticalIdentifier() const
{
    if(!impl) return 0;
    return ((CSS2BackgroundPositionImpl *)impl)->verticalIdentifier();
}

float CSS2BackgroundPosition::getHorizontalPosition( const float horizontalType )
{
    if(!impl) return 0;
    return ((CSS2BackgroundPositionImpl *)impl)->getHorizontalPosition( horizontalType );
}

float CSS2BackgroundPosition::getVerticalPosition( const float verticalType )
{
    if(!impl) return 0;
    return ((CSS2BackgroundPositionImpl *)impl)->getVerticalPosition( verticalType );
}

void CSS2BackgroundPosition::setHorizontalPosition( const unsigned short horizontalType, const float value )
{
    if(impl)
        ((CSS2BackgroundPositionImpl *)impl)->setHorizontalPosition( horizontalType, value );
}

void CSS2BackgroundPosition::setVerticalPosition( const unsigned short verticalType, const float value )
{
    if(impl)
        ((CSS2BackgroundPositionImpl *)impl)->setVerticalPosition( verticalType, value );
}

void CSS2BackgroundPosition::setPositionIdentifier( const DOMString &horizontalIdentifier, const DOMString &verticalIdentifier )
{
    if(impl)
        ((CSS2BackgroundPositionImpl *)impl)->setPositionIdentifier( horizontalIdentifier, verticalIdentifier );
}



CSS2BorderSpacing::CSS2BorderSpacing() : CSSValue()
{
}

CSS2BorderSpacing::CSS2BorderSpacing(const CSS2BorderSpacing &other) : CSSValue(other)
{
}

CSS2BorderSpacing::CSS2BorderSpacing(CSS2BorderSpacingImpl *impl) : CSSValue(impl)
{
}

CSS2BorderSpacing &CSS2BorderSpacing::operator = (const CSS2BorderSpacing &other)
{
    CSSValue::operator = (other);
    return *this;
}

CSS2BorderSpacing::~CSS2BorderSpacing()
{
}

unsigned short CSS2BorderSpacing::horizontalType() const
{
    if(!impl) return 0;
    return ((CSS2BorderSpacingImpl *)impl)->horizontalType();
}

unsigned short CSS2BorderSpacing::verticalType() const
{
    if(!impl) return 0;
    return ((CSS2BorderSpacingImpl *)impl)->verticalType();
}

float CSS2BorderSpacing::getHorizontalSpacing( const float horizontalType )
{
    if(!impl) return 0;
    return ((CSS2BorderSpacingImpl *)impl)->getHorizontalSpacing( horizontalType );
}

float CSS2BorderSpacing::getVerticalSpacing( const float verticalType )
{
    if(!impl) return 0;
    return ((CSS2BorderSpacingImpl *)impl)->getVerticalSpacing( verticalType );
}

void CSS2BorderSpacing::setHorizontalSpacing( const unsigned short horizontalType, const float value )
{
    if(impl)
        ((CSS2BorderSpacingImpl *)impl)->setHorizontalSpacing( horizontalType, value );
}

void CSS2BorderSpacing::setVerticalSpacing( const unsigned short verticalType, const float value )
{
    if(impl)
        ((CSS2BorderSpacingImpl *)impl)->setVerticalSpacing( verticalType, value );
}

void CSS2BorderSpacing::setInherit()
{
    if(impl)
        ((CSS2BorderSpacingImpl *)impl)->setInherit();
}



CSS2CounterIncrement::CSS2CounterIncrement()
{
}

CSS2CounterIncrement::CSS2CounterIncrement(const CSS2CounterIncrement &other)
{
}

CSS2CounterIncrement::CSS2CounterIncrement(CSS2CounterIncrementImpl *impl)
{
}

CSS2CounterIncrement &CSS2CounterIncrement::operator = (const CSS2CounterIncrement &other)
{
    ::operator = (other);
    return *this;
}

CSS2CounterIncrement::~CSS2CounterIncrement()
{
}

DOMString CSS2CounterIncrement::identifier() const
{
    if(!impl) return 0;
    return ((ElementImpl *)impl)->getAttribute("identifier");
}

void CSS2CounterIncrement::setIdentifier( const DOMString &value )
{
    if(impl) ((ElementImpl *)impl)->setAttribute("identifier", value);
}

short CSS2CounterIncrement::increment() const
{
    if(!impl) return 0;
    return ((CSS2CounterIncrementImpl *)impl)->increment();
}

void CSS2CounterIncrement::setIncrement( const short _increment )
{

    if(impl)
        ((CSS2CounterIncrementImpl *)impl)->setIncrement( _increment );
}




CSS2CounterReset::CSS2CounterReset()
{
}

CSS2CounterReset::CSS2CounterReset(const CSS2CounterReset &other)
{
}

CSS2CounterReset::CSS2CounterReset(CSS2CounterResetImpl *impl)
{
}

CSS2CounterReset &CSS2CounterReset::operator = (const CSS2CounterReset &other)
{
    ::operator = (other);
    return *this;
}

CSS2CounterReset::~CSS2CounterReset()
{
}

DOMString CSS2CounterReset::identifier() const
{
    if(!impl) return 0;
    return ((ElementImpl *)impl)->getAttribute("identifier");
}

void CSS2CounterReset::setIdentifier( const DOMString &value )
{
    if(impl) ((ElementImpl *)impl)->setAttribute("identifier", value);
}

short CSS2CounterReset::reset() const
{
    if(!impl) return 0;
    return ((CSS2CounterResetImpl *)impl)->reset();
}

void CSS2CounterReset::setReset( const short _reset )
{

    if(impl)
        ((CSS2CounterResetImpl *)impl)->setReset( _reset );
}




CSS2Cursor::CSS2Cursor() : CSSValue()
{
}

CSS2Cursor::CSS2Cursor(const CSS2Cursor &other) : CSSValue(other)
{
}

CSS2Cursor::CSS2Cursor(CSS2CursorImpl *impl) : CSSValue(impl)
{
}

CSS2Cursor &CSS2Cursor::operator = (const CSS2Cursor &other)
{
    CSSValue::operator = (other);
    return *this;
}

CSS2Cursor::~CSS2Cursor()
{
}

unsigned short CSS2Cursor::cursorType() const
{
    if(!impl) return 0;
    return ((CSS2CursorImpl *)impl)->cursorType();
}

void CSS2Cursor::setCursorType( const unsigned short _cursorType )
{

    if(impl)
        ((CSS2CursorImpl *)impl)->setCursorType( _cursorType );
}

CSSValueList CSS2Cursor::uris() const
{
    if(!impl) return 0;
    return ((CSS2CursorImpl *)impl)->uris();
}

DOMString CSS2Cursor::predefinedCursor() const
{
    if(!impl) return 0;
    return ((ElementImpl *)impl)->getAttribute("predefinedCursor");
}

void CSS2Cursor::setPredefinedCursor( const DOMString &value )
{
    if(impl) ((ElementImpl *)impl)->setAttribute("predefinedCursor", value);
}



CSS2FontFaceSrc::CSS2FontFaceSrc()
{
}

CSS2FontFaceSrc::CSS2FontFaceSrc(const CSS2FontFaceSrc &other)
{
}

CSS2FontFaceSrc::CSS2FontFaceSrc(CSS2FontFaceSrcImpl *impl)
{
}

CSS2FontFaceSrc &CSS2FontFaceSrc::operator = (const CSS2FontFaceSrc &other)
{
    ::operator = (other);
    return *this;
}

CSS2FontFaceSrc::~CSS2FontFaceSrc()
{
}

DOMString CSS2FontFaceSrc::uri() const
{
    if(!impl) return 0;
    return ((ElementImpl *)impl)->getAttribute("uri");
}

void CSS2FontFaceSrc::setUri( const DOMString &value )
{
    if(impl) ((ElementImpl *)impl)->setAttribute("uri", value);
}

CSSValueList CSS2FontFaceSrc::format() const
{
    if(!impl) return 0;
    return ((CSS2FontFaceSrcImpl *)impl)->format();
}

DOMString CSS2FontFaceSrc::fontFaceName() const
{
    if(!impl) return 0;
    return ((ElementImpl *)impl)->getAttribute("fontFaceName");
}

void CSS2FontFaceSrc::setFontFaceName( const DOMString &value )
{
    if(impl) ((ElementImpl *)impl)->setAttribute("fontFaceName", value);
}



CSS2FontFaceWidths::CSS2FontFaceWidths()
{
}

CSS2FontFaceWidths::CSS2FontFaceWidths(const CSS2FontFaceWidths &other)
{
}

CSS2FontFaceWidths::CSS2FontFaceWidths(CSS2FontFaceWidthsImpl *impl)
{
}

CSS2FontFaceWidths &CSS2FontFaceWidths::operator = (const CSS2FontFaceWidths &other)
{
    ::operator = (other);
    return *this;
}

CSS2FontFaceWidths::~CSS2FontFaceWidths()
{
}

DOMString CSS2FontFaceWidths::urange() const
{
    if(!impl) return 0;
    return ((ElementImpl *)impl)->getAttribute("urange");
}

void CSS2FontFaceWidths::setUrange( const DOMString &value )
{
    if(impl) ((ElementImpl *)impl)->setAttribute("urange", value);
}

CSSValueList CSS2FontFaceWidths::numbers() const
{
    if(!impl) return 0;
    return ((CSS2FontFaceWidthsImpl *)impl)->numbers();
}




CSS2PageSize::CSS2PageSize() : CSSValue()
{
}

CSS2PageSize::CSS2PageSize(const CSS2PageSize &other) : CSSValue(other)
{
}

CSS2PageSize::CSS2PageSize(CSS2PageSizeImpl *impl) : CSSValue(impl)
{
}

CSS2PageSize &CSS2PageSize::operator = (const CSS2PageSize &other)
{
    CSSValue::operator = (other);
    return *this;
}

CSS2PageSize::~CSS2PageSize()
{
}

unsigned short CSS2PageSize::widthType() const
{
    if(!impl) return 0;
    return ((CSS2PageSizeImpl *)impl)->widthType();
}

unsigned short CSS2PageSize::heightType() const
{
    if(!impl) return 0;
    return ((CSS2PageSizeImpl *)impl)->heightType();