dom2_events.cpp

khtml在gtk上的移植版本

/**
 * This file is part of the DOM implementation for KDE.
 *
 * (C) 2001 Peter Kelly ([e-mail])
 * Copyright (C) 2003 Apple Computer, Inc.
 *
 * 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., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, 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*/, bool)
{
}

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)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return DOMString(); }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return impl->type();
}

Node Event::target() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return impl->target();
}

Node Event::currentTarget() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return impl->currentTarget();
}

unsigned short Event::eventPhase() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return impl->eventPhase();
}

bool Event::bubbles() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return impl->bubbles();
}

bool Event::cancelable() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return impl->cancelable();
}

DOMTimeStamp Event::timeStamp() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return impl->timeStamp();
}

void Event::stopPropagation()
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    impl->stopPropagation();
}

void Event::preventDefault()
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return;  }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    impl->preventDefault();
}

void Event::initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg)
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    impl->initEvent(eventTypeArg,canBubbleArg,cancelableArg);
}

EventImpl *Event::handle() const
{
    return impl;
}

bool Event::isNull() const
{
    return (impl == 0);
}

void Event::setCancelBubble(bool cancel)
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    impl->setCancelBubble(cancel);
}

void Event::setDefaultPrevented(bool defaultPrevented)
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    impl->setDefaultPrevented(defaultPrevented);
}
 
bool Event::getCancelBubble() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return false; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return impl->getCancelBubble();
}

bool Event::defaultPrevented() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return false; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    
    
    return impl->defaultPrevented();
}

// -----------------------------------------------------------------------------

#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)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<UIEventImpl*>(impl)->view();
}

long UIEvent::detail() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<UIEventImpl*>(impl)->detail();
}

int UIEvent::keyCode() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    
    
    if (impl->isKeyboardEvent())
        return static_cast<KeyboardEventImpl*>(impl)->keyCode();
    else
        return 0;
}

int UIEvent::charCode() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    
    
    if (impl->isKeyboardEvent())
        return static_cast<KeyboardEventImpl*>(impl)->charCode();
    else
        return 0;
}

int UIEvent::pageX() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    
    
    if (impl->isMouseEvent())
        return static_cast<MouseEventImpl*>(impl)->clientX();
    else
        return 0;
}

int UIEvent::pageY() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    
    
    if (impl->isMouseEvent())
        return static_cast<MouseEventImpl*>(impl)->clientY();
    else
        return 0;
}

int UIEvent::layerX() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    
    
    if (impl->isMouseEvent())
        return static_cast<MouseEventImpl*>(impl)->layerX();
    else
        return 0;
}

int UIEvent::layerY() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    
    
    if (impl->isMouseEvent())
        return static_cast<MouseEventImpl*>(impl)->layerY();
    else
        return 0;
}

int UIEvent::which() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return 0; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    // Note: This property supports both key events and mouse events

    // Netscape's "which" returns a virtual key code for keydown and keyup, and a character code for keypress.
    // That's exactly what IE's "keyCode" returns.
    if (impl->isKeyboardEvent())
        return static_cast<KeyboardEventImpl*>(impl)->keyCode();

    // For khtml, the return values for left, middle and right mouse buttons are 0, 1, 2, respectively.
    // For the Netscape "which" property, the return values for left, middle and right mouse buttons are 1, 2, 3, respectively. 
    // So we can just add 1 to the value returned by calling button().
    if (impl->isMouseEvent())
        return static_cast<MouseEventImpl*>(impl)->button() + 1;

    return 0;
}


void UIEvent::initUIEvent(const DOMString &typeArg,
                                 bool canBubbleArg,
                                 bool cancelableArg,
                                 const AbstractView &viewArg,
                                 long detailArg)
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif