The current accessibility implementation (AccessibilityImplementation) for this InteractiveObject instance.

See also

Specifies the context menu associated with this object.

For content running in Flash Player, this property is a ContextMenu object. In the AIR runtime, the ContextMenu class extends the NativeMenu class, however Flash Player only supports the ContextMenu class, not the NativeMenu class.

Note: TextField objects always include a clipboard menu in the context menu. The clipboard menu contains Cut, Copy, Paste, Clear, and Select All commands. You cannot remove these commands from the context menu for TextField objects. For TextField objects, selecting these commands (or their keyboard equivalents) does not generate clear, copy, cut, paste, or selectAll events.

var red_cmi:ContextMenuItem = new ContextMenuItem("red");
red_cmi.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, cmi_menuItemSelect);
 
var cm:ContextMenu = new ContextMenu();
cm.customItems.push(red_cmi);
cm.hideBuiltInItems();
 
var spr:Sprite = new Sprite();
spr.contextMenu = cm;
spr.graphics.beginFill(0x000000);
spr.graphics.drawRect(0, 0, 120, 90);
spr.graphics.endFill();
spr.x = 10;
spr.y = 10;
addChild(spr);
 
function cmi_menuItemSelect(evt:ContextMenuEvent):void {
    spr.graphics.clear();
    spr.graphics.beginFill(0xFF0000);
    spr.graphics.drawRect(0, 0, 120, 90);
    spr.graphics.endFill();
}

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.

See also

Specifies whether this object displays a focus rectangle. It can take one of three values: true, false, or null. Values of true and false work as expected, specifying whether or not the focus rectangle appears. A value of null indicates that this object obeys the stageFocusRect property of the Stage.

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 keybaord 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 flash.display.DisplayObjectContainer.mouseChildren.

No event is dispatched by setting this property. You must use the addEventListener() method to create interactive functionality.

See also

Specifies whether this object is in the tab order. If this object is in the tab order, the value is true; otherwise, the value is false. By default, the value is false, except for the following:

• For a SimpleButton object, the value is true.
• For a TextField object with type = "input", the value is true.
• For a Sprite object or MovieClip object with buttonMode = true, the value is true.

Specifies the tab ordering of objects in a SWF file. The tabIndex property is -1 by default, meaning no tab index is set for the object.

If any currently displayed object in the SWF file contains a tabIndex property, automatic tab ordering is disabled, and the tab ordering is calculated from the tabIndex properties of objects in the SWF file. The custom tab ordering includes only objects that have tabIndex properties.

The tabIndex property can be a non-negative integer. The objects are ordered according to their tabIndex properties, in ascending order. An object with a tabIndex value of 1 precedes an object with a tabIndex value of 2. Do not use the same tabIndex value for multiple objects.

The custom tab ordering that the tabIndex property defines is flat. This means that no attention is paid to the hierarchical relationships of objects in the SWF file. All objects in the SWF file with tabIndex properties are placed in the tab order, and the tab order is determined by the order of the tabIndex values.

Note: To set the tab order for TLFTextField instances, cast the display object child of the TLFTextField as an InteractiveObject, then set the tabIndex property. For example:

	 InteractiveObject(tlfInstance.getChildAt(1)).tabIndex = 3;
	 

	 InteractiveObject(tlfInstance1.getChildAt(1)).tabIndex = 3;
	 InteractiveObject(tlfInstance2.getChildAt(1)).tabIndex = 2;
	 InteractiveObject(tlfInstance3.getChildAt(1)).tabIndex = 1;
	 

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()

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.

This event has the following properties:

Note: TextField objects do not dispatch clear, copy, cut, paste, or selectAll events. TextField objects always include Cut, Copy, Paste, Clear, and Select All commands in the context menu. You cannot remove these commands from the context menu for TextField objects. For TextField objects, selecting these commands (or their keyboard equivalents) does not generate clear, copy, cut, paste, or selectAll events. However, other classes that extend the InteractiveObject class, including components built using the Flash Text Engine (FTE), can dispatch these events.

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.

This event has the following properties:

Dispatched when a user gesture triggers the context menu associated with this interactive object in an AIR application.

This event has the following properties:

See also

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.

This event has the following properties:

