dom2_events.h

konqueror3 embedded版本, KDE环境下的当家浏览器的嵌入式版本源码包.

    /**
     * The vertical coordinate at which the event occurred relative to the DOM
     * implementation's client area.
     *
     */
    long clientY() const;

    /**
     * Used to indicate whether the 'ctrl' key was depressed during the firing
     * of the event.
     */
    bool ctrlKey() const;

    /**
     * Used to indicate whether the 'shift' key was depressed during the firing
     * of the event.
     *
     */
    bool shiftKey() const;

    /**
     * Used to indicate whether the 'alt' key was depressed during the firing
     * of the event. On some platforms this key may map to an alternative key
     * name.
     *
     */
    bool altKey() const;

    /**
     * Used to indicate whether the 'meta' key was depressed during the firing
     * of the event. On some platforms this key may map to an alternative key
     * name.
     *
     */
    bool metaKey() const;

    /**
     * During mouse events caused by the depression or release of a mouse
     * button, button is used to indicate which mouse button changed state. The
     * values for button range from zero to indicate the left button of the
     * mouse, one to indicate the middle button if present, and two to indicate
     * the right button. For mice configured for left handed use in which the
     * button actions are reversed the values are instead read from right to
     * left.
     *
     */
    unsigned short button() const;

    /**
     * Used to identify a secondary EventTarget related to a UI event.
     * Currently this attribute is used with the mouseover event to indicate
     * the EventTarget which the pointing device exited and with the mouseout
     * event to indicate the EventTarget which the pointing device entered.
     *
     */
    Node relatedTarget() const;

    /**
     * The initMouseEvent method is used to initialize the value of a
     * MouseEvent created through the DocumentEvent interface. This method may
     * only be called before the MouseEvent has been dispatched via the
     * dispatchEvent method, though it may be called multiple times during that
     * phase if necessary. If called multiple times, the final invocation takes
     * precedence. Parameters
     *
     * @param typeArg Specifies the event type.
     *
     * @param canBubbleArg Specifies whether or not the event can bubble.
     *
     * @param cancelableArg Specifies whether or not the event's default action can be prevented.
     *
     * @param viewArg Specifies the Event's AbstractView.
     *
     * @param detailArg Specifies the Event's mouse click count.
     *
     * @param screenXArg Specifies the Event's screen x coordinate
     *
     * @param screenYArg Specifies the Event's screen y coordinate
     *
     * @param clientXArg Specifies the Event's client x coordinate
     *
     * @param clientYArg Specifies the Event's client y coordinate
     *
     * @param ctrlKeyArg Specifies whether or not control key was depressed during the Event.
     *
     * @param altKeyArg Specifies whether or not alt key was depressed during the Event.
     *
     * @param shiftKeyArg Specifies whether or not shift key was depressed during the Event.
     *
     * @param metaKeyArg Specifies whether or not meta key was depressed during the Event.
     *
     * @param buttonArg Specifies the Event's mouse button.
     *
     * @param relatedTargetArg Specifies the Event's related EventTarget.
     *
     */
    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:
