dom2_events.cpp

手机浏览器源码程序,功能强大

	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

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

    return static_cast<MouseEventImpl*>(impl)->screenX();
}

long MouseEvent::screenY() 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<MouseEventImpl*>(impl)->screenY();
}

long MouseEvent::clientX() 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<MouseEventImpl*>(impl)->clientX();
}

long MouseEvent::clientY() 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<MouseEventImpl*>(impl)->clientY();
}

bool MouseEvent::ctrlKey() 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<MouseEventImpl*>(impl)->ctrlKey();
}

bool MouseEvent::shiftKey() 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<MouseEventImpl*>(impl)->shiftKey();
}

bool MouseEvent::altKey() 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<MouseEventImpl*>(impl)->altKey();
}

bool MouseEvent::metaKey() 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<MouseEventImpl*>(impl)->metaKey();
}

unsigned short MouseEvent::button() 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<MouseEventImpl*>(impl)->button();
}

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

    static_cast<MouseEventImpl*>(impl)->initMouseEvent(typeArg,canBubbleArg,
	cancelableArg,viewArg,detailArg,screenXArg,screenYArg,clientXArg,
	clientYArg,ctrlKeyArg,altKeyArg,shiftKeyArg,metaKeyArg,buttonArg,
	relatedTargetArg);
}



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

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

    return static_cast<MutationEventImpl*>(impl)->relatedNode();
}

DOMString MutationEvent::prevValue() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return DOMString(); }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<MutationEventImpl*>(impl)->prevValue();
}

DOMString MutationEvent::newValue() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return DOMString(); }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<MutationEventImpl*>(impl)->newValue();
}

DOMString MutationEvent::attrName() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return DOMString(); }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<MutationEventImpl*>(impl)->attrName();
}

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

    static_cast<MutationEventImpl*>(impl)->initMutationEvent(typeArg,
	canBubbleArg,cancelableArg,relatedNodeArg,prevValueArg,
	newValueArg,attrNameArg,attrChangeArg);
}


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

KeyboardEvent::KeyboardEvent()
{
}

KeyboardEvent::KeyboardEvent(const KeyboardEvent &other) : UIEvent(other)
{
}

KeyboardEvent::KeyboardEvent(const Event &other)
{
    *this = other;
}

KeyboardEvent::KeyboardEvent(KeyboardEventImpl *impl) : UIEvent(impl)
{
}

KeyboardEvent &KeyboardEvent::operator = (const KeyboardEvent &other)
{
    UIEvent::operator = (other);
    return *this;
}

KeyboardEvent &KeyboardEvent::operator = (const Event &other)
{
    Event e;
    e = other;
    if (!e.isNull() && !e.handle()->isKeyboardEvent()) {
	if ( impl ) impl->deref();
	impl = 0;
    } else
	UIEvent::operator = (other);
    return *this;
}

KeyboardEvent::~KeyboardEvent()
{
}

DOMString KeyboardEvent::keyIdentifier() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return DOMString(); }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<KeyboardEventImpl*>(impl)->keyIdentifier();
}

unsigned long KeyboardEvent::keyLocation() 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<KeyboardEventImpl*>(impl)->keyLocation();
}

bool KeyboardEvent::ctrlKey() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
	{ _exceptioncode = DOMException::INVALID_STATE_ERR; return false; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<KeyboardEventImpl*>(impl)->ctrlKey();
}

bool KeyboardEvent::shiftKey() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return false; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<KeyboardEventImpl*>(impl)->shiftKey();
}

bool KeyboardEvent::altKey() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return false; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<KeyboardEventImpl*>(impl)->altKey();
}

bool KeyboardEvent::metaKey() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return false; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<KeyboardEventImpl*>(impl)->metaKey();
}

bool KeyboardEvent::altGraphKey() const
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return false; }
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    return static_cast<KeyboardEventImpl*>(impl)->altGraphKey();
}

void KeyboardEvent::initKeyboardEvent(const DOMString &typeArg, 
                                        bool canBubbleArg,
                                        bool cancelableArg,
                                        const AbstractView &viewArg, 
                                        const DOMString &keyIdentifierArg, 
                                        unsigned long keyLocationArg, 
                                        bool ctrlKeyArg, 
                                        bool shiftKeyArg, 
                                        bool altKeyArg, 
                                        bool metaKeyArg, 
                                        bool altGraphKeyArg)
{
    if (!impl)
#if KHTML_NO_EXCEPTIONS    
    { _exceptioncode = DOMException::INVALID_STATE_ERR; return;}
#else
	throw DOMException(DOMException::INVALID_STATE_ERR);
#endif    

    static_cast<KeyboardEventImpl*>(impl)->initKeyboardEvent(typeArg,canBubbleArg,
	cancelableArg,viewArg,keyIdentifierArg,keyLocationArg,ctrlKeyArg,altKeyArg,
        shiftKeyArg,metaKeyArg,altGraphKeyArg);
}