dom2_events.h

Go to the documentation of this file.

/*
 * This file is part of the DOM implementation for KDE.
 *
 * Copyright 2001 Peter Kelly (pmk@post.com)
 * Copyright 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.
 *
 * This file includes excerpts from the Document Object Model (DOM)
 * Level 3 Events Specification (Working Group Note 07 November 2003)
 * http://www.w3.org/TR/DOM-Level-3-Events/
 * Copyright © 2003 World Wide Web Consortium , (Massachusetts Institute of
 * Technology, European Research Consortium for Informatics and Mathematics, 
 * Keio University ). All Rights Reserved.
 *
 */

#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 MutationEventImpl;



class KHTML_EXPORT EventListener : public DomShared {
public:
    EventListener();
    virtual ~EventListener();

    virtual void handleEvent(Event &evt);

    virtual DOMString eventListenerType();

protected:
    EventListenerImpl *impl;
};


class KHTML_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;

    Event(EventImpl *i);
protected:
    EventImpl *impl;
};


class KHTML_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,
        _EXCEPTION_OFFSET              = 3000,
        _EXCEPTION_MAX                 = 3999
    };

    unsigned short code;

    DOMString codeAsString() const;

    static DOMString codeAsString(int cssCode);

    static bool isEventExceptionCode(int exceptioncode);
    
};


class KHTML_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 KHTML_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);
};

class KHTML_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,
                      const DOMString &dataArg);

    DOMString data() const;
};


class KHTML_EXPORT KeyboardEvent : public UIEvent {
public:
    KeyboardEvent();
    KeyboardEvent(const KeyboardEvent &other);
    KeyboardEvent(const Event &other);
    KeyboardEvent & operator = (const KeyboardEvent &other);
    KeyboardEvent & operator = (const Event &other);
    virtual ~KeyboardEvent();

    enum KeyLocation {
        DOM_KEY_LOCATION_STANDARD      = 0x00,

        DOM_KEY_LOCATION_LEFT          = 0x01,

        DOM_KEY_LOCATION_RIGHT         = 0x02,

        DOM_KEY_LOCATION_NUMPAD        = 0x03
    };

    DOMString       keyIdentifier() const;

    unsigned long   keyLocation() const;

    bool ctrlKey() const;

    bool shiftKey() const;

    bool altKey() const;

    bool metaKey() const;

    bool getModifierState(DOMString keyIdentifierArg) const;


    void  initKeyboardEvent(DOMString typeArg,
                            bool canBubbleArg,
                            bool cancelableArg,
                            AbstractView viewArg,
                            DOMString keyIdentifierArg,
                            unsigned long keyLocationArg,
                            DOMString modifiersList);
};


class KHTML_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