/**
 * DOM::TextEvent
 * The detail attribute inherited from UIEvent is used to indicate
 * the number of keypresses which have occurred during key repetition.
 * If this information is not available this value should be 0.
 */
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();

    /**
     * initTextEvent
     *
     * The initTextEvent method is used to initialize the value of a
     * MouseEvent created through the DocumentEvent interface. This
     * method may only be called before the TextEvent has been dispatched
     * via the dispatchEvent method, though it may be called multiple
     * times during that phase if necessary. If called multiple times,
     * the final invocation takes precedence. This method has no effect
     * if called after the event has been dispatched.
     *
     * Parameters:
     *
     * typeArg of type DOMString
     *   Specifies the event type.
     * canBubbleArg of type boolean
     *   Specifies whether or not the event can bubble.
     * cancelableArg of type boolean
     *   Specifies whether or not the event's default action can be prevent.
     * viewArg of type views::AbstractView
     *   Specifies the TextEvent's AbstractView.
     * detailArg of type unsigned short
     *   Specifies the number of repeated keypresses, if available.
     * outputStringArg of type DOMString
     *   Specifies the TextEvent's outputString attribute
     * keyValArg of type unsigned long
     *   Specifies the TextEvent's keyValattribute
     * virtKeyValArg of type unsigned long
     *   Specifies the TextEvent's virtKeyValattribute
     * inputGeneratedArg of type boolean
     *   Specifies the TextEvent's inputGeneratedattribute
     * numPadArg of type boolean
     *   Specifies the TextEvent's numPadattribute
     *
     * No Return Value.
     * No Exceptions.
     */
    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);

    /**
     * initModifier
     *
     * The initModifier method is used to initialize the values of any
     * modifiers associated with a TextEvent created through the
     * DocumentEvent interface. This method may only be called before the
     * TextEvent has been dispatched via the dispatchEvent method, though
     * it may be called multiple times during that phase if necessary. If
     * called multiple times with the same modifier property the final
     * invocation takes precedence. Unless explicitly give a value of
     * true, all modifiers have a value of false. This method has no
     * effect if called after the event has been dispatched.  The list of
     * keys below represents the allowable modifier parameters for this
     * method:
     *    DOM_VK_LEFT_ALT
     *    DOM_VK_RIGHT_ALT
     *    DOM_VK_LEFT_CONTROL
     *    DOM_VK_RIGHT_CONTROL
     *    DOM_VK_LEFT_SHIFT
     *    DOM_VK_RIGHT_SHIFT
     *    DOM_VK_META
     *
     * Parameters:
     *
     * modifier of type unsigned long
     *   The modifier which the user wishes to initialize
     * value of type boolean
     *   The new value of the modifier.
     *
     * No Return Value
     * No Exceptions
     */
    void initModifier(unsigned long modifierArg, bool valueArg);

    /**
     * inputGenerated of type boolean
     *
     *  The inputGenerated attribute indicates whether the key event will
     *  normally cause visible output. If the key event does not
     *  generate any visible output, such as the use of a function key
     *  or the combination of certain modifier keys used in conjunction
     *  with another key, then the value will be false. If visible
     *  output is normally generated by the key event then the value
     *  will be true.  The value of inputGenerated does not guarantee
     *  the creation of a character. If a key event causing visible
     *  output is cancelable it may be prevented from causing
     *  output. This attribute is intended primarily to differentiate
     *  between keys events which may or may not produce visible output
     *  depending on the system state.
     */
    bool inputGenerated() const;

    /** keyVal of type unsigned long
     *
     *  The value of keyVal holds the value of the Unicode character
     *  associated with the depressed key. If the key has no Unicode
     *  representation or no Unicode character is available the value is
     *  0.
     */
    unsigned long keyVal() const;

    /** numPad of type boolean
     *
     *  The numPad attribute indicates whether or not the key event was
     *  generated on the number pad section of the keyboard. If the number
     *  pad was used to generate the key event the value is true,
     *  otherwise the value is false.
     */
    bool numPad() const;

    /**
     *outputString of type DOMString
     *
     *  outputString holds the value of the output generated by the key
     *  event. This may be a single Unicode character or it may be a
     *  string. It may also be null in the case where no output was
     *  generated by the key event.
     */

    DOMString     outputString() const;
    /** virtKeyVal of type unsigned long
     *
     *  When the key associated with a key event is not representable via
     *  a Unicode character virtKeyVale holds the virtual key code
     *  associated with the depressed key. If the key has a Unicode
     *  representation or no virtual code is available the value is
     *  DOM_VK_UNDEFINED.
     */
    unsigned long virtKeyVal() const;

    /**
     *  checkModifier
     *
     * Note: the below description does not match the actual behavior.
     *       it's extended in a way that you can query multiple modifiers
     *       at once by logically OR`ing them.
     *       also, we use the Qt modifier enum instead of the DOM one.
     *
     * The CheckModifier method is used to check the status of a single
     * modifier key associated with a TextEvent. The identifier of the
     * modifier in question is passed into the CheckModifier function. If
     * the modifier is triggered it will return true. If not, it will
     * return false.  The list of keys below represents the allowable
     * modifier parameters for this method:
     *     DOM_VK_LEFT_ALT
     *     DOM_VK_RIGHT_ALT
     *     DOM_VK_LEFT_CONTROL
     *     DOM_VK_RIGHT_CONTROL
     *     DOM_VK_LEFT_SHIFT
     *     DOM_VK_RIGHT_SHIFT
     *     DOM_VK_META
     *
     * Parameters:
     *
     * modifier of type unsigned long
     *   The modifier which the user wishes to query.
     *
     * Return Value: boolean
     *   The status of the modifier represented as a boolean.
     *
     * No Exceptions
     */
    bool checkModifier(unsigned long modifierArg); // ### KDE 4: const!

