Rename a number of libraries and executables to avoid conflicts with KDE4

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);
+}
+
+