Note: TextField objects do not dispatch clear, copy, cut, paste, or selectAll events. TextField objects always include Cut, Copy, Paste, Clear, and Select All commands in the context menu. You cannot remove these commands from the context menu for TextField objects. For TextField objects, selecting these commands (or their keyboard equivalents) does not generate clear, copy, cut, paste, or selectAll events. However, other classes that extend the InteractiveObject class, including components built using the Flash Text Engine (FTE), can dispatch these events.

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.

This event has the following properties:

Note: TextField objects do not dispatch clear, copy, cut, paste, or selectAll events. TextField objects always include Cut, Copy, Paste, Clear, and Select All commands in the context menu. You cannot remove these commands from the context menu for TextField objects. For TextField objects, selecting these commands (or their keyboard equivalents) does not generate clear, copy, cut, paste, or selectAll events. However, other classes that extend the InteractiveObject class, including components built using the Flash Text Engine (FTE), can dispatch these events.

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.

This event has the following properties:

See also

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.

This event has the following properties:

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.

This event has the following properties:

Dispatched when the user moves a point of contact over the InteractiveObject instance on a touch-enabled device (such as moving a fingers 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 flash.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.

The dispatched TransformGestureEvent object has the following properties:

Multitouch.inputMode = MultitouchInputMode.GESTURE;

var mySprite = new Sprite();
mySprite.addEventListener(TransformGestureEvent.GESTURE_PAN , onPan);
mySprite.graphics.beginFill(0x336699);
mySprite.graphics.drawRect(0, 0, 100, 80);
var myTextField = new TextField();
myTextField.y = 200;
addChild(mySprite);
addChild(myTextField);

function onPan(evt:TransformGestureEvent):void {

    evt.target.localX++;

    if (evt.phase==GesturePhase.BEGIN) {
        myTextField.text = "Begin";
    }
    if (evt.phase==GesturePhase.UPDATE) {
        myTextField.text = "Update";
    }
    if (evt.phase==GesturePhase.END) {
        myTextField.text = "End";
    }
}

See also

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 flash.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").

The dispatched PressAndTapGestureEvent object has the following properties:

See also

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 flash.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.

The dispatched TransformGestureEvent object has the following properties:

Multitouch.inputMode = MultitouchInputMode.GESTURE;

var mySprite = new Sprite();
mySprite.addEventListener(TransformGestureEvent.GESTURE_ROTATE , onRotate );
mySprite.graphics.beginFill(0x336699);
mySprite.graphics.drawRect(0, 0, 100, 80);
var myTextField = new TextField();
myTextField.y = 200;
addChild(mySprite);
addChild(myTextField);

function onRotate(evt:TransformGestureEvent):void {

    evt.target.rotation -= 45;

    if (evt.phase==GesturePhase.BEGIN) {
        myTextField.text = "Begin";
    }
    if (evt.phase==GesturePhase.UPDATE) {
        myTextField.text = "Update";
    }
    if (evt.phase==GesturePhase.END) {
        myTextField.text = "End";
    }
}

See also

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.

The dispatched TransformGestureEvent object has the following properties:

Multitouch.inputMode = MultitouchInputMode.GESTURE;

var mySprite = new Sprite();
mySprite.addEventListener(TransformGestureEvent.GESTURE_SWIPE , onSwipe);
mySprite.graphics.beginFill(0x336699);
mySprite.graphics.drawRect(0, 0, 100, 80);
var myTextField = new TextField();
myTextField.y = 200;
addChild(mySprite);
addChild(myTextField);

function onSwipe(evt:TransformGestureEvent):void {

    if (evt.offsetX == 1 ) {
    myTextField.text = "right";
    }
    if (evt.offsetY == -1) {
    myTextField.text = "up";
    }
    myTextField.text = evt.phase;

}

See also

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 flash.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.

The dispatched GestureEvent object has the following properties:

See also

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 flash.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.

The dispatched TransformGestureEvent object has the following properties:

Multitouch.inputMode = MultitouchInputMode.GESTURE;

var mySprite = new Sprite();
mySprite.addEventListener(TransformGestureEvent.GESTURE_ZOOM , onZoom);
mySprite.graphics.beginFill(0x336699);
mySprite.graphics.drawRect(0, 0, 100, 80);
var myTextField = new TextField();
myTextField.y = 200;
addChild(mySprite);
addChild(myTextField);

function onZoom(evt:TransformGestureEvent):void {

    evt.target.scaleX++;

    if (evt.phase==GesturePhase.BEGIN) {
        myTextField.text = "Begin";
    }
    if (evt.phase==GesturePhase.UPDATE) {
        myTextField.text = "Update";
    }
    if (evt.phase==GesturePhase.END) {
        myTextField.text = "End";
    }
}

See also

This event is dispatched to any client app that supports inline input with an IME

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.

This event has the following properties:

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.

This event has the following properties:

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:

This event has the following properties:

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.

This event has the following properties:

Dispatched when a user presses the middle pointing device button over an InteractiveObject instance.

This event has the following properties:

Dispatched when a user releases the pointing device button over an InteractiveObject instance.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

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 an drag action of "move"), or by changing the visual properties.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

