|
|
|
/*
|
|
|
|
Copyright (C) 2001-2003 KSVG Team
|
|
|
|
This file is part of the KDE project
|
|
|
|
|
|
|
|
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 <kdebug.h>
|
|
|
|
|
|
|
|
#include <tqtimer.h>
|
|
|
|
#include <tqstringlist.h>
|
|
|
|
#include <tqdatetime.h>
|
|
|
|
|
|
|
|
#define USE_VALGRIND 0
|
|
|
|
|
|
|
|
#if USE_VALGRIND
|
|
|
|
#include <valgrind/calltree.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "SVGLength.h"
|
|
|
|
|
|
|
|
#include "SVGRectImpl.h"
|
|
|
|
#include "SVGAngleImpl.h"
|
|
|
|
#include "SVGShapeImpl.h"
|
|
|
|
#include "SVGPointImpl.h"
|
|
|
|
#include "SVGNumberImpl.h"
|
|
|
|
#include "SVGMatrixImpl.h"
|
|
|
|
|
|
|
|
#include "SVGEventImpl.h"
|
|
|
|
#include "SVGAElementImpl.h"
|
|
|
|
#include "SVGDocumentImpl.h"
|
|
|
|
#include "SVGViewSpecImpl.h"
|
|
|
|
#include "SVGTransformImpl.h"
|
|
|
|
#include "SVGSVGElementImpl.h"
|
|
|
|
#include "SVGAnimatedRectImpl.h"
|
|
|
|
#include "SVGTransformListImpl.h"
|
|
|
|
#include "SVGAnimatedLengthImpl.h"
|
|
|
|
#include "SVGAnimatedStringImpl.h"
|
|
|
|
#include "SVGPreserveAspectRatioImpl.h"
|
|
|
|
#include "SVGAnimatedTransformListImpl.h"
|
|
|
|
#include "SVGAnimatedPreserveAspectRatioImpl.h"
|
|
|
|
|
|
|
|
#include "CanvasItem.h"
|
|
|
|
#include "KSVGCanvas.h"
|
|
|
|
|
|
|
|
using namespace KSVG;
|
|
|
|
|
|
|
|
#include "SVGSVGElementImpl.lut.h"
|
|
|
|
#include "ksvg_scriptinterpreter.h"
|
|
|
|
#include "ksvg_bridge.h"
|
|
|
|
#include "ksvg_ecma.h"
|
|
|
|
|
|
|
|
SVGSVGElementImpl::SVGSVGElementImpl(DOM::ElementImpl *impl) : SVGContainerImpl(impl), SVGTestsImpl(), SVGLangSpaceImpl(), SVGExternalResourcesRequiredImpl(), SVGStylableImpl(this), SVGLocatableImpl(), SVGFitToViewBoxImpl(), SVGZoomAndPanImpl()
|
|
|
|
{
|
|
|
|
KSVG_EMPTY_FLAGS
|
|
|
|
|
|
|
|
m_x = new SVGAnimatedLengthImpl(LENGTHMODE_WIDTH, this);
|
|
|
|
m_x->ref();
|
|
|
|
|
|
|
|
m_y = new SVGAnimatedLengthImpl(LENGTHMODE_HEIGHT, this);
|
|
|
|
m_y->ref();
|
|
|
|
|
|
|
|
m_width = new SVGAnimatedLengthImpl(LENGTHMODE_WIDTH, this);
|
|
|
|
m_width->ref();
|
|
|
|
|
|
|
|
m_height = new SVGAnimatedLengthImpl(LENGTHMODE_HEIGHT, this);
|
|
|
|
m_height->ref();
|
|
|
|
|
|
|
|
m_viewport = SVGSVGElementImpl::createSVGRect();
|
|
|
|
|
|
|
|
m_currentTranslate = SVGSVGElementImpl::createSVGPoint();
|
|
|
|
|
|
|
|
m_currentView = new SVGViewSpecImpl();
|
|
|
|
m_currentView->ref();
|
|
|
|
|
|
|
|
m_currentScale = 1.0;
|
|
|
|
|
|
|
|
m_useCurrentView = false;
|
|
|
|
|
|
|
|
m_clip[0] = 0;
|
|
|
|
m_clip[1] = 0;
|
|
|
|
m_clip[2] = 0;
|
|
|
|
m_clip[3] = 0;
|
|
|
|
|
|
|
|
m_rootParentScreenCTM = 0;
|
|
|
|
|
|
|
|
m_localMatrix = SVGSVGElementImpl::createSVGMatrix();
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGSVGElementImpl::~SVGSVGElementImpl()
|
|
|
|
{
|
|
|
|
if(m_x)
|
|
|
|
m_x->deref();
|
|
|
|
if(m_y)
|
|
|
|
m_y->deref();
|
|
|
|
if(m_width)
|
|
|
|
m_width->deref();
|
|
|
|
if(m_height)
|
|
|
|
m_height->deref();
|
|
|
|
if(m_viewport)
|
|
|
|
m_viewport->deref();
|
|
|
|
if(m_currentTranslate)
|
|
|
|
m_currentTranslate->deref();
|
|
|
|
if(m_currentView)
|
|
|
|
m_currentView->deref();
|
|
|
|
if(m_rootParentScreenCTM)
|
|
|
|
m_rootParentScreenCTM->deref();
|
|
|
|
if(m_localMatrix)
|
|
|
|
m_localMatrix->deref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SVGSVGElementImpl::isRootElement() const
|
|
|
|
{
|
|
|
|
return ownerDoc()->rootElement() == this;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setAttributes()
|
|
|
|
{
|
|
|
|
SVGElementImpl::setAttributes();
|
|
|
|
|
|
|
|
// Spec: if not specified, effect is as if a value of "0" were specified
|
|
|
|
if(KSVG_TOKEN_NOT_PARSED(X))
|
|
|
|
KSVG_SET_ALT_ATTRIBUTE(X, "0")
|
|
|
|
|
|
|
|
// Spec: if not specified, effect is as if a value of "0" were specified
|
|
|
|
if(KSVG_TOKEN_NOT_PARSED(Y))
|
|
|
|
KSVG_SET_ALT_ATTRIBUTE(Y, "0")
|
|
|
|
|
|
|
|
// Spec: If the attribute is not specified, the effect is as if a value of "100%" were specified.
|
|
|
|
if(KSVG_TOKEN_NOT_PARSED(Width))
|
|
|
|
KSVG_SET_ALT_ATTRIBUTE(Width, "100%")
|
|
|
|
|
|
|
|
// Spec: If the attribute is not specified, the effect is as if a value of "100%" were specified.
|
|
|
|
if(KSVG_TOKEN_NOT_PARSED(Height))
|
|
|
|
KSVG_SET_ALT_ATTRIBUTE(Height, "100%")
|
|
|
|
|
|
|
|
// Spec: The contentScriptType should default to "text/ecmascript".
|
|
|
|
if(KSVG_TOKEN_NOT_PARSED(ContentScriptType))
|
|
|
|
KSVG_SET_ALT_ATTRIBUTE(ContentScriptType, "text/ecmascript")
|
|
|
|
|
|
|
|
// Spec: The contentStyleType should default to "text/css".
|
|
|
|
if(KSVG_TOKEN_NOT_PARSED(ContentStyleType))
|
|
|
|
KSVG_SET_ALT_ATTRIBUTE(ContentStyleType, "text/css")
|
|
|
|
|
|
|
|
if(m_useCurrentView)
|
|
|
|
{
|
|
|
|
parseViewBox(m_currentView->viewBoxString().string());
|
|
|
|
preserveAspectRatio()->baseVal()->parsePreserveAspectRatio(m_currentView->preserveAspectRatioString().string());
|
|
|
|
}
|
|
|
|
|
|
|
|
m_viewport->setX(x()->baseVal()->value());
|
|
|
|
m_viewport->setY(y()->baseVal()->value());
|
|
|
|
m_viewport->setWidth(width()->baseVal()->value());
|
|
|
|
m_viewport->setHeight(height()->baseVal()->value());
|
|
|
|
|
|
|
|
if(isRootElement() && ownerDoc()->tqparentImage() == 0)
|
|
|
|
{
|
|
|
|
if(ownerDoc()->canvas())
|
|
|
|
ownerDoc()->canvas()->setViewportDimension(int(ceil(width()->baseVal()->value() * currentScale())), int(ceil(height()->baseVal()->value() * currentScale())));
|
|
|
|
|
|
|
|
// Special case for outermost svg element:
|
|
|
|
// We need to register our id manually, because
|
|
|
|
// m_ownerSVGElement is 0 in SVGElementImpl::setAttributes (Niko)
|
|
|
|
if(!id().isNull())
|
|
|
|
addToIdMap(id().string(), this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGAnimatedLengthImpl *SVGSVGElementImpl::x()
|
|
|
|
{
|
|
|
|
return m_x;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGAnimatedLengthImpl *SVGSVGElementImpl::y()
|
|
|
|
{
|
|
|
|
return m_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGAnimatedLengthImpl *SVGSVGElementImpl::width()
|
|
|
|
{
|
|
|
|
return m_width;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGAnimatedLengthImpl *SVGSVGElementImpl::height()
|
|
|
|
{
|
|
|
|
return m_height;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setContentScriptType(const DOM::DOMString &contentScriptType)
|
|
|
|
{
|
|
|
|
setAttribute("contentScriptType", contentScriptType);
|
|
|
|
}
|
|
|
|
|
|
|
|
DOM::DOMString SVGSVGElementImpl::contentScriptType() const
|
|
|
|
{
|
|
|
|
return getAttribute("contentScriptType");
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setContentStyleType(const DOM::DOMString &contentStyleType)
|
|
|
|
{
|
|
|
|
setAttribute("contentStyleType", contentStyleType);
|
|
|
|
}
|
|
|
|
|
|
|
|
DOM::DOMString SVGSVGElementImpl::contentStyleType() const
|
|
|
|
{
|
|
|
|
return getAttribute("contentStyleType");
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGRectImpl *SVGSVGElementImpl::viewport()
|
|
|
|
{
|
|
|
|
return m_viewport;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGRectImpl *SVGSVGElementImpl::getBBox()
|
|
|
|
{
|
|
|
|
SVGRectImpl *ret = new SVGRectImpl(getCTM()->qmatrix().invert().map(m_viewport->qrect()));
|
|
|
|
ret->ref();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
float SVGSVGElementImpl::pixelUnitToMillimeterX() const
|
|
|
|
{
|
|
|
|
return ownerDoc()->screenPixelsPerMillimeterX();
|
|
|
|
}
|
|
|
|
|
|
|
|
float SVGSVGElementImpl::pixelUnitToMillimeterY() const
|
|
|
|
{
|
|
|
|
return ownerDoc()->screenPixelsPerMillimeterY();
|
|
|
|
}
|
|
|
|
|
|
|
|
float SVGSVGElementImpl::screenPixelToMillimeterX() const
|
|
|
|
{
|
|
|
|
return pixelUnitToMillimeterX();
|
|
|
|
}
|
|
|
|
|
|
|
|
float SVGSVGElementImpl::screenPixelToMillimeterY() const
|
|
|
|
{
|
|
|
|
return pixelUnitToMillimeterY();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setUseCurrentView(bool useCurrentView)
|
|
|
|
{
|
|
|
|
m_useCurrentView = useCurrentView;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SVGSVGElementImpl::useCurrentView() const
|
|
|
|
{
|
|
|
|
return m_useCurrentView;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGViewSpecImpl *SVGSVGElementImpl::currentView() const
|
|
|
|
{
|
|
|
|
return m_currentView;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setCurrentScale(float currentScale)
|
|
|
|
{
|
|
|
|
if( m_currentScale != currentScale )
|
|
|
|
{
|
|
|
|
m_currentScale = currentScale;
|
|
|
|
tqinvalidateCachedMatrices();
|
|
|
|
|
|
|
|
if(hasEventListener(SVGEvent::ZOOM_EVENT, true))
|
|
|
|
dispatchEvent(SVGEvent::ZOOM_EVENT, false, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
float SVGSVGElementImpl::currentScale() const
|
|
|
|
{
|
|
|
|
return m_currentScale;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setCurrentTranslate(const TQPoint &p)
|
|
|
|
{
|
|
|
|
if(m_currentTranslate->x() != p.x() || m_currentTranslate->y() != p.y())
|
|
|
|
{
|
|
|
|
m_currentTranslate->setX(p.x());
|
|
|
|
m_currentTranslate->setY(p.y());
|
|
|
|
tqinvalidateCachedMatrices();
|
|
|
|
if(hasEventListener(SVGEvent::SCROLL_EVENT, true))
|
|
|
|
dispatchEvent(SVGEvent::SCROLL_EVENT, false, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGPointImpl *SVGSVGElementImpl::currentTranslate()
|
|
|
|
{
|
|
|
|
return m_currentTranslate;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long SVGSVGElementImpl::suspendRedraw(unsigned long)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::unsuspendRedraw(unsigned long)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::unsuspendRedrawAll()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::forceRedraw()
|
|
|
|
{
|
|
|
|
#if USE_VALGRIND
|
|
|
|
CALLTREE_ZERO_STATS();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
TQTime timer;
|
|
|
|
timer.start();
|
|
|
|
|
|
|
|
if(ownerDoc() && ownerDoc()->canvas())
|
|
|
|
ownerDoc()->canvas()->update();
|
|
|
|
|
|
|
|
kdDebug(26000) << "forceRedraw in " << timer.elapsed()/1000.0 << " seconds" << endl;
|
|
|
|
|
|
|
|
#if USE_VALGRIND
|
|
|
|
CALLTREE_DUMP_STATS();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::pauseAnimations()
|
|
|
|
{
|
|
|
|
if(!ownerDoc()->timeScheduler()->animationsPaused())
|
|
|
|
ownerDoc()->timeScheduler()->toggleAnimations();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::unpauseAnimations()
|
|
|
|
{
|
|
|
|
if(ownerDoc()->timeScheduler()->animationsPaused())
|
|
|
|
ownerDoc()->timeScheduler()->toggleAnimations();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SVGSVGElementImpl::animationsPaused()
|
|
|
|
{
|
|
|
|
return ownerDoc()->timeScheduler()->animationsPaused();
|
|
|
|
}
|
|
|
|
|
|
|
|
float SVGSVGElementImpl::getCurrentTime() const
|
|
|
|
{
|
|
|
|
return ownerDoc()->timeScheduler()->elapsed();
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setCurrentTime(float)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
DOM::NodeList SVGSVGElementImpl::getIntersectionList(SVGRectImpl *, SVGElementImpl *)
|
|
|
|
{
|
|
|
|
// TODO : implement me
|
|
|
|
return DOM::NodeList();
|
|
|
|
}
|
|
|
|
|
|
|
|
DOM::NodeList SVGSVGElementImpl::getEnclosureList(SVGRectImpl *rect, SVGElementImpl */*referenceElement*/)
|
|
|
|
{
|
|
|
|
DOM::NodeList list;
|
|
|
|
|
|
|
|
DOM::Node node = firstChild();
|
|
|
|
for(; !node.isNull(); node = node.nextSibling())
|
|
|
|
{
|
|
|
|
SVGElementImpl *element = ownerDoc()->getElementFromHandle(node.handle());
|
|
|
|
SVGShapeImpl *tqshape = dynamic_cast<SVGShapeImpl *>(element);
|
|
|
|
if(tqshape)
|
|
|
|
{
|
|
|
|
if(tqshape->isContainer())
|
|
|
|
// TODO : pass it on to container::getEnclosureList() which should return a NodeList
|
|
|
|
kdDebug() << "!tqshape" << endl;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// TODO : add the tqshape to list if the test succeeds
|
|
|
|
SVGRectImpl *current = tqshape->getBBox();
|
|
|
|
if(rect->qrect().tqcontains(current->qrect(), true))
|
|
|
|
kdDebug() << "tqshape : " << element->nodeName().string() << " is fully enclosed" << endl;
|
|
|
|
|
|
|
|
current->deref();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SVGSVGElementImpl::checkIntersection(SVGElementImpl *element, SVGRectImpl *rect)
|
|
|
|
{
|
|
|
|
SVGShapeImpl *tqshape = dynamic_cast<SVGShapeImpl *>(element);
|
|
|
|
if(!tqshape)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SVGRectImpl *current = tqshape->getBBox();
|
|
|
|
bool result = rect->qrect().intersects(current->qrect());
|
|
|
|
current->deref();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SVGSVGElementImpl::checkEnclosure(SVGElementImpl *element, SVGRectImpl *rect)
|
|
|
|
{
|
|
|
|
SVGShapeImpl *tqshape = dynamic_cast<SVGShapeImpl *>(element);
|
|
|
|
if(!tqshape)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
SVGRectImpl *current = tqshape->getBBox();
|
|
|
|
bool result = rect->qrect().tqcontains(current->qrect());
|
|
|
|
current->deref();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::deSelectAll()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGNumberImpl *SVGSVGElementImpl::createSVGNumber()
|
|
|
|
{
|
|
|
|
// Spec: Creates an SVGNumber object outside of any document
|
|
|
|
// trees. The object is initialized to a value of zero.
|
|
|
|
SVGNumberImpl *ret = new SVGNumberImpl();
|
|
|
|
ret->ref();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGLengthImpl *SVGSVGElementImpl::createSVGLength()
|
|
|
|
{
|
|
|
|
// Spec: Creates an SVGLength object outside of any document
|
|
|
|
// trees. The object is initialized to the value of 0 user units.
|
|
|
|
SVGLengthImpl *ret = new SVGLengthImpl();
|
|
|
|
ret->ref();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGAngleImpl *SVGSVGElementImpl::createSVGAngle()
|
|
|
|
{
|
|
|
|
// Spec: Creates an SVGAngle object outside of any document
|
|
|
|
// trees. The object is initialized to the value 0 degrees (unitless).
|
|
|
|
SVGAngleImpl *ret = new SVGAngleImpl();
|
|
|
|
ret->ref();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGPointImpl *SVGSVGElementImpl::createSVGPoint()
|
|
|
|
{
|
|
|
|
// Spec: Creates an SVGPoint object outside of any document
|
|
|
|
// trees. The object is initialized to the point (0,0) in the user coordinate system.
|
|
|
|
SVGPointImpl *ret = new SVGPointImpl();
|
|
|
|
ret->ref();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGMatrixImpl *SVGSVGElementImpl::createSVGMatrix()
|
|
|
|
{
|
|
|
|
// Spec: Creates an SVGMatrix object outside of any document
|
|
|
|
// trees. The object is initialized to the identity matrix.
|
|
|
|
SVGMatrixImpl *ret = new SVGMatrixImpl(TQWMatrix(1.0F, 0.0F, 0.0F, 1.0F, 0.0F, 0.0F));
|
|
|
|
ret->ref();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGRectImpl *SVGSVGElementImpl::createSVGRect()
|
|
|
|
{
|
|
|
|
// Spec: Creates an SVGRect object outside of any document
|
|
|
|
// trees. The object is initialized such that all values are set to 0 user units.
|
|
|
|
SVGRectImpl *ret = new SVGRectImpl();
|
|
|
|
ret->ref();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGTransformImpl *SVGSVGElementImpl::createSVGTransform()
|
|
|
|
{
|
|
|
|
// Spec: Creates an SVGTransform object outside of any document
|
|
|
|
// trees. The object is initialized to an identity matrix transform (SVG_TRANSFORM_MATRIX).
|
|
|
|
SVGTransformImpl *transform = createSVGTransformFromMatrix(createSVGMatrix());
|
|
|
|
|
|
|
|
// createSVGMatrix already ref's the matrix, the SVGTransformImpl->setMatrix
|
|
|
|
// call also does this, prevent non deleting of the object by deref'ing (Niko)
|
|
|
|
transform->matrix()->deref();
|
|
|
|
|
|
|
|
return transform;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGTransformImpl *SVGSVGElementImpl::createSVGTransformFromMatrix(SVGMatrixImpl *mat)
|
|
|
|
{
|
|
|
|
// Spec: Creates an SVGTransform object outside of any document
|
|
|
|
// trees. The object is initialized to the given matrix transform (i.e., SVG_TRANSFORM_MATRIX).
|
|
|
|
SVGTransformImpl *ret = new SVGTransformImpl();
|
|
|
|
ret->setMatrix(mat);
|
|
|
|
ret->ref();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGElementImpl *SVGSVGElementImpl::getElementById(const DOM::DOMString &elementId)
|
|
|
|
{
|
|
|
|
return m_map[elementId.string()];
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::addToIdMap(const TQString &id, SVGElementImpl *obj)
|
|
|
|
{
|
|
|
|
m_map.insert(id, obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
SVGMatrixImpl *SVGSVGElementImpl::getCTM()
|
|
|
|
{
|
|
|
|
return viewBoxToViewTransform(width()->baseVal()->value(), height()->baseVal()->value());
|
|
|
|
}
|
|
|
|
|
|
|
|
const SVGMatrixImpl *SVGSVGElementImpl::localMatrix()
|
|
|
|
{
|
|
|
|
// TODO: only update the matrix when needed and just return m_localMatrix
|
|
|
|
|
|
|
|
m_localMatrix->reset();
|
|
|
|
|
|
|
|
if(ownerSVGElement() == 0)
|
|
|
|
{
|
|
|
|
if(m_rootParentScreenCTM != 0)
|
|
|
|
m_localMatrix->copy(m_rootParentScreenCTM);
|
|
|
|
|
|
|
|
// We're the outermost svg element.
|
|
|
|
// Put the zoom scale and translate into the matrix.
|
|
|
|
m_localMatrix->translate(currentTranslate()->x(), currentTranslate()->y());
|
|
|
|
m_localMatrix->scale(currentScale());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Apply viewport translation.
|
|
|
|
m_localMatrix->translate(x()->baseVal()->value(), y()->baseVal()->value());
|
|
|
|
|
|
|
|
// And viewbox.
|
|
|
|
SVGMatrixImpl *viewboxMatrix = viewBoxToViewTransform(width()->baseVal()->value(), height()->baseVal()->value());
|
|
|
|
|
|
|
|
m_localMatrix->multiply(viewboxMatrix);
|
|
|
|
viewboxMatrix->deref();
|
|
|
|
|
|
|
|
return m_localMatrix;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setClip(const TQString &clip)
|
|
|
|
{
|
|
|
|
// TODO : this routine should probably be shared between all classes that establish new viewports (Rob)
|
|
|
|
if(!clip.startsWith("rect(") || !clip.endsWith(")"))
|
|
|
|
return;
|
|
|
|
|
|
|
|
TQString work = clip.mid(5, clip.length() - 6);
|
|
|
|
TQStringList substrings = TQStringList::split(',', clip);
|
|
|
|
TQStringList::ConstIterator it = substrings.begin();
|
|
|
|
|
|
|
|
if(m_clip[0])
|
|
|
|
m_clip[0]->deref();
|
|
|
|
m_clip[0] = SVGSVGElementImpl::createSVGLength();
|
|
|
|
|
|
|
|
if(*it != "auto")
|
|
|
|
m_clip[0]->setValueAsString(*it);
|
|
|
|
++it;
|
|
|
|
|
|
|
|
if(m_clip[1])
|
|
|
|
m_clip[1]->deref();
|
|
|
|
m_clip[1] = SVGSVGElementImpl::createSVGLength();
|
|
|
|
|
|
|
|
if(*it != "auto")
|
|
|
|
m_clip[1]->setValueAsString(*it);
|
|
|
|
++it;
|
|
|
|
|
|
|
|
if(m_clip[2])
|
|
|
|
m_clip[2]->deref();
|
|
|
|
m_clip[2] = SVGSVGElementImpl::createSVGLength();
|
|
|
|
|
|
|
|
if(*it != "auto")
|
|
|
|
m_clip[2]->setValueAsString(*it);
|
|
|
|
++it;
|
|
|
|
|
|
|
|
if(m_clip[3])
|
|
|
|
m_clip[3]->deref();
|
|
|
|
m_clip[3] = SVGSVGElementImpl::createSVGLength();
|
|
|
|
|
|
|
|
if(*it != "auto")
|
|
|
|
m_clip[3]->setValueAsString(*it);
|
|
|
|
}
|
|
|
|
|
|
|
|
TQRect SVGSVGElementImpl::clip()
|
|
|
|
{
|
|
|
|
// Get viewport in user coordinates.
|
|
|
|
TQRect v(0, 0, m_viewport->qrect().width(), m_viewport->qrect().height());
|
|
|
|
|
|
|
|
SVGMatrixImpl *ctm = getCTM();
|
|
|
|
TQRect r = ctm->qmatrix().invert().mapRect(v);
|
|
|
|
ctm->deref();
|
|
|
|
|
|
|
|
if(m_clip[0])
|
|
|
|
r.setTop(static_cast<int>(r.top() + m_clip[0]->value()));
|
|
|
|
if(m_clip[1])
|
|
|
|
r.setRight(static_cast<int>(r.right() - m_clip[1]->value()));
|
|
|
|
if(m_clip[2])
|
|
|
|
r.setBottom(static_cast<int>(r.bottom() - m_clip[2]->value()));
|
|
|
|
if(m_clip[3])
|
|
|
|
r.setLeft(static_cast<int>(r.left() + m_clip[3]->value()));
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::setRootParentScreenCTM(SVGMatrixImpl *screenCTM)
|
|
|
|
{
|
|
|
|
if(m_rootParentScreenCTM != 0)
|
|
|
|
m_rootParentScreenCTM->deref();
|
|
|
|
|
|
|
|
m_rootParentScreenCTM = screenCTM;
|
|
|
|
screenCTM->ref();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool SVGSVGElementImpl::prepareMouseEvent(const TQPoint &p, const TQPoint &a, SVGMouseEventImpl *mev)
|
|
|
|
{
|
|
|
|
// mop: central bool var which turns to true once the current "mouseover" element has been found
|
|
|
|
bool ret = false, dorerender = false;
|
|
|
|
SVGElementImpl *elem = 0;
|
|
|
|
|
|
|
|
SVGMatrixImpl *ctm = getCTM();
|
|
|
|
TQPoint userA = ctm->qmatrix().invert().map(a);
|
|
|
|
ctm->deref();
|
|
|
|
|
|
|
|
// Just check the lastTarget once (mop)
|
|
|
|
if(ownerDoc()->lastTarget())
|
|
|
|
{
|
|
|
|
elem = ownerDoc()->lastTarget();
|
|
|
|
ret = elem->prepareMouseEvent(p, userA, mev);
|
|
|
|
|
|
|
|
// mop: only proceed if element is not the current element anymore. rest is done in the lower part
|
|
|
|
if(!ret)
|
|
|
|
{
|
|
|
|
if(elem->hasEventListener(SVGEvent::MOUSEOUT_EVENT, false))
|
|
|
|
{
|
|
|
|
dorerender = true;
|
|
|
|
elem->setMouseOver(false);
|
|
|
|
elem->dispatchMouseEvent(SVGEvent::MOUSEOUT_EVENT, true, true, 0, mev->screenX(), mev->screenY(), mev->clientX(), mev->clientY(), mev->ctrlKey(), mev->altKey(), mev->shiftKey(), mev->metaKey(), mev->button(), elem);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(elem->hasEventListener(SVGEvent::DOMFOCUSOUT_EVENT, false) && elem->focus())
|
|
|
|
{
|
|
|
|
dorerender = true;
|
|
|
|
elem->setFocus(false);
|
|
|
|
elem->dispatchEvent(SVGEvent::DOMFOCUSOUT_EVENT, true, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
// mop: unset last target once we left it
|
|
|
|
ownerDoc()->setLastTarget(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// mop: DAMN...logic doesn't work :(
|
|
|
|
// we cant use the results of the above check because something like this
|
|
|
|
// _________
|
|
|
|
// | ____ |
|
|
|
|
// ||____| |
|
|
|
|
// |_________|
|
|
|
|
//
|
|
|
|
// wouldn't work because even if the mousepointer would be in the inner rect it would still be inside the bbox
|
|
|
|
// of the outer (assuming that the outer is the lastTarget). :(
|
|
|
|
ret = false;
|
|
|
|
|
|
|
|
// mop: just check for a node until the element where the mouse is over is found
|
|
|
|
// mop: "ret" can be set from the above stuff too...
|
|
|
|
// find the element here and do the event stuff in the lower part..much cleaner
|
|
|
|
CanvasItemList hits = ownerDoc()->canvas()->collisions(p, true);
|
|
|
|
for(CanvasItemList::Iterator it = hits.begin(); it != hits.end(); ++it)
|
|
|
|
{
|
|
|
|
elem = (*it)->element();
|
|
|
|
if(elem)
|
|
|
|
{
|
|
|
|
// Check if mouse is over a certain tqshape...
|
|
|
|
// mop: once an element has been found check eventlisteners and leave immediately
|
|
|
|
ret = elem->prepareMouseEvent(p, userA, mev);
|
|
|
|
if(ret) break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// mop: has an element been found?
|
|
|
|
if(ret)
|
|
|
|
{
|
|
|
|
int events = mev->target()->getEventListeners(false);
|
|
|
|
|
|
|
|
// Dispatch mousemove, mousedown, mouseup and mouseclick events
|
|
|
|
bool cancel = (mev->id() != SVGEvent::MOUSEMOVE_EVENT);
|
|
|
|
|
|
|
|
if(events & 1 << mev->id())
|
|
|
|
{
|
|
|
|
mev->target()->dispatchMouseEvent(mev->id(), true, cancel, 0, mev->screenX(), mev->screenY(), mev->clientX(), mev->clientY(), mev->ctrlKey(), mev->altKey(), mev->shiftKey(), mev->metaKey(), mev->button(), elem);
|
|
|
|
dorerender = true; // mop: if it has the event then rerender
|
|
|
|
}
|
|
|
|
|
|
|
|
// If a mouse "moves" over a tqshape, it's also "over" the tqshape
|
|
|
|
if(mev->id() == SVGEvent::MOUSEMOVE_EVENT)
|
|
|
|
{
|
|
|
|
mev->target()->setMouseOver(true);
|
|
|
|
if(events & 1 << SVGEvent::MOUSEOVER_EVENT)
|
|
|
|
{
|
|
|
|
mev->target()->dispatchMouseEvent(SVGEvent::MOUSEOVER_EVENT, true, cancel, 0, mev->screenX(), mev->screenY(), mev->clientX(), mev->clientY(), mev->ctrlKey(), mev->altKey(), mev->shiftKey(), mev->metaKey(), mev->button(), elem);
|
|
|
|
dorerender = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// Also send an domactivate + focusin event on mouseup
|
|
|
|
bool dolinktest = true;
|
|
|
|
if(mev->id() == SVGEvent::MOUSEUP_EVENT)
|
|
|
|
{
|
|
|
|
mev->target()->setFocus(true);
|
|
|
|
|
|
|
|
if(events & 1 << SVGEvent::CLICK_EVENT)
|
|
|
|
{
|
|
|
|
dolinktest = mev->target()->dispatchEvent(SVGEvent::CLICK_EVENT, true, true);
|
|
|
|
dorerender = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(events & 1 << SVGEvent::DOMACTIVATE_EVENT)
|
|
|
|
{
|
|
|
|
mev->target()->dispatchEvent(SVGEvent::DOMACTIVATE_EVENT, true, true);
|
|
|
|
dorerender = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(events & 1 << SVGEvent::DOMFOCUSIN_EVENT)
|
|
|
|
{
|
|
|
|
mev->target()->dispatchEvent(SVGEvent::DOMFOCUSIN_EVENT, true, true);
|
|
|
|
dorerender = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Hyperlink support
|
|
|
|
SVGAElementImpl* link=0;
|
|
|
|
if(dolinktest && !mev->defaultPrevented())
|
|
|
|
{
|
|
|
|
link = SVGAElementImpl::getLink(elem);
|
|
|
|
if(link)
|
|
|
|
{
|
|
|
|
mev->setURL(link->href()->baseVal());
|
|
|
|
emit ownerDoc()->gotURL(link->target()->baseVal().string());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// The mouse is over a tqshape, so we have a target..we need to register that for a mouseout
|
|
|
|
ownerDoc()->setLastTarget(mev->target());
|
|
|
|
}
|
|
|
|
|
|
|
|
// mop: all events may trigger changed style, add elements etc. this is definately needed :(
|
|
|
|
if(dorerender)
|
|
|
|
ownerDoc()->rerender();
|
|
|
|
|
|
|
|
return dorerender; // mop: some kind of event has been found and executed
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ecma stuff
|
|
|
|
|
|
|
|
/*
|
|
|
|
@namespace KSVG
|
|
|
|
@begin SVGSVGElementImpl::s_hashTable 23
|
|
|
|
x SVGSVGElementImpl::X DontDelete|ReadOnly
|
|
|
|
y SVGSVGElementImpl::Y DontDelete|ReadOnly
|
|
|
|
width SVGSVGElementImpl::Width DontDelete|ReadOnly
|
|
|
|
height SVGSVGElementImpl::Height DontDelete|ReadOnly
|
|
|
|
viewport SVGSVGElementImpl::Viewport DontDelete|ReadOnly
|
|
|
|
contentScriptType SVGSVGElementImpl::ContentScriptType DontDelete
|
|
|
|
contentStyleType SVGSVGElementImpl::ContentStyleType DontDelete
|
|
|
|
pixelUnitToMillimeterX SVGSVGElementImpl::PixelUnitToMillimeterX DontDelete|ReadOnly
|
|
|
|
pixelUnitToMillimeterY SVGSVGElementImpl::PixelUnitToMillimeterY DontDelete|ReadOnly
|
|
|
|
screenPixelToMillimeterX SVGSVGElementImpl::ScreenPixelToMillimeterX DontDelete|ReadOnly
|
|
|
|
screenPixelToMillimeterY SVGSVGElementImpl::ScreenPixelToMillimeterY DontDelete|ReadOnly
|
|
|
|
useCurrentView SVGSVGElementImpl::UseCurrentView DontDelete
|
|
|
|
currentScale SVGSVGElementImpl::CurrentScale DontDelete
|
|
|
|
currentTranslate SVGSVGElementImpl::CurrentTranslate DontDelete|ReadOnly
|
|
|
|
onunload SVGSVGElementImpl::OnUnload DontDelete
|
|
|
|
onerror SVGSVGElementImpl::OnError DontDelete
|
|
|
|
onresize SVGSVGElementImpl::OnResize DontDelete
|
|
|
|
onzoom SVGSVGElementImpl::OnZoom DontDelete
|
|
|
|
onscroll SVGSVGElementImpl::OnScroll DontDelete
|
|
|
|
@end
|
|
|
|
@namespace KSVG
|
|
|
|
@begin SVGSVGElementImplProto::s_hashTable 29
|
|
|
|
createSVGNumber SVGSVGElementImpl::CreateSVGNumber DontDelete|Function 0
|
|
|
|
createSVGLength SVGSVGElementImpl::CreateSVGLength DontDelete|Function 0
|
|
|
|
createSVGAngle SVGSVGElementImpl::CreateSVGAngle DontDelete|Function 0
|
|
|
|
createSVGPoint SVGSVGElementImpl::CreateSVGPoint DontDelete|Function 0
|
|
|
|
createSVGMatrix SVGSVGElementImpl::CreateSVGMatrix DontDelete|Function 0
|
|
|
|
createSVGRect SVGSVGElementImpl::CreateSVGRect DontDelete|Function 0
|
|
|
|
createSVGTransform SVGSVGElementImpl::CreateSVGTransform DontDelete|Function 0
|
|
|
|
createSVGTransformFromMatrix SVGSVGElementImpl::CreateSVGTransformFromMatrix DontDelete|Function 1
|
|
|
|
suspendRedraw SVGSVGElementImpl::SuspendRedraw DontDelete|Function 1
|
|
|
|
unsuspendRedraw SVGSVGElementImpl::UnsuspendRedraw DontDelete|Function 1
|
|
|
|
unsuspendRedrawAll SVGSVGElementImpl::UnsuspendRedrawAll DontDelete|Function 0
|
|
|
|
forceRedraw SVGSVGElementImpl::ForceRedraw DontDelete|Function 0
|
|
|
|
pauseAnimations SVGSVGElementImpl::PauseAnimations DontDelete|Function 0
|
|
|
|
unpauseAnimations SVGSVGElementImpl::UnpauseAnimations DontDelete|Function 0
|
|
|
|
animationsPaused SVGSVGElementImpl::AnimationsPaused DontDelete|Function 0
|
|
|
|
getCurrentTime SVGSVGElementImpl::GetCurrentTime DontDelete|Function 0
|
|
|
|
setCurrentTime SVGSVGElementImpl::SetCurrentTime DontDelete|Function 1
|
|
|
|
getIntersectionList SVGSVGElementImpl::GetIntersectionList DontDelete|Function 2
|
|
|
|
getEnclosureList SVGSVGElementImpl::GetEnclosureList DontDelete|Function 2
|
|
|
|
checkIntersection SVGSVGElementImpl::CheckIntersection DontDelete|Function 2
|
|
|
|
checkEnclosure SVGSVGElementImpl::CheckEnclosure DontDelete|Function 2
|
|
|
|
deselectAll SVGSVGElementImpl::DeselectAll DontDelete|Function 0
|
|
|
|
getElementById SVGSVGElementImpl::GetElementById DontDelete|Function 1
|
|
|
|
@end
|
|
|
|
*/
|
|
|
|
|
|
|
|
KSVG_IMPLEMENT_PROTOTYPE("SVGSVGElement", SVGSVGElementImplProto, SVGSVGElementImplProtoFunc)
|
|
|
|
|
|
|
|
Value SVGSVGElementImpl::getValueProperty(ExecState *exec, int token) const
|
|
|
|
{
|
|
|
|
KSVG_CHECK_ATTRIBUTE
|
|
|
|
|
|
|
|
switch(token)
|
|
|
|
{
|
|
|
|
case X:
|
|
|
|
if(!attributeMode)
|
|
|
|
return m_x->cache(exec);
|
|
|
|
else
|
|
|
|
return Number(m_x->baseVal()->value());
|
|
|
|
case Y:
|
|
|
|
if(!attributeMode)
|
|
|
|
return m_y->cache(exec);
|
|
|
|
else
|
|
|
|
return Number(m_y->baseVal()->value());
|
|
|
|
case Width:
|
|
|
|
if(!attributeMode)
|
|
|
|
return m_width->cache(exec);
|
|
|
|
else
|
|
|
|
return Number(m_width->baseVal()->value());
|
|
|
|
case Height:
|
|
|
|
if(!attributeMode)
|
|
|
|
return m_height->cache(exec);
|
|
|
|
else
|
|
|
|
return Number(m_height->baseVal()->value());
|
|
|
|
case Viewport:
|
|
|
|
return m_viewport->cache(exec);
|
|
|
|
case ContentScriptType:
|
|
|
|
return String(contentScriptType().string());
|
|
|
|
case ContentStyleType:
|
|
|
|
return String(contentStyleType().string());
|
|
|
|
case PixelUnitToMillimeterX:
|
|
|
|
return Number(pixelUnitToMillimeterX());
|
|
|
|
case PixelUnitToMillimeterY:
|
|
|
|
return Number(pixelUnitToMillimeterY());
|
|
|
|
case ScreenPixelToMillimeterX:
|
|
|
|
return Number(screenPixelToMillimeterX());
|
|
|
|
case ScreenPixelToMillimeterY:
|
|
|
|
return Number(screenPixelToMillimeterY());
|
|
|
|
case UseCurrentView:
|
|
|
|
return Boolean(useCurrentView());
|
|
|
|
case CurrentScale:
|
|
|
|
return Number(currentScale());
|
|
|
|
case CurrentTranslate:
|
|
|
|
return m_currentTranslate->cache(exec);
|
|
|
|
default:
|
|
|
|
kdWarning() << "Unhandled token in " << k_funcinfo << " : " << token << endl;
|
|
|
|
return Undefined();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SVGSVGElementImpl::putValueProperty(ExecState *exec, int token, const Value &value, int)
|
|
|
|
{
|
|
|
|
switch(token)
|
|
|
|
{
|
|
|
|
case ContentScriptType:
|
|
|
|
setContentScriptType(value.toString(exec).string());
|
|
|
|
break;
|
|
|
|
case ContentStyleType:
|
|
|
|
setContentStyleType(value.toString(exec).string());
|
|
|
|
break;
|
|
|
|
case CurrentScale:
|
|
|
|
m_currentScale = value.toNumber(exec);
|
|
|
|
break;
|
|
|
|
case X:
|
|
|
|
x()->baseVal()->setValueAsString(value.toString(exec).qstring());
|
|
|
|
break;
|
|
|
|
case Y:
|
|
|
|
y()->baseVal()->setValueAsString(value.toString(exec).qstring());
|
|
|
|
break;
|
|
|
|
case Width:
|
|
|
|
width()->baseVal()->setValueAsString(value.toString(exec).qstring());
|
|
|
|
break;
|
|
|
|
case Height:
|
|
|
|
height()->baseVal()->setValueAsString(value.toString(exec).qstring());
|
|
|
|
break;
|
|
|
|
case OnUnload:
|
|
|
|
// Spec: only applicable to outermost 'svg' elements
|
|
|
|
if(isRootElement())
|
|
|
|
setEventListener(SVGEvent::UNLOAD_EVENT, ownerDoc()->createEventListener(value.toString(exec).qstring()));
|
|
|
|
break;
|
|
|
|
case OnError:
|
|
|
|
setEventListener(SVGEvent::ERROR_EVENT, ownerDoc()->createEventListener(value.toString(exec).qstring()));
|
|
|
|
break;
|
|
|
|
case OnResize:
|
|
|
|
// Spec: only applicable to outermost 'svg' elements
|
|
|
|
if(isRootElement())
|
|
|
|
setEventListener(SVGEvent::RESIZE_EVENT, ownerDoc()->createEventListener(value.toString(exec).qstring()));
|
|
|
|
break;
|
|
|
|
case OnZoom:
|
|
|
|
// Spec: only applicable to outermost 'svg' elements
|
|
|
|
if(isRootElement())
|
|
|
|
setEventListener(SVGEvent::ZOOM_EVENT, ownerDoc()->createEventListener(value.toString(exec).qstring()));
|
|
|
|
break;
|
|
|
|
case OnScroll:
|
|
|
|
// Spec: only applicable to outermost 'svg' elements
|
|
|
|
if(isRootElement())
|
|
|
|
setEventListener(SVGEvent::SCROLL_EVENT, ownerDoc()->createEventListener(value.toString(exec).qstring()));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
kdWarning() << k_funcinfo << "unhandled token " << token << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Value SVGSVGElementImplProtoFunc::call(ExecState *exec, Object &thisObj, const List &args)
|
|
|
|
{
|
|
|
|
KSVG_CHECK_THIS(SVGSVGElementImpl)
|
|
|
|
|
|
|
|
switch(id)
|
|
|
|
{
|
|
|
|
case SVGSVGElementImpl::CreateSVGNumber:
|
|
|
|
return obj->createSVGNumber()->cache(exec);
|
|
|
|
case SVGSVGElementImpl::CreateSVGLength:
|
|
|
|
return obj->createSVGLength()->cache(exec);
|
|
|
|
case SVGSVGElementImpl::CreateSVGAngle:
|
|
|
|
return obj->createSVGAngle()->cache(exec);
|
|
|
|
case SVGSVGElementImpl::CreateSVGPoint:
|
|
|
|
return obj->createSVGPoint()->cache(exec);
|
|
|
|
case SVGSVGElementImpl::CreateSVGMatrix:
|
|
|
|
return obj->createSVGMatrix()->cache(exec);
|
|
|
|
case SVGSVGElementImpl::CreateSVGRect:
|
|
|
|
return obj->createSVGRect()->cache(exec);
|
|
|
|
case SVGSVGElementImpl::CreateSVGTransform:
|
|
|
|
return obj->createSVGTransform()->cache(exec);
|
|
|
|
case SVGSVGElementImpl::CreateSVGTransformFromMatrix:
|
|
|
|
return obj->createSVGTransformFromMatrix(static_cast<KSVGBridge<SVGMatrixImpl> *>(args[0].imp())->impl())->cache(exec);
|
|
|
|
case SVGSVGElementImpl::GetElementById:
|
|
|
|
{
|
|
|
|
// Keep in sync with SVGDocumentImpl's version.
|
|
|
|
Value ret;
|
|
|
|
|
|
|
|
SVGElementImpl *element = obj->getElementById(args[0].toString(exec).string());
|
|
|
|
|
|
|
|
if(element)
|
|
|
|
ret = getDOMNode(exec, *element);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
element = obj->ownerDoc()->recursiveSearch(*(obj->ownerDoc()), args[0].toString(exec).string());
|
|
|
|
if(!element)
|
|
|
|
return Null();
|
|
|
|
|
|
|
|
ret = getDOMNode(exec, *element);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
case SVGSVGElementImpl::GetCurrentTime:
|
|
|
|
return Number(obj->getCurrentTime());
|
|
|
|
case SVGSVGElementImpl::SetCurrentTime:
|
|
|
|
obj->setCurrentTime(args[0].toNumber(exec));
|
|
|
|
return Undefined();
|
|
|
|
case SVGSVGElementImpl::DeselectAll:
|
|
|
|
obj->deSelectAll();
|
|
|
|
return Undefined();
|
|
|
|
case SVGSVGElementImpl::PauseAnimations:
|
|
|
|
obj->pauseAnimations();
|
|
|
|
return Undefined();
|
|
|
|
case SVGSVGElementImpl::UnpauseAnimations:
|
|
|
|
obj->unpauseAnimations();
|
|
|
|
return Undefined();
|
|
|
|
case SVGSVGElementImpl::AnimationsPaused:
|
|
|
|
return Boolean(obj->animationsPaused());
|
|
|
|
default:
|
|
|
|
kdWarning() << "Unhandled function id in " << k_funcinfo << " : " << id << endl;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Undefined();
|
|
|
|
}
|
|
|
|
|
|
|
|
// vim:ts=4:noet
|