You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdegraphics/ksvg/impl/SVGElementImpl.cc

714 lines
19 KiB

/*
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 <tqxml.h>
#include <kdebug.h>
#include "SVGEvent.h"
#include "SVGEventImpl.h"
#include "SVGHelperImpl.h"
#include "SVGElementImpl.h"
#include "SVGDocumentImpl.h"
#include "SVGSVGElementImpl.h"
using namespace KSVG;
#include "SVGElementImpl.lut.h"
#include "ksvg_scriptinterpreter.h"
#include "ksvg_ecma.h"
SVGElementImpl::Factory *SVGElementImpl::Factory::m_instance = 0;
SVGElementImpl::SVGElementImpl(DOM::ElementImpl *impl) : DOM::DomShared(), DOM::Element(impl), SVGDOMElementBridge(static_cast<DOM::Element>(*this))
{
KSVG_EMPTY_FLAGS
m_ownerSVGElement = 0;
m_viewportElement = 0;
m_ownerDoc = 0;
m_mouseOver = false;
m_focus = false;
m_eventListeners.setAutoDelete(true);
m_attributes.setAutoDelete(true);
}
SVGElementImpl::~SVGElementImpl()
{
if(m_ownerSVGElement)
m_ownerSVGElement->deref();
}
void SVGElementImpl::setEventListener(int id, SVGEventListener *listener)
{
if(listener)
listener->ref();
removeEventListener(id);
if(listener)
{
SVGRegisteredEventListener *rl = new SVGRegisteredEventListener(static_cast<SVGEvent::EventId>(id), listener, false);
m_eventListeners.append(rl);
listener->deref();
}
}
int SVGElementImpl::getEventListeners(bool local)
{
int events = 0;
TQPtrListIterator<SVGRegisteredEventListener> it(m_eventListeners);
for(; it.current(); ++it)
events |= (1 << it.current()->id);
if(local)
return events;
for(DOM::Node node = parentNode(); !node.isNull(); node = node.parentNode())
{
SVGElementImpl *element = ownerDoc()->getElementFromHandle(node.handle());
if(element)
{
TQPtrListIterator<SVGRegisteredEventListener> it(element->m_eventListeners);
for(; it.current(); ++it)
events |= (1 << it.current()->id);
}
}
return events;
}
void SVGElementImpl::setupEventListeners(SVGDocumentImpl *doc, SVGDocumentImpl *newDoc)
{
if(!doc || !newDoc)
return;
// Changes the document where the eventlisteners are registered
// Needed for parseXML'ed elements with events, their listeners
// are created in the temporary document fragment and need to be
// registered in the main document (Niko)
TQPtrListIterator<SVGRegisteredEventListener> it(m_eventListeners);
for(; it.current(); ++it)
{
SVGRegisteredEventListener *current = it.current();
TQString valueOfCurrent = newDoc->ecmaEngine()->valueOfEventListener(current->listener);
setEventListener(current->id, doc->createEventListener(valueOfCurrent));
}
}
bool SVGElementImpl::hasEventListener(int id, bool local)
{
// First check if we have the listener, locally
TQPtrListIterator<SVGRegisteredEventListener> it(m_eventListeners);
for(; it.current(); ++it)
{
if(it.current()->id == id)
return true;
}
// We have no local listeners, if we are just interessted
// in those listeners, then return now...
if(local)
return false;
// Check every tqparent element
for(DOM::Node node = parentNode(); !node.isNull(); node = node.parentNode())
{
SVGElementImpl *element = ownerDoc()->getElementFromHandle(node.handle());
if(element)
{
TQPtrListIterator<SVGRegisteredEventListener> it(element->m_eventListeners);
for(; it.current(); ++it)
{
if(it.current()->id == id)
return true;
}
}
}
return false;
}
void SVGElementImpl::removeEventListener(int id)
{
TQPtrListIterator<SVGRegisteredEventListener> it(m_eventListeners);
for(; it.current(); ++it)
{
if(it.current()->id == id)
{
m_eventListeners.removeRef(it.current());
break;
}
}
}
void SVGElementImpl::handleLocalEvents(SVGEventImpl *evt, bool useCapture)
{
TQPtrListIterator<SVGRegisteredEventListener> it(m_eventListeners);
for(; it.current(); ++it)
{
if(it.current()->id == evt->id() && it.current()->useCapture == useCapture)
{
it.current()->listener->handleEvent(evt);
break;
}
}
}
void SVGElementImpl::defaultEventHandler(SVGEventImpl *)
{
}
/*
@namespace KSVG
@begin SVGElementImpl::s_hashTable 23
id SVGElementImpl::ElementId DontDelete
ownerSVGElement SVGElementImpl::OwnerSvgElement DontDelete|ReadOnly
viewportElement SVGElementImpl::ViewportElement DontDelete|ReadOnly
xmlbase SVGElementImpl::XmlBase DontDelete
base SVGElementImpl::XmlBase DontDelete
onmouseup SVGElementImpl::OnMouseUp DontDelete
onmousedown SVGElementImpl::OnMouseDown DontDelete
onmousemove SVGElementImpl::OnMouseMove DontDelete
onmouseover SVGElementImpl::OnMouseOver DontDelete
onmouseout SVGElementImpl::OnMouseOut DontDelete
onclick SVGElementImpl::OnClick DontDelete
onmouseclick SVGElementImpl::OnClick DontDelete
onactivate SVGElementImpl::OnActivate DontDelete
onkeydown SVGElementImpl::OnKeyDown DontDelete
onkeyup SVGElementImpl::OnKeyUp DontDelete
onkeypress SVGElementImpl::OnKeyPress DontDelete
onload SVGElementImpl::OnLoad DontDelete
onfocusin SVGElementImpl::OnFocusIn DontDelete
onfocusout SVGElementImpl::OnFocusOut DontDelete
onerror SVGElementImpl::OnError DontDelete
onabort SVGElementImpl::OnAbort DontDelete
@end
@namespace KSVG
@begin SVGElementImplProto::s_hashTable 5
getStyle SVGElementImpl::GetStyle DontDelete|Function 0
setProperty SVGElementImpl::SetProperty DontDelete|Function 2
getPropertyValue SVGElementImpl::GetPropertyValue DontDelete|Function 1
@end
*/
KSVG_IMPLEMENT_PROTOTYPE("SVGElement", SVGElementImplProto, SVGElementImplProtoFunc)
Value SVGElementImpl::getValueProperty(ExecState *exec, int token) const
{
switch(token)
{
case ElementId:
return String(id().string());
case XmlBase:
return String(xmlbase().string());
case OwnerSvgElement:
return getDOMNode(exec, *ownerSVGElement());
case ViewportElement:
return getDOMNode(exec, *viewportElement());
default:
kdWarning() << "Unhandled token in " << k_funcinfo << " : " << token << endl;
return Undefined();
}
}
void SVGElementImpl::putValueProperty(ExecState *exec, int token, const Value &value, int)
{
switch(token)
{
case ElementId:
setId(value.toString(exec).string());
break;
case XmlBase:
setXmlbase(value.toString(exec).string());
break;
case OnMouseUp:
setEventListener(SVGEvent::MOUSEUP_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnMouseDown:
setEventListener(SVGEvent::MOUSEDOWN_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnMouseMove:
setEventListener(SVGEvent::MOUSEMOVE_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnMouseOver:
setEventListener(SVGEvent::MOUSEOVER_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnMouseOut:
setEventListener(SVGEvent::MOUSEOUT_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnClick:
setEventListener(SVGEvent::CLICK_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnActivate:
setEventListener(SVGEvent::DOMACTIVATE_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnKeyDown:
setEventListener(SVGEvent::KEYDOWN_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnKeyUp:
setEventListener(SVGEvent::KEYUP_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnKeyPress:
setEventListener(SVGEvent::KEYPRESS_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnLoad:
setEventListener(SVGEvent::LOAD_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnFocusIn:
setEventListener(SVGEvent::DOMFOCUSIN_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnFocusOut:
setEventListener(SVGEvent::DOMFOCUSOUT_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnError:
setEventListener(SVGEvent::ERROR_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
case OnAbort:
setEventListener(SVGEvent::ABORT_EVENT, m_ownerDoc->createEventListener(value.toString(exec).string()));
break;
default:
kdWarning() << k_funcinfo << "unhandled token " << token << endl;
}
}
Value SVGElementImplProtoFunc::call(ExecState *exec, Object &thisObj, const List &args)
{
KSVG_CHECK_THIS(SVGElementImpl)
switch(id)
{
case SVGElementImpl::GetStyle:
return obj->cache(exec);
case SVGElementImpl::SetProperty:
{
DOM::DOMString attribute = args[0].toString(exec).qstring().lower();
DOM::DOMString value = args[1].toString(exec).qstring();
obj->setAttribute(attribute, value);
break;
}
case SVGElementImpl::GetPropertyValue:
return String(obj->getAttribute(args[0].toString(exec).qstring()));
default:
break;
}
return Undefined();
}
TQDict<DOM::DOMString> &SVGElementImpl::attributes()
{
return m_attributes;
}
// khtml overrides
void SVGElementImpl::setAttribute(const DOM::DOMString &name, const DOM::DOMString &value)
{
m_attributes.tqreplace(name.string(), new DOM::DOMString(value));
}
// Changes internal value. This will have no effect on getAttribute().
void SVGElementImpl::setAttributeInternal(const DOM::DOMString &name, const DOM::DOMString &value)
{
ExecState *exec = ownerDoc()->ecmaEngine()->globalExec();
static_cast<KSVGScriptInterpreter *>(exec->interpreter())->setAttributeSetMode(true);
bridge(exec)->put(exec, Identifier(UString(name)), String(value), KJS::Internal);
static_cast<KSVGScriptInterpreter *>(exec->interpreter())->setAttributeSetMode(false);
}
// This gets the actual attribute as set in the svg source
DOM::DOMString SVGElementImpl::getAttribute(const DOM::DOMString &name) const
{
DOM::DOMString *result = m_attributes[name.string()];
if(result)
return *result;
else
return DOM::DOMString();
}
// This gets the internal, real-time value. This means it can return a default value
// for an attribute even if its not explicitly set in the svg source.
DOM::DOMString SVGElementImpl::getAttributeInternal(const DOM::DOMString &name)
{
ExecState *exec = ownerDoc()->ecmaEngine()->globalExec();
DOM::DOMString retVal;
static_cast<KSVGScriptInterpreter *>(exec->interpreter())->setAttributeGetMode(true);
retVal = bridge(exec)->get(exec, Identifier(UString(name))).toString(exec).string();
static_cast<KSVGScriptInterpreter *>(exec->interpreter())->setAttributeGetMode(false);
return retVal;
}
bool SVGElementImpl::hasAttribute(const DOM::DOMString &name)
{
return m_attributes.tqfind(name.string()) != 0;
}
bool SVGElementImpl::hasAttributes()
{
return m_attributes.count() > 0;
}
void SVGElementImpl::setApplyAttribute(const TQString &name, const TQString &value)
{
if(hasAttribute(name))
{
TQString cur = getAttribute(name).string();
cur = cur.simplifyWhiteSpace();
if(!cur.endsWith(";"))
cur += "; ";
cur += value;
setAttribute(name, cur);
}
else
setAttribute(name, value);
}
void SVGElementImpl::setId(DOM::DOMString id)
{
setAttribute("id", id);
if(ownerDoc() && ownerDoc()->rootElement() && !id.isEmpty())
ownerDoc()->rootElement()->addToIdMap(id.string(), this);
else if(m_ownerSVGElement && !id.isEmpty())
m_ownerSVGElement->addToIdMap(id.string(), this);
}
DOM::DOMString SVGElementImpl::id() const
{
return getAttribute("id");
}
void SVGElementImpl::setXmlbase(DOM::DOMString xmlbase)
{
setAttribute("xml:base", xmlbase);
}
DOM::DOMString SVGElementImpl::xmlbase() const
{
return getAttribute("xml:base");
}
void SVGElementImpl::setOwnerSVGElement(SVGSVGElementImpl *owner)
{
if(m_ownerSVGElement)
m_ownerSVGElement->deref();
m_ownerSVGElement = owner;
if(m_ownerSVGElement)
m_ownerSVGElement->ref();
}
void SVGElementImpl::setViewportElement(SVGElementImpl *viewport)
{
if(m_viewportElement)
m_viewportElement->deref();
m_viewportElement = viewport;
if(m_viewportElement)
m_viewportElement->ref();
}
SVGSVGElementImpl *SVGElementImpl::ownerSVGElement() const
{
return m_ownerSVGElement;
}
SVGElementImpl *SVGElementImpl::viewportElement() const
{
return m_viewportElement;
}
void SVGElementImpl::setAttributes(const TQXmlAttributes &attrs)
{
for(int i = 0; i < attrs.length(); i++)
{
setAttribute(attrs.localName(i), attrs.value(i));
setAttributeInternal(attrs.localName(i), attrs.value(i));
}
setAttributes();
}
void SVGElementImpl::setAttributes()
{
// Finalize style
SVGStylableImpl *style = dynamic_cast<SVGStylableImpl *>(this);
if(style)
style->processStyle();
}
void SVGElementImpl::setAttributes(bool deep)
{
// Finalize style
SVGStylableImpl *style = dynamic_cast<SVGStylableImpl *>(this);
if(style)
style->processStyle();
if(deep)
{
if(hasChildNodes())
{
DOM::Node n;
for(n = firstChild(); !n.isNull(); n = n.nextSibling())
{
SVGElementImpl *elem = ownerDoc()->getElementFromHandle(n.handle());
if(elem)
elem->setAttributes(true);
}
}
}
}
bool SVGElementImpl::prepareMouseEvent(const TQPoint &p, const TQPoint &a, SVGMouseEventImpl *mev)
{
SVGShapeImpl *tqshape = dynamic_cast<SVGShapeImpl *>(this);
if(tqshape)
return tqshape->prepareMouseEvent(p, a, mev);
return false;
}
bool SVGElementImpl::dispatchEvent(int id, bool canBubbleArg, bool cancelableArg)
{
SVGEventImpl *evt = new SVGEventImpl(static_cast<SVGEvent::EventId>(id), canBubbleArg, cancelableArg);
evt->ref();
bool ret = dispatchEvent(evt, true);
evt->deref();
return ret;
}
bool SVGElementImpl::dispatchEvent(SVGEventImpl *evt, bool tempEvent)
{
evt->setTarget(this);
// Find out, where to send to -> collect tqparent nodes
TQPtrList<SVGElementImpl> nodeChain;
for(DOM::Element e = *this; !e.isNull(); e = e.parentNode())
nodeChain.prepend(ownerDoc()->getElementFromHandle(e.handle()));
// Trigger any capturing event handlers on our way down
evt->setEventPhase(DOM::Event::CAPTURING_PHASE);
TQPtrListIterator<SVGElementImpl> it(nodeChain);
for(; it.current() && it.current() != this && !evt->propagationStopped(); ++it)
{
evt->setCurrentTarget(it.current());
if(it.current())
it.current()->handleLocalEvents(evt, true);
}
// Dispatch to the actual target node
it.toLast();
if(!evt->propagationStopped())
{
evt->setEventPhase(DOM::Event::AT_TARGET);
evt->setCurrentTarget(it.current());
if(it.current())
it.current()->handleLocalEvents(evt, false);
}
--it;
// Bubble up again
if(evt->bubbles())
{
evt->setEventPhase(DOM::Event::BUBBLING_PHASE);
for(; it.current() && !evt->propagationStopped(); --it)
{
evt->setCurrentTarget(it.current());
if(it.current())
it.current()->handleLocalEvents(evt, false);
}
}
evt->setCurrentTarget(0);
evt->setEventPhase(0); // I guess this is correct, the spec does not seem to say
// anything about the default event handler phase.
if(evt->bubbles())
{
// now we call all default event handlers (this is not part of DOM - it is internal to ksvg)
it.toLast();
for(; it.current() && !evt->propagationStopped() && !evt->defaultPrevented() && !evt->defaultHandled(); --it)
it.current()->defaultEventHandler(evt);
}
// If tempEvent is true, this means that the DOM implementation will not be storing a reference to the event, i.e.
// there is no way to retrieve it from javascript if a script does not already have a reference to it in a variable.
// So there is no need for the interpreter to keep the event in its cache
if(tempEvent)
ownerDoc()->ecmaEngine()->finishedWithEvent(evt);
return !evt->defaultPrevented(); // ### what if defaultPrevented was called before dispatchEvent?
}
bool SVGElementImpl::dispatchKeyEvent(TQKeyEvent *ke)
{
DOM::AbstractView temp;
SVGEvent::EventId evtId = SVGEvent::UNKNOWN_EVENT;
if(ke->type() == TQEvent::KeyRelease && !ke->isAutoRepeat())
evtId = SVGEvent::KEYUP_EVENT;
else if(ke->isAutoRepeat())
evtId = SVGEvent::KEYPRESS_EVENT;
else if(ke->type() == TQEvent::KeyPress)
evtId = SVGEvent::KEYDOWN_EVENT;
if(evtId == SVGEvent::KEYUP_EVENT && hasEventListener(SVGEvent::DOMACTIVATE_EVENT, false))
dispatchEvent(SVGEvent::DOMACTIVATE_EVENT, true, true);
if(!hasEventListener(evtId, false))
return false;
SVGEventImpl *evt = new SVGKeyEventImpl(ke, temp, evtId);
evt->ref();
bool ret = dispatchEvent(evt, true);
evt->deref();
// Rerender now! Once! (Niko)
ownerDoc()->rerender();
return ret;
}
bool SVGElementImpl::dispatchMouseEvent(int id, bool canBubbleArg, bool cancelableArg, long detailArg, long screenXArg, long screenYArg, long clientXArg, long clientYArg, bool ctrlKeyArg, bool altKeyArg, bool shiftKeyArg, bool metaKeyArg, unsigned short buttonArg, SVGElementImpl *relatedTargetArg)
{
DOM::AbstractView temp;
SVGEventImpl *evt = new SVGMouseEventImpl(static_cast<SVGEvent::EventId>(id),
canBubbleArg, cancelableArg, temp, detailArg,
screenXArg, screenYArg,
clientXArg, clientYArg,
ctrlKeyArg, altKeyArg, shiftKeyArg, metaKeyArg,
buttonArg, relatedTargetArg);
evt->ref();
bool ret = dispatchEvent(evt, true);
evt->deref();
return ret;
}
void SVGElementImpl::setOwnerDoc(SVGDocumentImpl *doc)
{
if(m_ownerDoc)
m_ownerDoc->removeFromElemDict(handle());
m_ownerDoc = doc;
if(m_ownerDoc)
m_ownerDoc->addToElemDict(handle(), this);
}
SVGDocumentImpl *SVGElementImpl::ownerDoc() const
{
return m_ownerDoc;
}
SVGElementImpl *SVGElementImpl::cloneNode(bool deep)
{
DOM::Element impl = static_cast<DOM::Document *>(ownerDoc())->createElementNS("", tagName());
SVGElementImpl *newElement = SVGDocumentImpl::createElement(tagName(), impl.cloneNode(false), ownerDoc());
newElement->setOwnerSVGElement(ownerSVGElement());
newElement->setViewportElement(viewportElement());
SVGHelperImpl::copyAttributes(this, newElement);
// Recalc style
//newElement->setAttributes();
if(deep)
cloneChildNodes(newElement);
return newElement;
}
void SVGElementImpl::cloneChildNodes(SVGElementImpl *clone)
{
DOM::Node n;
for(n = firstChild(); !n.isNull(); n = n.nextSibling())
{
SVGElementImpl *elem = ownerDoc()->getElementFromHandle(n.handle());
if(elem)
clone->appendChild(*elem->cloneNode(true));
else if(n.nodeType() == DOM::Node::TEXT_NODE)
clone->appendChild(n.cloneNode(true));
}
}
void SVGElementImpl::gotError(const TQString &errorDesc)
{
if(ownerDoc())
{
ownerDoc()->finishParsing(true, errorDesc);
if(hasEventListener(SVGEvent::ERROR_EVENT, true))
dispatchEvent(SVGEvent::ERROR_EVENT, false, false);
}
}
TQString SVGElementImpl::collectText()
{
TQString text;
if(hasChildNodes())
{
DOM::Node node = firstChild();
for(; !node.isNull(); node = node.nextSibling())
{
if(node.nodeType() == DOM::Node::TEXT_NODE)
{
DOM::Text textNode = node;
text += textNode.data().string();
}
}
}
return text;
}
// vim:ts=4:noet