Dispatched by an InteractiveObject when a drag gesture leaves its boundary.

This event has the following properties:

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.

This event has the following properties:

Dispatched at the beginning of a drag operation by the InteractiveObject that is specified as the drag initiator in the DragManager.doDrag() call.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

Note: TextField objects do not dispatch clear, copy, cut, paste, or selectAll events. TextField objects always include Cut, Copy, Paste, Clear, and Select All commands in the context menu. You cannot remove these commands from the context menu for TextField objects. For TextField objects, selecting these commands (or their keyboard equivalents) does not generate clear, copy, cut, paste, or selectAll events. However, other classes that extend the InteractiveObject class, including components built using the Flash Text Engine (FTE), can dispatch these events.

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.

This event has the following properties:

Dispatched when a user presses the pointing device button over an InteractiveObject instance.

This event has the following properties:

Dispatched when a user releases the pointing device button over an InteractiveObject instance.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

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.

This event has the following properties:

Note: TextField objects do not dispatch clear, copy, cut, paste, or selectAll events. TextField objects always include Cut, Copy, Paste, Clear, and Select All commands in the context menu. You cannot remove these commands from the context menu for TextField objects. For TextField objects, selecting these commands (or their keyboard equivalents) does not generate clear, copy, cut, paste, or selectAll events. However, other classes that extend the InteractiveObject class, including components built using the Flash Text Engine (FTE), can dispatch these events.

Dispatched when the value of the object's tabChildren flag changes.

This event has the following properties:

Dispatched when the object's tabEnabled flag changes.

This event has the following properties:

Dispatched when the value of the object's tabIndex property changes.

This event has the following properties:

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.

Note: This event is not dispatched for the Delete or Backspace keys.

This event has the following properties:

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 flash.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.

The dispatched TouchEvent object has the following properties:

Multitouch.inputMode = MultitouchInputMode.TOUCH_POINT;

MySprite.addEventListener(TouchEvent.TOUCH_BEGIN, onTouchBegin);
MySprite.addEventListener(TouchEvent.TOUCH_MOVE, onTouchMove);
MySprite.addEventListener(TouchEvent.TOUCH_END, onTouchEnd);

function onTouchBegin(eBegin:TouchEvent) {
     eBegin.target.startTouchDrag(eBegin.touchPointID, false, bg.getRect(this));
     trace("touch begin");
 
 }

function onTouchMove(eMove:TouchEvent) {
    trace(eMove.stageX);
}
 
function onTouchEnd(eEnd:TouchEvent) {
     eEnd.target.stopTouchDrag(eEnd.touchPointID);
     trace("touch end");
}

See also

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 flash.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.

The dispatched TouchEvent object has the following properties:

Multitouch.inputMode = MultitouchInputMode.TOUCH_POINT;

MySprite.addEventListener(TouchEvent.TOUCH_BEGIN, onTouchBegin);
MySprite.addEventListener(TouchEvent.TOUCH_MOVE, onTouchMove);
MySprite.addEventListener(TouchEvent.TOUCH_END, onTouchEnd);

function onTouchBegin(eBegin:TouchEvent) {
     eBegin.target.startTouchDrag(eBegin.touchPointID, false, bg.getRect(this));
     trace("touch begin");
 
 }

function onTouchMove(eMove:TouchEvent) {
    trace(eMove.stageX);
}
 
function onTouchEnd(eEnd:TouchEvent) {
     eEnd.target.stopTouchDrag(eEnd.touchPointID);
     trace("touch end");
}