protected:
    TextEvent(TextEventImpl *impl);
};


/**
 * Introduced in DOM Level 2
 *
 * The MutationEvent interface provides specific contextual information
 * associated with Mutation events.
 *
 */
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();

    /**
     * An integer indicating in which way the Attr was changed.
     *
     * ADDITION: The Attr was just added.
     *
     * MODIFICATION: The Attr was modified in place.
     *
     * REMOVAL: The Attr was just removed.
     *
     */
    enum attrChangeType {
	MODIFICATION = 1,
	ADDITION = 2,
	REMOVAL = 3
    };


    /**
     * relatedNode is used to identify a secondary node related to a mutation
     * event. For example, if a mutation event is dispatched to a node
     * indicating that its parent has changed, the relatedNode is the changed
     * parent. If an event is instead dispatched to a subtree indicating a node
     * was changed within it, the relatedNode is the changed node. In the case
     * of the DOMAttrModified event it indicates the Attr node which was
     * modified, added, or removed.
     *
     */
    Node relatedNode() const;

    /**
     * prevValue indicates the previous value of the Attr node in
     * DOMAttrModified events, and of the CharacterData node in
     * DOMCharDataModified events.
     *
     */
    DOMString prevValue() const;

    /**
     * newValue indicates the new value of the Attr node in DOMAttrModified
     * events, and of the CharacterData node in DOMCharDataModified events.
     *
     */
    DOMString newValue() const;

    /**
     * attrName indicates the name of the changed Attr node in a
     * DOMAttrModified event.
     *
     */
    DOMString attrName() const;

    /**
     * attrChange indicates the type of change which triggered the
     * DOMAttrModified event. The values can be MODIFICATION, ADDITION, or
     * REMOVAL.
     *
     */
    unsigned short attrChange() const;

    /**
     * The initMutationEvent method is used to initialize the value of a
     * MutationEvent created through the DocumentEvent interface. This method
     * may only be called before the MutationEvent has been dispatched via the
     * dispatchEvent method, though it may be called multiple times during that
     * phase if necessary. If called multiple times, the final invocation takes
     * precedence.
     *
     * @param typeArg Specifies the event type.
     *
     * @param canBubbleArg Specifies whether or not the event can bubble.
     *
     * @param cancelableArg Specifies whether or not the event's default action can be prevented.
     *
     * @param relatedNodeArg Specifies the Event's related Node.
     *
     * @param prevValueArg Specifies the Event's prevValue attribute. This value may be null.
     *
     * @param newValueArg Specifies the Event's newValue attribute. This value may be null.
     *
     * @param attrNameArg Specifies the Event's attrName attribute. This value may be null.
     *
     * @param attrChangeArg Specifies the Event's attrChange attribute
     *
     */
    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