summaryrefslogtreecommitdiffstats
path: root/tdehtml/dom/dom2_events.cpp
diff options
context:
space:
mode:
authorTimothy Pearson <kb9vqf@pearsoncomputing.net>2013-01-26 13:17:21 -0600
committerTimothy Pearson <kb9vqf@pearsoncomputing.net>2013-01-26 13:17:21 -0600
commitdfe289850f068f19ba4a83ab4e7e22a7e09c13c9 (patch)
treec297348a55df66c571de4525646e0b9762427353 /tdehtml/dom/dom2_events.cpp
parentb7658a0d5eca24a9d37c6e04f88298ef02389db0 (diff)
downloadtdelibs-dfe289850f068f19ba4a83ab4e7e22a7e09c13c9.tar.gz
tdelibs-dfe289850f068f19ba4a83ab4e7e22a7e09c13c9.zip
Rename a number of libraries and executables to avoid conflicts with KDE4
Diffstat (limited to 'tdehtml/dom/dom2_events.cpp')
-rw-r--r--tdehtml/dom/dom2_events.cpp725
1 files changed, 725 insertions, 0 deletions
diff --git a/tdehtml/dom/dom2_events.cpp b/tdehtml/dom/dom2_events.cpp
new file mode 100644
index 000000000..898a73bc3
--- /dev/null
+++ b/tdehtml/dom/dom2_events.cpp
@@ -0,0 +1,725 @@
+/**
+ * This file is part of the DOM implementation for KDE.
+ *
+ * (C) 2001 Peter Kelly (pmk@post.com)
+ *
+ * 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/dom2_views.h"
+#include "dom/dom_exception.h"
+#include "xml/dom2_eventsimpl.h"
+
+using namespace DOM;
+
+EventListener::EventListener()
+{
+}
+
+EventListener::~EventListener()
+{
+}
+
+void EventListener::handleEvent(Event &/*evt*/)
+{
+}
+
+DOMString EventListener::eventListenerType()
+{
+ return "";
+}
+
+// -----------------------------------------------------------------------------
+
+Event::Event()
+{
+ impl = 0;
+}
+
+
+Event::Event(const Event &other)
+{
+ impl = other.impl;
+ if (impl) impl->ref();
+}
+
+Event::Event(EventImpl *i)
+{
+ impl = i;
+ if (impl) impl->ref();
+}
+
+Event::~Event()
+{
+ if (impl) impl->deref();
+}
+
+Event &Event::operator = (const Event &other)
+{
+ if ( impl != other.impl ) {
+ if(impl) impl->deref();
+ impl = other.impl;
+ if(impl) impl->ref();
+ }
+ return *this;
+}
+
+DOMString Event::type() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return impl->type();
+}
+
+Node Event::target() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return impl->target();
+}
+
+Node Event::currentTarget() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return impl->currentTarget();
+}
+
+unsigned short Event::eventPhase() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return impl->eventPhase();
+}
+
+bool Event::bubbles() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return impl->bubbles();
+}
+
+bool Event::cancelable() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return impl->cancelable();
+}
+
+DOMTimeStamp Event::timeStamp() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return impl->timeStamp();
+}
+
+void Event::stopPropagation()
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ impl->stopPropagation(true);
+}
+
+void Event::preventDefault()
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ impl->preventDefault(true);
+}
+
+void Event::initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg)
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ impl->initEvent(eventTypeArg,canBubbleArg,cancelableArg);
+}
+
+EventImpl *Event::handle() const
+{
+ return impl;
+}
+
+bool Event::isNull() const
+{
+ return (impl == 0);
+}
+
+// -----------------------------------------------------------------------------
+
+#ifndef SAVE_SPACE
+
+EventException::EventException(unsigned short _code)
+{
+ code = _code;
+}
+
+EventException::EventException(const EventException &other)
+{
+ code = other.code;
+}
+
+EventException & EventException::operator = (const EventException &other)
+{
+ code = other.code;
+ return *this;
+}
+
+#endif
+
+// -----------------------------------------------------------------------------
+
+UIEvent::UIEvent() : Event()
+{
+}
+
+UIEvent::UIEvent(const UIEvent &other) : Event(other)
+{
+}
+
+UIEvent::UIEvent(const Event &other) : Event()
+{
+ (*this)=other;
+}
+
+UIEvent::UIEvent(UIEventImpl *impl) : Event(impl)
+{
+}
+
+UIEvent &UIEvent::operator = (const UIEvent &other)
+{
+ Event::operator = (other);
+ return *this;
+}
+
+UIEvent &UIEvent::operator = (const Event &other)
+{
+ Event e;
+ e = other;
+ if (!e.isNull() && !e.handle()->isUIEvent()) {
+ if ( impl ) impl->deref();
+ impl = 0;
+ } else
+ Event::operator = (other);
+ return *this;
+}
+
+UIEvent::~UIEvent()
+{
+}
+
+AbstractView UIEvent::view() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<UIEventImpl*>(impl)->view();
+}
+
+long UIEvent::detail() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<UIEventImpl*>(impl)->detail();
+}
+
+int UIEvent::keyCode() const
+{
+ if ( !impl ) throw DOMException( DOMException::INVALID_STATE_ERR );
+
+ if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
+ return static_cast<KeyEventBaseImpl*>( impl )->keyCode();
+
+ return 0;
+}
+
+int UIEvent::charCode() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
+ return static_cast<KeyEventBaseImpl*>( impl )->charCode();
+
+ return 0;
+}
+
+int UIEvent::pageX() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ if (impl->isMouseEvent() )
+ return static_cast<MouseEventImpl*>( impl )->pageX();
+ else
+ return 0;
+}
+
+int UIEvent::pageY() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ if ( impl->isMouseEvent() )
+ return static_cast<MouseEventImpl*>( impl )->pageY();
+ else
+ return 0;
+}
+
+int UIEvent::layerX() const
+{
+ if( !impl )
+ throw DOMException( DOMException::INVALID_STATE_ERR );
+
+ if( impl->isMouseEvent() )
+ return static_cast<MouseEventImpl*>( impl )->layerX();
+ return 0;
+}
+
+int UIEvent::layerY() const
+{
+ if( !impl )
+ throw DOMException( DOMException::INVALID_STATE_ERR );
+
+ if( impl->isMouseEvent() )
+ return static_cast<MouseEventImpl*>( impl )->layerY();
+ return 0;
+}
+
+int UIEvent::which() const
+{
+ if( !impl ) throw DOMException( DOMException::INVALID_STATE_ERR );
+
+ if( impl->isMouseEvent() )
+ return static_cast<MouseEventImpl*>( impl )->button() + 1;
+ else if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
+ {
+ // return 0 unless the key has an ascii value
+ if ( static_cast<KeyEventBaseImpl*>( impl )->keyVal() )
+ return static_cast<KeyEventBaseImpl*>( impl )->keyCode();
+ }
+
+ return 0;
+}
+
+void UIEvent::initUIEvent(const DOMString &typeArg,
+ bool canBubbleArg,
+ bool cancelableArg,
+ const AbstractView &viewArg,
+ long detailArg)
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ static_cast<UIEventImpl*>(impl)->initUIEvent(typeArg,canBubbleArg,cancelableArg,
+ viewArg,detailArg);
+}
+
+// -----------------------------------------------------------------------------
+
+MouseEvent::MouseEvent() : UIEvent()
+{
+}
+
+MouseEvent::MouseEvent(const MouseEvent &other) : UIEvent(other)
+{
+}
+
+MouseEvent::MouseEvent(const Event &other) : UIEvent()
+{
+ (*this)=other;
+}
+
+MouseEvent::MouseEvent(MouseEventImpl *impl) : UIEvent(impl)
+{
+}
+
+MouseEvent &MouseEvent::operator = (const MouseEvent &other)
+{
+ UIEvent::operator = (other);
+ return *this;
+}
+
+MouseEvent &MouseEvent::operator = (const Event &other)
+{
+ Event e;
+ e = other;
+ if (!e.isNull() && !e.handle()->isMouseEvent()) {
+ if ( impl ) impl->deref();
+ impl = 0;
+ } else
+ UIEvent::operator = (other);
+ return *this;
+}
+
+MouseEvent::~MouseEvent()
+{
+}
+
+long MouseEvent::screenX() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->screenX();
+}
+
+long MouseEvent::screenY() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->screenY();
+}
+
+long MouseEvent::clientX() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->clientX();
+}
+
+long MouseEvent::clientY() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->clientY();
+}
+
+bool MouseEvent::ctrlKey() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->ctrlKey();
+}
+
+bool MouseEvent::shiftKey() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->shiftKey();
+}
+
+bool MouseEvent::altKey() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->altKey();
+}
+
+bool MouseEvent::metaKey() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->metaKey();
+}
+
+unsigned short MouseEvent::button() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->button();
+}
+
+Node MouseEvent::relatedTarget() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MouseEventImpl*>(impl)->relatedTarget();
+}
+
+void MouseEvent::initMouseEvent(const DOMString &typeArg,
+ bool canBubbleArg,
+ bool cancelableArg,
+ const AbstractView &viewArg,
+ long detailArg,
+ long screenXArg,
+ long screenYArg,
+ long clientXArg,
+ long clientYArg,
+ bool ctrlKeyArg,
+ bool altKeyArg,
+ bool shiftKeyArg,
+ bool metaKeyArg,
+ unsigned short buttonArg,
+ const Node &relatedTargetArg)
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ static_cast<MouseEventImpl*>(impl)->initMouseEvent(typeArg,canBubbleArg,
+ cancelableArg,viewArg,detailArg,screenXArg,screenYArg,clientXArg,
+ clientYArg,ctrlKeyArg,altKeyArg,shiftKeyArg,metaKeyArg,buttonArg,
+ relatedTargetArg);
+}
+
+// -----------------------------------------------------------------------------
+
+TextEvent::TextEvent() : UIEvent()
+{
+}
+
+TextEvent::TextEvent(const TextEvent &other) : UIEvent(other)
+{
+}
+
+TextEvent::TextEvent(const Event &other) : UIEvent()
+{
+ (*this)=other;
+}
+
+TextEvent::TextEvent(KeyEventBaseImpl *impl) : UIEvent(impl)
+{
+}
+
+TextEvent &TextEvent::operator = (const TextEvent &other)
+{
+ UIEvent::operator = (other);
+ return *this;
+}
+
+TextEvent &TextEvent::operator = (const Event &other)
+{
+ Event e;
+ e = other;
+ if (!e.isNull() && !(e.handle()->isTextInputEvent() || e.handle()->isKeyboardEvent())) {
+ if ( impl ) impl->deref();
+ impl = 0;
+ } else
+ UIEvent::operator = (other);
+ return *this;
+}
+
+TextEvent::~TextEvent()
+{
+}
+
+void TextEvent::initTextEvent(const DOMString &typeArg,
+ bool canBubbleArg,
+ bool cancelableArg,
+ const AbstractView &viewArg,
+ long /*detailArg*/,
+ const DOMString &outputStringArg,
+ unsigned long keyValArg,
+ unsigned long virtKeyValArg,
+ bool /*inputGeneratedArg*/,
+ bool numPadArg)
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ if (impl->isTextInputEvent()) {
+ //Initialize based on the outputStringArg or virtKeyValArg.
+ TQString text = outputStringArg.string();
+ if (outputStringArg.length() == 0 && virtKeyValArg) {
+ text += TQChar((unsigned short)virtKeyValArg);
+ }
+
+ TextEventImpl* tImpl = static_cast<TextEventImpl*>(impl);
+ tImpl->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, text);
+ } else {
+ KeyboardEventImpl* kbImpl = static_cast<KeyboardEventImpl*>(impl);
+ kbImpl->initKeyboardEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
+ keyValArg, virtKeyValArg, 0, numPadArg ?
+ KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD : KeyboardEventImpl::DOM_KEY_LOCATION_STANDARD);
+ }
+}
+
+unsigned long TextEvent::keyVal() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<KeyEventBaseImpl*>(impl)->keyVal();
+}
+
+DOMString TextEvent::outputString() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ KeyEventBaseImpl* ke = static_cast<KeyEventBaseImpl*>(impl);
+ if (ke->isTextInputEvent())
+ return static_cast<TextEventImpl*>(ke)->data();
+ else {
+ if (ke->keyVal())
+ return TQString(TQChar((ushort)ke->keyVal()));
+ else
+ return DOMString();
+ }
+}
+
+unsigned long TextEvent::virtKeyVal() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<KeyEventBaseImpl*>(impl)->virtKeyVal();
+}
+
+void TextEvent::initModifier(unsigned long modifierArg, bool valueArg)
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<KeyEventBaseImpl*>(impl)->initModifier(modifierArg,valueArg);
+}
+
+bool TextEvent::checkModifier(unsigned long modifierArg)
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<KeyEventBaseImpl*>(impl)->checkModifier(modifierArg);
+}
+
+bool TextEvent::inputGenerated() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<KeyEventBaseImpl*>(impl)->inputGenerated();
+}
+
+bool TextEvent::numPad() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ KeyEventBaseImpl* ke = static_cast<KeyEventBaseImpl*>(impl);
+ if (ke->isKeyboardEvent())
+ return static_cast<KeyboardEventImpl*>(ke)->keyLocation() ==
+ KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD;
+ else return false;
+}
+// -----------------------------------------------------------------------------
+
+MutationEvent::MutationEvent() : Event()
+{
+}
+
+MutationEvent::MutationEvent(const MutationEvent &other) : Event(other)
+{
+}
+
+MutationEvent::MutationEvent(const Event &other) : Event()
+{
+ (*this)=other;
+}
+
+MutationEvent::MutationEvent(MutationEventImpl *impl) : Event(impl)
+{
+}
+
+MutationEvent &MutationEvent::operator = (const MutationEvent &other)
+{
+ Event::operator = (other);
+ return *this;
+}
+
+MutationEvent &MutationEvent::operator = (const Event &other)
+{
+ Event e;
+ e = other;
+ if (!e.isNull() && !e.handle()->isMutationEvent()) {
+ if ( impl ) impl->deref();
+ impl = 0;
+ } else
+ Event::operator = (other);
+ return *this;
+}
+
+MutationEvent::~MutationEvent()
+{
+}
+
+Node MutationEvent::relatedNode() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MutationEventImpl*>(impl)->relatedNode();
+}
+
+DOMString MutationEvent::prevValue() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MutationEventImpl*>(impl)->prevValue();
+}
+
+DOMString MutationEvent::newValue() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MutationEventImpl*>(impl)->newValue();
+}
+
+DOMString MutationEvent::attrName() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MutationEventImpl*>(impl)->attrName();
+}
+
+unsigned short MutationEvent::attrChange() const
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ return static_cast<MutationEventImpl*>(impl)->attrChange();
+}
+
+void MutationEvent::initMutationEvent(const DOMString &typeArg,
+ bool canBubbleArg,
+ bool cancelableArg,
+ const Node &relatedNodeArg,
+ const DOMString &prevValueArg,
+ const DOMString &newValueArg,
+ const DOMString &attrNameArg,
+ unsigned short attrChangeArg)
+{
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+ static_cast<MutationEventImpl*>(impl)->initMutationEvent(typeArg,
+ canBubbleArg,cancelableArg,relatedNodeArg,prevValueArg,
+ newValueArg,attrNameArg,attrChangeArg);
+}
+
+