See also

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 flash.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.

The dispatched TouchEvent object has the following properties:

Multitouch.inputMode = MultitouchInputMode.TOUCH_POINT;

MySprite.addEventListener(TouchEvent.TOUCH_BEGIN, onTouchBegin);
MySprite.addEventListener(TouchEvent.TOUCH_MOVE, onTouchMove);
MySprite.addEventListener(TouchEvent.TOUCH_END, onTouchEnd);

function onTouchBegin(eBegin:TouchEvent) {
     eBegin.target.startTouchDrag(eBegin.touchPointID, false, bg.getRect(this));
     trace("touch begin");
 
 }

function onTouchMove(eMove:TouchEvent) {
    trace(eMove.stageX);
}
 
function onTouchEnd(eEnd:TouchEvent) {
     eEnd.target.stopTouchDrag(eEnd.touchPointID);
     trace("touch end");
}

See also

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 flash.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.

The dispatched TouchEvent object has the following properties:

See also

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 flash.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.

The dispatched TouchEvent object has the following properties:

See also

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 outisde 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 flash.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.

The dispatched TouchEvent object has the following properties:

See also

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 flash.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.

The dispatched TouchEvent object has the following properties:

See also

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 flash.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.

The dispatched TouchEvent object has the following properties:

Multitouch.inputMode=MultitouchInputMode.TOUCH_POINT;

var mySprite:Sprite = new Sprite();
var myTextField:TextField = new TextField();

mySprite.graphics.beginFill(0x336699);
mySprite.graphics.drawRect(0,0,40,40);
addChild(mySprite);

mySprite.addEventListener(TouchEvent.TOUCH_TAP, taphandler);

function taphandler(e:TouchEvent): void {
    myTextField.text = "I've been tapped";
    myTextField.y = 50;
    addChild(myTextField);
}

See also

1. In the InteractiveObjectExample constructor, a new ChildSprite object of type Sprite called child is created, which calls the ChildSprite constructor method to draw the shape and add mouse events for the shape (as explained in the following steps). The child object is added to the top of the display list at coordinates x = 0, y = 0.
2. In the ChildSprite class, declare the size and overSize properties that are used later in the draw() method and MouseEvent methods.
3. Declare properties that set the background color to orange, the mouse-over color to dark yellow, and the mouse-down color to light blue.
4. In the ChildSprite constructor, an orange square is drawn by using methods from the Graphics class and the draw() method.
5. The constructor adds four MouseEvent event listener methods:
   • mouseOverHandler: redraws a larger 60 x 60 pixel square with a dark-yellow color at the original coordinates.
   • mouseOutHandler: returns the square to its original size and color.
   • mouseDownHandler: redraws a larger 60 x 60 pixel square with a light-blue color at the original coordinates.
   • mouseUpHandler: same as mouseOverHandler.

package {
    import flash.display.Sprite;

    public class InteractiveObjectExample extends Sprite {

        public function InteractiveObjectExample() {
            var child:Sprite = new ChildSprite();
            addChild(child);
        }
    }
}

import flash.display.Sprite;
import flash.events.MouseEvent;

class ChildSprite extends Sprite {
    private var size:uint = 50;
    private var overSize:uint = 60;
    private var backgroundColor:uint = 0xFFCC00;
    private var overColor:uint = 0xCCFF00;
    private var downColor:uint = 0x00CCFF;

    public function ChildSprite() {
        buttonMode = true;
        draw(size, size, backgroundColor);
        addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
        addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
        addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
        addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
    }

    private function draw(w:uint, h:uint, bgColor:uint):void {
        graphics.clear();
        graphics.beginFill(bgColor);
        graphics.drawRect(0, 0, w, h);
        graphics.endFill();
    }

    public function mouseOverHandler(event:MouseEvent):void {
        trace("mouseOverHandler");
        draw(overSize, overSize, overColor);
    }

    public function mouseOutHandler(event:MouseEvent):void {
        trace("mouseOutHandler");
        draw(size, size, backgroundColor);
    }

    public function mouseDownHandler(event:MouseEvent):void {
        trace("mouseDownHandler");
        draw(overSize, overSize, downColor);
    }

    public function mouseUpHandler(event:MouseEvent):void {
        trace("mouseUpHandler");
        draw(overSize, overSize, overColor);
    }
}