openfl
Version:
A fast, productive library for 2D cross-platform development.
1,170 lines • 75.2 kB
TypeScript
import DisplayObject from "./DisplayObject";
import Rectangle from "./../geom/Rectangle";
declare namespace openfl.display {
/**
* The InteractiveObject class is the abstract base class for all display
* objects with which the user can interact, using the mouse, keyboard, or
* other user input device.
*
* You cannot instantiate the InteractiveObject class directly. A call to
* the `new InteractiveObject()` constructor throws an
* `ArgumentError` exception.
*
* The InteractiveObject class itself does not include any APIs for
* rendering content onscreen. To create a custom subclass of the
* InteractiveObject class, extend one of the subclasses that do have APIs for
* rendering content onscreen, such as the Sprite, SimpleButton, TextField, or
* MovieClip classes.
*
* @:event clear Dispatched when the user selects 'Clear'(or
* 'Delete') from the text context menu. This
* event is dispatched to the object that
* currently has focus. If the object that
* currently has focus is a TextField, the
* default behavior of this event is to cause
* any currently selected text in the text field
* to be deleted.
* @:event click Dispatched when a user presses and releases
* the main button of the user's pointing device
* over the same InteractiveObject. For a click
* event to occur, it must always follow this
* series of events in the order of occurrence:
* mouseDown event, then mouseUp. The target
* object must be identical for both of these
* events; otherwise the `click`
* event does not occur. Any number of other
* mouse events can occur at any time between
* the `mouseDown` or
* `mouseUp` events; the
* `click` event still occurs.
* @:event contextMenu Dispatched when a user gesture triggers the
* context menu associated with this interactive
* object in an AIR application.
* @:event copy Dispatched when the user activates the
* platform-specific accelerator key combination
* for a copy operation or selects 'Copy' from
* the text context menu. This event is
* dispatched to the object that currently has
* focus. If the object that currently has focus
* is a TextField, the default behavior of this
* event is to cause any currently selected text
* in the text field to be copied to the
* clipboard.
* @:event cut Dispatched when the user activates the
* platform-specific accelerator key combination
* for a cut operation or selects 'Cut' from the
* text context menu. This event is dispatched
* to the object that currently has focus. If
* the object that currently has focus is a
* TextField, the default behavior of this event
* is to cause any currently selected text in
* the text field to be cut to the clipboard.
* @:event doubleClick Dispatched when a user presses and releases
* the main button of a pointing device twice in
* rapid succession over the same
* InteractiveObject when that object's
* `doubleClickEnabled` flag is set
* to `true`. For a
* `doubleClick` event to occur, it
* must immediately follow the following series
* of events: `mouseDown`,
* `mouseUp`, `click`,
* `mouseDown`, `mouseUp`.
* All of these events must share the same
* target as the `doubleClick` event.
* The second click, represented by the second
* `mouseDown` and
* `mouseUp` events, must occur
* within a specific period of time after the
* `click` event. The allowable
* length of this period varies by operating
* system and can often be configured by the
* user. If the target is a selectable text
* field, the word under the pointer is selected
* as the default behavior. If the target
* InteractiveObject does not have its
* `doubleClickEnabled` flag set to
* `true` it receives two
* `click` events.
*
* The `doubleClickEnabled`
* property defaults to `false`.
*
* The double-click text selection behavior
* of a TextField object is not related to the
* `doubleClick` event. Use
* `TextField.doubleClickEnabled` to
* control TextField selections.
* @:event focusIn Dispatched _after_ a display object
* gains focus. This situation happens when a
* user highlights the object with a pointing
* device or keyboard navigation. The recipient
* of such focus is called the target object of
* this event, while the corresponding
* InteractiveObject instance that lost focus
* because of this change is called the related
* object. A reference to the related object is
* stored in the receiving object's
* `relatedObject` property. The
* `shiftKey` property is not used.
* This event follows the dispatch of the
* previous object's `focusOut`
* event.
* @:event focusOut Dispatched _after_ a display object
* loses focus. This happens when a user
* highlights a different object with a pointing
* device or keyboard navigation. The object
* that loses focus is called the target object
* of this event, while the corresponding
* InteractiveObject instance that receives
* focus is called the related object. A
* reference to the related object is stored in
* the target object's
* `relatedObject` property. The
* `shiftKey` property is not used.
* This event precedes the dispatch of the
* `focusIn` event by the related
* object.
* @:event gesturePan Dispatched when the user moves a point of
* contact over the InteractiveObject instance
* on a touch-enabled device(such as moving a
* finger from left to right over a display
* object on a mobile phone or tablet with a
* touch screen). Some devices might also
* interpret this contact as a
* `mouseOver` event and as a
* `touchOver` event.
*
* Specifically, if a user moves a finger
* over an InteractiveObject, the
* InteractiveObject instance can dispatch a
* `mouseOver` event or a
* `touchOver` event or a
* `gesturePan` event, or all if the
* current environment supports it. Choose how
* you want to handle the user interaction. Use
* the openfl.ui.Multitouch class to manage touch
* event handling(enable touch gesture event
* handling, simple touch point event handling,
* or disable touch events so only mouse events
* are dispatched). If you choose to handle the
* `mouseOver` event, then the same
* event handler will run on a touch-enabled
* device and a mouse enabled device. However,
* if you choose to handle the
* `gesturePan` event, you can design
* your event handler to respond to the specific
* needs of a touch-enabled environment and
* provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event gesturePressAndTap Dispatched when the user creates a point of
* contact with an InteractiveObject instance,
* then taps on a touch-enabled device(such as
* placing several fingers over a display object
* to open a menu and then taps one finger to
* select a menu item on a mobile phone or
* tablet with a touch screen). Some devices
* might also interpret this contact as a
* combination of several mouse events, as well.
*
*
* Specifically, if a user moves a finger
* over an InteractiveObject, and then provides
* a secondary tap, the InteractiveObject
* instance can dispatch a
* `mouseOver` event and a
* `click` event(among others) as
* well as the `gesturePressAndTap`
* event, or all if the current environment
* supports it. Choose how you want to handle
* the user interaction. Use the
* openfl.ui.Multitouch class to manage touch
* event handling(enable touch gesture event
* handling, simple touch point event handling,
* or disable touch events so only mouse events
* are dispatched). If you choose to handle the
* `mouseOver` event, then the same
* event handler will run on a touch-enabled
* device and a mouse enabled device. However,
* if you choose to handle the
* `gesturePressAndTap` event, you
* can design your event handler to respond to
* the specific needs of a touch-enabled
* environment and provide users with a richer
* touch-enabled experience. You can also handle
* both events, separately, to provide a
* different response for a touch event than a
* mouse event.
*
* When handling the properties of the event
* object, note that the `localX` and
* `localY` properties are set to the
* primary point of contact(the "push"). The
* `offsetX` and `offsetY`
* properties are the distance to the secondary
* point of contact(the "tap").
* @:event gestureRotate Dispatched when the user performs a rotation
* gesture at a point of contact with an
* InteractiveObject instance(such as touching
* two fingers and rotating them over a display
* object on a mobile phone or tablet with a
* touch screen). Two-finger rotation is a
* common rotation gesture, but each device and
* operating system can have its own
* requirements to indicate rotation. Some
* devices might also interpret this contact as
* a combination of several mouse events, as
* well.
*
* Specifically, if a user moves a finger
* over an InteractiveObject, the
* InteractiveObject instance can dispatch a
* `mouseOver` event and a
* `click` event(among others), in
* addition to the `gestureRotate`
* event, or all if the current environment
* supports it. Choose how you want to handle
* the user interaction. Use the
* openfl.ui.Multitouch class to manage touch
* event handling(enable touch gesture event
* handling, simple touch point event handling,
* or disable touch events so only mouse events
* are dispatched). If you choose to handle the
* `mouseOver` event, then the same
* event handler will run on a touch-enabled
* device and a mouse enabled device. However,
* if you choose to handle the
* `gestureRotate` event, you can
* design your event handler to respond to the
* specific needs of a touch-enabled environment
* and provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* When handling the properties of the event
* object, note that the `localX` and
* `localY` properties are set to the
* primary point of contact. The
* `offsetX` and `offsetY`
* properties are the distance to the point of
* contact where the rotation gesture is
* complete.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event gestureSwipe Dispatched when the user performs a swipe
* gesture at a point of contact with an
* InteractiveObject instance(such as touching
* three fingers to a screen and then moving
* them in parallel over a display object on a
* mobile phone or tablet with a touch screen).
* Moving several fingers in parallel is a
* common swipe gesture, but each device and
* operating system can have its own
* requirements for a swipe. Some devices might
* also interpret this contact as a combination
* of several mouse events, as well.
*
* Specifically, if a user moves a finger
* over an InteractiveObject, and then moves the
* fingers together, the InteractiveObject
* instance can dispatch a `rollOver`
* event and a `rollOut` event(among
* others), in addition to the
* `gestureSwipe` event, or all if
* the current environment supports it. Choose
* how you want to handle the user interaction.
* If you choose to handle the
* `rollOver` event, then the same
* event handler will run on a touch-enabled
* device and a mouse enabled device. However,
* if you choose to handle the
* `gestureSwipe` event, you can
* design your event handler to respond to the
* specific needs of a touch-enabled environment
* and provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* When handling the properties of the event
* object, note that the `localX` and
* `localY` properties are set to the
* primary point of contact. The
* `offsetX` and `offsetY`
* properties are the distance to the point of
* contact where the swipe gesture is
* complete.
*
* **Note:** While some devices using the
* Mac OS operating system can interpret a
* four-finger swipe, this API only supports a
* three-finger swipe.
* @:event gestureTwoFingerTap Dispatched when the user presses two points
* of contact over the same InteractiveObject
* instance on a touch-enabled device(such as
* presses and releases two fingers over a
* display object on a mobile phone or tablet
* with a touch screen). Some devices might also
* interpret this contact as a
* `doubleClick` event.
*
* Specifically, if a user taps two fingers
* over an InteractiveObject, the
* InteractiveObject instance can dispatch a
* `doubleClick` event or a
* `gestureTwoFingerTap` event, or
* both if the current environment supports it.
* Choose how you want to handle the user
* interaction. Use the openfl.ui.Multitouch
* class to manage touch event handling(enable
* touch gesture event handling, simple touch
* point event handling, or disable touch events
* so only mouse events are dispatched). If you
* choose to handle the `doubleClick`
* event, then the same event handler will run
* on a touch-enabled device and a mouse enabled
* device. However, if you choose to handle the
* `gestureTwoFingerTap` event, you
* can design your event handler to respond to
* the specific needs of a touch-enabled
* environment and provide users with a richer
* touch-enabled experience. You can also handle
* both events, separately, to provide a
* different response for a touch event than a
* mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event gestureZoom Dispatched when the user performs a zoom
* gesture at a point of contact with an
* InteractiveObject instance(such as touching
* two fingers to a screen and then quickly
* spreading the fingers apart over a display
* object on a mobile phone or tablet with a
* touch screen). Moving fingers apart is a
* common zoom gesture, but each device and
* operating system can have its own
* requirements to indicate zoom. Some devices
* might also interpret this contact as a
* combination of several mouse events, as well.
*
*
* Specifically, if a user moves a finger
* over an InteractiveObject, and then moves the
* fingers apart, the InteractiveObject instance
* can dispatch a `mouseOver` event
* and a `click` event(among
* others), in addition to the
* `gestureZoom` event, or all if the
* current environment supports it. Choose how
* you want to handle the user interaction. Use
* the openfl.ui.Multitouch class to manage touch
* event handling(enable touch gesture event
* handling, simple touch point event handling,
* or disable touch events so only mouse events
* are dispatched). If you choose to handle the
* `mouseOver` event, then the same
* event handler will run on a touch-enabled
* device and a mouse enabled device. However,
* if you choose to handle the
* `gestureZoom` event, you can
* design your event handler to respond to the
* specific needs of a touch-enabled environment
* and provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* When handling the properties of the event
* object, note that the `localX` and
* `localY` properties are set to the
* primary point of contact. The
* `offsetX` and `offsetY`
* properties are the distance to the point of
* contact where the zoom gesture is
* complete.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event imeStartComposition This event is dispatched to any client app
* that supports inline input with an IME
* @:event keyDown Dispatched when the user presses a key.
* Mappings between keys and specific characters
* vary by device and operating system. This
* event type is generated after such a mapping
* occurs but before the processing of an input
* method editor(IME). IMEs are used to enter
* characters, such as Chinese ideographs, that
* the standard QWERTY keyboard is ill-equipped
* to produce. This event occurs before the
* `keyUp` event.
*
* In AIR, canceling this event prevents the
* character from being entered into a text
* field.
* @:event keyFocusChange Dispatched when the user attempts to change
* focus by using keyboard navigation. The
* default behavior of this event is to change
* the focus and dispatch the corresponding
* `focusIn` and
* `focusOut` events.
*
* This event is dispatched to the object
* that currently has focus. The related object
* for this event is the InteractiveObject
* instance that receives focus if you do not
* prevent the default behavior. You can prevent
* the change in focus by calling the
* `preventDefault()` method in an
* event listener that is properly registered
* with the target object. Focus changes and
* `focusIn` and
* `focusOut` events are dispatched
* by default.
* @:event keyUp Dispatched when the user releases a key.
* Mappings between keys and specific characters
* vary by device and operating system. This
* event type is generated after such a mapping
* occurs but before the processing of an input
* method editor(IME). IMEs are used to enter
* characters, such as Chinese ideographs, that
* the standard QWERTY keyboard is ill-equipped
* to produce. This event occurs after a
* `keyDown` event and has the
* following characteristics:
* @:event middleClick Dispatched when a user presses and releases
* the middle button of the user's pointing
* device over the same InteractiveObject. For a
* `middleClick` event to occur, it
* must always follow this series of events in
* the order of occurrence:
* `middleMouseDown` event, then
* `middleMouseUp`. The target object
* must be identical for both of these events;
* otherwise the `middleClick` event
* does not occur. Any number of other mouse
* events can occur at any time between the
* `middleMouseDown` or
* `middleMouseUp` events; the
* `middleClick` event still occurs.
* @:event middleMouseDown Dispatched when a user presses the middle
* pointing device button over an
* InteractiveObject instance.
* @:event middleMouseUp Dispatched when a user releases the pointing
* device button over an InteractiveObject
* instance.
* @:event mouseDown Dispatched when a user presses the pointing
* device button over an InteractiveObject
* instance. If the target is a SimpleButton
* instance, the SimpleButton instance displays
* the `downState` display object as
* the default behavior. If the target is a
* selectable text field, the text field begins
* selection as the default behavior.
* @:event mouseFocusChange Dispatched when the user attempts to change
* focus by using a pointer device. The default
* behavior of this event is to change the focus
* and dispatch the corresponding
* `focusIn` and
* `focusOut` events.
*
* This event is dispatched to the object
* that currently has focus. The related object
* for this event is the InteractiveObject
* instance that receives focus if you do not
* prevent the default behavior. You can prevent
* the change in focus by calling
* `preventDefault()` in an event
* listener that is properly registered with the
* target object. The `shiftKey`
* property is not used. Focus changes and
* `focusIn` and
* `focusOut` events are dispatched
* by default.
* @:event mouseMove Dispatched when a user moves the pointing
* device while it is over an InteractiveObject.
* If the target is a text field that the user
* is selecting, the selection is updated as the
* default behavior.
* @:event mouseOut Dispatched when the user moves a pointing
* device away from an InteractiveObject
* instance. The event target is the object
* previously under the pointing device. The
* `relatedObject` is the object the
* pointing device has moved to. If the target
* is a SimpleButton instance, the button
* displays the `upState` display
* object as the default behavior.
*
* The `mouseOut` event is
* dispatched each time the mouse leaves the
* area of any child object of the display
* object container, even if the mouse remains
* over another child object of the display
* object container. This is different behavior
* than the purpose of the `rollOut`
* event, which is to simplify the coding of
* rollover behaviors for display object
* containers with children. When the mouse
* leaves the area of a display object or the
* area of any of its children to go to an
* object that is not one of its children, the
* display object dispatches the
* `rollOut` event.The
* `rollOut` events are dispatched
* consecutively up the parent chain of the
* object, starting with the object and ending
* with the highest parent that is neither the
* root nor an ancestor of the
* `relatedObject`.
* @:event mouseOver Dispatched when the user moves a pointing
* device over an InteractiveObject instance.
* The `relatedObject` is the object
* that was previously under the pointing
* device. If the target is a SimpleButton
* instance, the object displays the
* `overState` or
* `upState` display object,
* depending on whether the mouse button is
* down, as the default behavior.
*
* The `mouseOver` event is
* dispatched each time the mouse enters the
* area of any child object of the display
* object container, even if the mouse was
* already over another child object of the
* display object container. This is different
* behavior than the purpose of the
* `rollOver` event, which is to
* simplify the coding of rollout behaviors for
* display object containers with children. When
* the mouse enters the area of a display object
* or the area of any of its children from an
* object that is not one of its children, the
* display object dispatches the
* `rollOver` event. The
* `rollOver` events are dispatched
* consecutively down the parent chain of the
* object, starting with the highest parent that
* is neither the root nor an ancestor of the
* `relatedObject` and ending with
* the object.
* @:event mouseUp Dispatched when a user releases the pointing
* device button over an InteractiveObject
* instance. If the target is a SimpleButton
* instance, the object displays the
* `upState` display object. If the
* target is a selectable text field, the text
* field ends selection as the default behavior.
* @:event mouseWheel Dispatched when a mouse wheel is spun over an
* InteractiveObject instance. If the target is
* a text field, the text scrolls as the default
* behavior. Only available on Microsoft Windows
* operating systems.
* @:event nativeDragComplete Dispatched by the drag initiator
* InteractiveObject when the user releases the
* drag gesture.
*
* The event's dropAction property indicates
* the action set by the drag target object; a
* value of "none"
* (`DragActions.NONE`) indicates
* that the drop was canceled or was not
* accepted.
*
* The `nativeDragComplete` event
* handler is a convenient place to update the
* state of the initiating display object, for
* example, by removing an item from a list(on
* a drag action of "move"), or by changing the
* visual properties.
* @:event nativeDragDrop Dispatched by the target InteractiveObject
* when a dragged object is dropped on it and
* the drop has been accepted with a call to
* DragManager.acceptDragDrop().
*
* Access the dropped data using the event
* object `clipboard` property.
*
* The handler for this event should set the
* `DragManager.dropAction` property
* to provide feedback to the initiator object
* about which drag action was taken. If no
* value is set, the DragManager will select a
* default value from the list of allowed
* actions.
* @:event nativeDragEnter Dispatched by an InteractiveObject when a
* drag gesture enters its boundary.
*
* Handle either the
* `nativeDragEnter` or
* `nativeDragOver` events to allow
* the display object to become the drop
* target.
*
* To determine whether the dispatching
* display object can accept the drop, check the
* suitability of the data in
* `clipboard` property of the event
* object, and the allowed drag actions in the
* `allowedActions` property.
* @:event nativeDragExit Dispatched by an InteractiveObject when a
* drag gesture leaves its boundary.
* @:event nativeDragOver Dispatched by an InteractiveObject
* continually while a drag gesture remains
* within its boundary.
*
* `nativeDragOver` events are
* dispatched whenever the mouse is moved. On
* Windows and Mac, they are also dispatched on
* a short timer interval even when the mouse
* has not moved.
*
* Handle either the
* `nativeDragOver` or
* `nativeDragEnter` events to allow
* the display object to become the drop
* target.
*
* To determine whether the dispatching
* display object can accept the drop, check the
* suitability of the data in
* `clipboard` property of the event
* object, and the allowed drag actions in the
* `allowedActions` property.
* @:event nativeDragStart Dispatched at the beginning of a drag
* operation by the InteractiveObject that is
* specified as the drag initiator in the
* DragManager.doDrag() call.
* @:event nativeDragUpdate Dispatched during a drag operation by the
* InteractiveObject that is specified as the
* drag initiator in the DragManager.doDrag()
* call.
*
* `nativeDragUpdate` events are
* not dispatched on Linux.
* @:event paste Dispatched when the user activates the
* platform-specific accelerator key combination
* for a paste operation or selects 'Paste' from
* the text context menu. This event is
* dispatched to the object that currently has
* focus. If the object that currently has focus
* is a TextField, the default behavior of this
* event is to cause the contents of the
* clipboard to be pasted into the text field at
* the current insertion point replacing any
* currently selected text in the text field.
* @:event rightClick Dispatched when a user presses and releases
* the right button of the user's pointing
* device over the same InteractiveObject. For a
* `rightClick` event to occur, it
* must always follow this series of events in
* the order of occurrence:
* `rightMouseDown` event, then
* `rightMouseUp`. The target object
* must be identical for both of these events;
* otherwise the `rightClick` event
* does not occur. Any number of other mouse
* events can occur at any time between the
* `rightMouseDown` or
* `rightMouseUp` events; the
* `rightClick` event still occurs.
* @:event rightMouseDown Dispatched when a user presses the pointing
* device button over an InteractiveObject
* instance.
* @:event rightMouseUp Dispatched when a user releases the pointing
* device button over an InteractiveObject
* instance.
* @:event rollOut Dispatched when the user moves a pointing
* device away from an InteractiveObject
* instance. The event target is the object
* previously under the pointing device or a
* parent of that object. The
* `relatedObject` is the object that
* the pointing device has moved to. The
* `rollOut` events are dispatched
* consecutively up the parent chain of the
* object, starting with the object and ending
* with the highest parent that is neither the
* root nor an ancestor of the
* `relatedObject`.
*
* The purpose of the `rollOut`
* event is to simplify the coding of rollover
* behaviors for display object containers with
* children. When the mouse leaves the area of a
* display object or the area of any of its
* children to go to an object that is not one
* of its children, the display object
* dispatches the `rollOut` event.
* This is different behavior than that of the
* `mouseOut` event, which is
* dispatched each time the mouse leaves the
* area of any child object of the display
* object container, even if the mouse remains
* over another child object of the display
* object container.
* @:event rollOver Dispatched when the user moves a pointing
* device over an InteractiveObject instance.
* The event target is the object under the
* pointing device or a parent of that object.
* The `relatedObject` is the object
* that was previously under the pointing
* device. The `rollOver` events are
* dispatched consecutively down the parent
* chain of the object, starting with the
* highest parent that is neither the root nor
* an ancestor of the `relatedObject`
* and ending with the object.
*
* The purpose of the `rollOver`
* event is to simplify the coding of rollout
* behaviors for display object containers with
* children. When the mouse enters the area of a
* display object or the area of any of its
* children from an object that is not one of
* its children, the display object dispatches
* the `rollOver` event. This is
* different behavior than that of the
* `mouseOver` event, which is
* dispatched each time the mouse enters the
* area of any child object of the display
* object container, even if the mouse was
* already over another child object of the
* display object container.
* @:event selectAll Dispatched when the user activates the
* platform-specific accelerator key combination
* for a select all operation or selects 'Select
* All' from the text context menu. This event
* is dispatched to the object that currently
* has focus. If the object that currently has
* focus is a TextField, the default behavior of
* this event is to cause all the contents of
* the text field to be selected.
* @:event softKeyboardActivate Dispatched immediately after the soft
* keyboard is raised.
* @:event softKeyboardActivating Dispatched immediately before the soft
* keyboard is raised.
* @:event softKeyboardDeactivate Dispatched immediately after the soft
* keyboard is lowered.
* @:event tabChildrenChange Dispatched when the value of the object's
* `tabChildren` flag changes.
* @:event tabEnabledChange Dispatched when the object's
* `tabEnabled` flag changes.
* @:event tabIndexChange Dispatched when the value of the object's
* `tabIndex` property changes.
* @:event textInput Dispatched when a user enters one or more
* characters of text. Various text input
* methods can generate this event, including
* standard keyboards, input method editors
* (IMEs), voice or speech recognition systems,
* and even the act of pasting plain text with
* no formatting or style information.
* @:event touchBegin Dispatched when the user first contacts a
* touch-enabled device(such as touches a
* finger to a mobile phone or tablet with a
* touch screen). Some devices might also
* interpret this contact as a
* `mouseDown` event.
*
* Specifically, if a user touches a finger
* to a touch screen, the InteractiveObject
* instance can dispatch a
* `mouseDown` event or a
* `touchBegin` event, or both if the
* current environment supports it. Choose how
* you want to handle the user interaction. Use
* the openfl.ui.Multitouch class to manage touch
* event handling(enable touch gesture event
* handling, simple touch point event handling,
* or disable touch events so only mouse events
* are dispatched). If you choose to handle the
* `mouseDown` event, then the same
* event handler will run on a touch-enabled
* device and a mouse enabled device. However,
* if you choose to handle the
* `touchBegin` event, you can design
* your event handler to respond to the specific
* needs of a touch-enabled environment and
* provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event touchEnd Dispatched when the user removes contact with
* a touch-enabled device(such as lifts a
* finger off a mobile phone or tablet with a
* touch screen). Some devices might also
* interpret this contact as a
* `mouseUp` event.
*
* Specifically, if a user lifts a finger
* from a touch screen, the InteractiveObject
* instance can dispatch a `mouseUp`
* event or a `touchEnd` event, or
* both if the current environment supports it.
* Choose how you want to handle the user
* interaction. Use the openfl.ui.Multitouch
* class to manage touch event handling(enable
* touch gesture event handling, simple touch
* point event handling, or disable touch events
* so only mouse events are dispatched). If you
* choose to handle the `mouseUp`
* event, then the same event handler will run
* on a touch-enabled device and a mouse enabled
* device. However, if you choose to handle the
* `touchEnd` event, you can design
* your event handler to respond to the specific
* needs of a touch-enabled environment and
* provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event touchMove Dispatched when the user moves the point of
* contact with a touch-enabled device(such as
* drags a finger across a mobile phone or
* tablet with a touch screen). Some devices
* might also interpret this contact as a
* `mouseMove` event.
*
* Specifically, if a user moves a finger
* across a touch screen, the InteractiveObject
* instance can dispatch a
* `mouseMove` event or a
* `touchMove` event, or both if the
* current environment supports it. Choose how
* you want to handle the user interaction. Use
* the openfl.ui.Multitouch class to manage touch
* event handling(enable touch gesture event
* handling, simple touch point event handling,
* or disable touch events so only mouse events
* are dispatched). If you choose to handle the
* `mouseMove` event, then the same
* event handler will run on a touch-enabled
* device and a mouse enabled device. However,
* if you choose to handle the
* `touchMove` event, you can design
* your event handler to respond to the specific
* needs of a touch-enabled environment and
* provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event touchOut Dispatched when the user moves the point of
* contact away from InteractiveObject instance
* on a touch-enabled device(such as drags a
* finger from one display object to another on
* a mobile phone or tablet with a touch
* screen). Some devices might also interpret
* this contact as a `mouseOut`
* event.
*
* Specifically, if a user moves a finger
* across a touch screen, the InteractiveObject
* instance can dispatch a `mouseOut`
* event or a `touchOut` event, or
* both if the current environment supports it.
* Choose how you want to handle the user
* interaction. Use the openfl.ui.Multitouch
* class to manage touch event handling(enable
* touch gesture event handling, simple touch
* point event handling, or disable touch events
* so only mouse events are dispatched). If you
* choose to handle the `mouseOut`
* event, then the same event handler will run
* on a touch-enabled device and a mouse enabled
* device. However, if you choose to handle the
* `touchOut` event, you can design
* your event handler to respond to the specific
* needs of a touch-enabled environment and
* provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event touchOver Dispatched when the user moves the point of
* contact over an InteractiveObject instance on
* a touch-enabled device(such as drags a
* finger from a point outside a display object
* to a point over a display object on a mobile
* phone or tablet with a touch screen). Some
* devices might also interpret this contact as
* a `mouseOver` event.
*
* Specifically, if a user moves a finger
* over an InteractiveObject, the
* InteractiveObject instance can dispatch a
* `mouseOver` event or a
* `touchOver` event, or both if the
* current environment supports it. Choose how
* you want to handle the user interaction. Use
* the openfl.ui.Multitouch class to manage touch
* event handling(enable touch gesture event
* handling, simple touch point event handling,
* or disable touch events so only mouse events
* are dispatched). If you choose to handle the
* `mouseOver` event, then the same
* event handler will run on a touch-enabled
* device and a mouse enabled device. However,
* if you choose to handle the
* `touchOver` event, you can design
* your event handler to respond to the specific
* needs of a touch-enabled environment and
* provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event touchRollOut Dispatched when the user moves the point of
* contact away from an InteractiveObject
* instance on a touch-enabled device(such as
* drags a finger from over a display object to
* a point outside the display object on a
* mobile phone or tablet with a touch screen).
* Some devices might also interpret this
* contact as a `rollOut` event.
*
* Specifically, if a user moves a finger
* over an InteractiveObject, the
* InteractiveObject instance can dispatch a
* `rollOut` event or a
* `touchRollOut` event, or both if
* the current environment supports it. Choose
* how you want to handle the user interaction.
* Use the openfl.ui.Multitouch class to manage
* touch event handling(enable touch gesture
* event handling, simple touch point event
* handling, or disable touch events so only
* mouse events are dispatched). If you choose
* to handle the `rollOut` event,
* then the same event handler will run on a
* touch-enabled device and a mouse enabled
* device. However, if you choose to handle the
* `touchRollOut` event, you can
* design your event handler to respond to the
* specific needs of a touch-enabled environment
* and provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event touchRollOver Dispatched when the user moves the point of
* contact over an InteractiveObject instance on
* a touch-enabled device(such as drags a
* finger from a point outside a display object
* to a point over a display object on a mobile
* phone or tablet with a touch screen). Some
* devices might also interpret this contact as
* a `rollOver` event.
*
* Specifically, if a user moves a finger
* over an InteractiveObject, the
* InteractiveObject instance can dispatch a
* `rollOver` event or a
* `touchRollOver` event, or both if
* the current environment supports it. Choose
* how you want to handle the user interaction.
* Use the openfl.ui.Multitouch class to manage
* touch event handling(enable touch gesture
* event handling, simple touch point event
* handling, or disable touch events so only
* mouse events are dispatched). If you choose
* to handle the `rollOver` event,
* then the same event handler will run on a
* touch-enabled device and a mouse enabled
* device. However, if you choose to handle the
* `touchRollOver` event, you can
* design your event handler to respond to the
* specific needs of a touch-enabled environment
* and provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
* @:event touchTap Dispatched when the user lifts the point of
* contact over the same InteractiveObject
* instance on which the contact was initiated
* on a touch-enabled device(such as presses
* and releases a finger from a single point
* over a display object on a mobile phone or
* tablet with a touch screen). Some devices
* might also interpret this contact as a
* `click` event.
*
* Specifically, if a user taps a finger over
* an InteractiveObject, the InteractiveObject
* instance can dispatch a `click`
* event or a `touchTap` event, or
* both if the current environment supports it.
* Choose how you want to handle the user
* interaction. Use the openfl.ui.Multitouch
* class to manage touch event handling(enable
* touch gesture event handling, simple touch
* point event handling, or disable touch events
* so only mouse events are dispatched). If you
* choose to handle the `click`
* event, then the same event handler will run
* on a touch-enabled device and a mouse enabled
* device. However, if you choose to handle the
* `touchTap` event, you can design
* your event handler to respond to the specific
* needs of a touch-enabled environment and
* provide users with a richer touch-enabled
* experience. You can also handle both events,
* separately, to provide a different response
* for a touch event than a mouse event.
*
* **Note:** See the Multitouch class for
* environment compatibility information.
*/
export class InteractiveObject extends DisplayObject {
// #if flash
// @:noCompletion @:dox(hide) public var accessibilityImplementation:flash.accessibility.AccessibilityImplementation;
// #end
// #if flash
// @:noCompletion @:dox(hide) public var contextMenu:flash.ui.ContextMenu;
// #end
/**
* Specifies whether the object receives `doubleClick` events. The
* default value is `false`, which means that by default an
* InteractiveObject instance does not receive `doubleClick`
* events. If the `doubleClickEnabled` property is set to
* `true`, the instance receives `doubleClick` events
* within its bounds. The `mouseEnabled` property of the
* InteractiveObject instance must also be set to `true` for the
* object to receive `doubleClick` events.
*
* No event is dispatched by setting this property. You must use the
* `addEventListener()` method to add an event listener for the
* `doubleClick` event.
*/
doubleClickEnabled:boolean;
focusRect:boolean | null;
/**
* Specifies whether this object receives mouse, or other user input,
* messages. The default value is `true`, which means that by
* default any InteractiveObject instance that is on the display list
* receives mouse events or other user input events. If
* `mouseEnabled` is set to `false`, the instance does
* not receive any mouse events(or other user input events like keyboard
* events). Any children of this instance on the display list are not
* affected. To change the `mouseEnabled` behavior for all
* children of an object on the display list, use
* `openfl.display.DisplayObjectContainer.mouseChildren`.
*
* No event is dispatched by setting this property. You must use the
* `addEventListener()` method to create interactive
* functionality.
*/
mouseEnabled:boolean;
/**
* Specifies whether a virtual keyboard(an on-screen, software keyboard)
* should display when this InteractiveObject instance receives focus.
*
* By default, the value is `false` and focusing an
* InteractiveObject instance does not raise a soft keyboard. If the
* `needsSoftKeyboard` property is set to `true`, the
* runtime raises a soft keyboard when the InteractiveObject instance is
* ready to accept user input. An InteractiveObject instance is ready to
* accept user input after a programmatic call to set the Stage
* `focus` property or a user interaction, such as a "tap." If the
* client system has a hardware keyboard available or does not support
* virtual keyboards, then the soft keyboard is not raised.
*
* The InteractiveObject instance dispatches
* `softKeyboardActivating`, `softKeyboardActivate`,
* and `softKeyboardDeactivate` events when the soft keyboard
* raises and lowers.
*
* **Note:** This property is not supported in AIR applications on
* iOS.
*/
needsSoftKeyboard:boolean;
softKeyboardInputAreaOfInterest:Rectangle;
tabEnabled:boolean;
protected get_tabEnabled ():boolean;
protected set_tabEnabled (value:boolean):boolean;
tabIndex:number;
protected get_tabIndex ():number;
protected set_tabIndex (value:number):number;
/**
* Calling the `new InteractiveObject()` constructor throws an
* `ArgumentError` exception. You can, however, call constructors
* for the following subclasses of InteractiveObject:
*
* * `new SimpleButton()`
* * `new TextField()`
* * `new Loader()`
* * `new Sprite()`
* * `new MovieClip()`
*
*/
constructor ();
/**
* Raises a virtual keyboard.
*
* Calling this method focuses the InteractiveObject instance and raises
* the soft keyboard, if necessary. The `needsSoftKeyboard` must
* also be `true`. A keyboard is not raised if a hardware keyboard
* is available, or if the client system does not support virtual
* keyboards.
*
* **Note:** This method is not supported in AIR applications on
* iOS.
*
* @return A value of `true` means that the soft keyboard request
* was granted; `false` means that the soft keyboard was
* not raised.
*/
requestSoftKeyboard ():boolean;
}
}
export default openfl.display.InteractiveObject;