dom2_events.h

/*
 * This file is part of the DOM implementation for KDE.
 *
 * Copyright (C) 2001 Peter Kelly (pmk@post.com)
 *           (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., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 */
 
#ifndef _DOM_Events_h_
#define _DOM_Events_h_
 
#include <dom/dom_node.h>
#include <dom/dom_misc.h>
 
namespace DOM {
 
class Event;
class EventException;
class UIEvent;
class MouseEvent;
class TextEvent;
class MutationEvent;
class AbstractView;
 
class EventListenerImpl;
class EventImpl;
class UIEventImpl;
class MouseEventImpl;
class KeyEventBaseImpl;
class MutationEventImpl;
 
 
 
class TDEHTML_EXPORT EventListener : public DomShared {
public:
    EventListener();
    virtual ~EventListener();
 
    virtual void handleEvent(Event &evt);
 
    virtual DOMString eventListenerType();
 
protected:
    EventListenerImpl *impl;
};
 
 
class TDEHTML_EXPORT Event {
    friend class Document;
    friend class NodeImpl;
    friend class DocumentImpl;
public:
    Event();
    Event(const Event &other);
    virtual ~Event();
 
    Event & operator = (const Event &other);
 
    enum PhaseType {
    CAPTURING_PHASE = 1,
    AT_TARGET = 2,
    BUBBLING_PHASE = 3
    };
 
    DOMString type() const;
 
    Node target() const;
 
    Node currentTarget() const;
 
    unsigned short eventPhase() const;
 
    bool bubbles() const;
 
    bool cancelable() const;
 
    DOMTimeStamp timeStamp() const;
 
    void stopPropagation();
 
    void preventDefault();
 
    void initEvent(const DOMString &eventTypeArg, bool canBubbleArg, bool cancelableArg);
 
    EventImpl *handle() const;
    bool isNull() const;
 
protected:
    Event(EventImpl *i);
    EventImpl *impl;
};
 
 
class TDEHTML_EXPORT EventException
{
public:
    EventException(unsigned short _code);
    EventException(const EventException &other);
    EventException & operator = (const EventException &other);
    virtual ~EventException() {}
 
    enum EventExceptionCode {
        UNSPECIFIED_EVENT_TYPE_ERR     = 0
    };
 
    unsigned short code;
};
 
 
class TDEHTML_EXPORT UIEvent : public Event {
public:
    UIEvent();
    UIEvent(const UIEvent &other);
    UIEvent(const Event &other);
    UIEvent & operator = (const UIEvent &other);
    UIEvent & operator = (const Event &other);
    virtual ~UIEvent();
 
    AbstractView view() const;
 
    long detail() const;
 
    int keyCode() const;
 
    int charCode() const;
 
    int pageX() const;
    int pageY() const;
 
    int layerX() const;
    int layerY() const;
 
    int which() const;
 
    void initUIEvent(const DOMString &typeArg,
                                 bool canBubbleArg,
                                 bool cancelableArg,
                                 const AbstractView &viewArg,
                                 long detailArg);
protected:
    UIEvent(UIEventImpl *impl);
};
 
 
 
 
class TDEHTML_EXPORT MouseEvent : public UIEvent {
public:
    MouseEvent();
    MouseEvent(const MouseEvent &other);
    MouseEvent(const Event &other);
    MouseEvent & operator = (const MouseEvent &other);
    MouseEvent & operator = (const Event &other);
    virtual ~MouseEvent();
 
    long screenX() const;
 
    long screenY() const;
 
    long clientX() const;
 
    long clientY() const;
 
    bool ctrlKey() const;
 
    bool shiftKey() const;
 
    bool altKey() const;
 
    bool metaKey() const;
 
    unsigned short button() const;
 
    Node relatedTarget() const;
 
    void 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);
protected:
    MouseEvent(MouseEventImpl *impl);
};
 
// Introduced in DOM Level 3:
class TDEHTML_EXPORT TextEvent : public UIEvent {
public:
    TextEvent();
    TextEvent(const TextEvent &other);
    TextEvent(const Event &other);
    TextEvent & operator = (const TextEvent &other);
    TextEvent & operator = (const Event &other);
    virtual ~TextEvent();
 
    void 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);
 
    void initModifier(unsigned long modifierArg, bool valueArg);
 
    bool inputGenerated() const;
 
    unsigned long keyVal() const;
 
    bool numPad() const;
 
    DOMString     outputString() const;
    unsigned long virtKeyVal() const;
 
    bool checkModifier(unsigned long modifierArg); // ### KDE 4: const!
 
protected:
    TextEvent(KeyEventBaseImpl *impl);
};
 
 
class TDEHTML_EXPORT MutationEvent : public Event {
public:
    MutationEvent();
    MutationEvent(const MutationEvent &other);
    MutationEvent(const Event &other);
    MutationEvent & operator = (const MutationEvent &other);
    MutationEvent & operator = (const Event &other);
    virtual ~MutationEvent();
 
    enum attrChangeType {
    MODIFICATION = 1,
    ADDITION = 2,
    REMOVAL = 3
    };
 
 
    Node relatedNode() const;
 
    DOMString prevValue() const;
 
    DOMString newValue() const;
 
    DOMString attrName() const;
 
    unsigned short attrChange() const;
 
    void initMutationEvent(const DOMString &typeArg,
                                       bool canBubbleArg,
                                       bool cancelableArg,
                                       const Node &relatedNodeArg,
                                       const DOMString &prevValueArg,
                                       const DOMString &newValueArg,
                                       const DOMString &attrNameArg,
                                       unsigned short attrChangeArg);
protected:
    MutationEvent(MutationEventImpl *impl);
};
 
 
 
} //namespace
#endif