Sprite Class
Displays a frame or sequence of frames (ie. an animation) from a SpriteSheet instance. A sprite sheet is a series of images (usually animation frames) combined into a single image. For example, an animation consisting of 8 100x100 images could be combined into a 400x200 sprite sheet (4 frames across by 2 high). You can display individual frames, play frames as an animation, and even sequence animations together.
See the SpriteSheet class for more information on setting up frames and animations.
Example
var instance = new createjs.Sprite(spriteSheet);
instance.gotoAndStop("frameName");Until gotoAndStop or gotoAndPlay is called, only the first defined frame defined in the sprite sheet will be displayed.
Constructor
Sprite
-
spriteSheet -
[frameOrAnimation]
Parameters:
-
spriteSheetSpriteSheetThe SpriteSheet instance to play back. This includes the source image(s), frame dimensions, and frame data. See SpriteSheet for more information.
-
[frameOrAnimation]String | Number optionalThe frame number or animation to play initially.
Item Index
Methods
- _applyShadow
- _cloneProps
- _dispatchEvent
- _getBounds
- _getStage
- _goto
- _isMouseOpaque
- _normalizeFrame
- _testHit
- _tick
- _transformBounds
- _updateState
- addEventListener
- advance
- cache
- clone
- dispatchEvent
- draw
- getBounds
- getCacheDataURL
- getConcatenatedDisplayProps
- getConcatenatedMatrix
- getMatrix
- getStage deprecated
- getTransformedBounds
- globalToLocal
- gotoAndPlay
- gotoAndStop
- hasEventListener
- hitTest
- initialize deprecated
- isVisible
- localToGlobal
- localToLocal
- off
- on
- play
- removeAllEventListeners
- removeEventListener
- set
- setBounds
- setTransform
- stop
- toString
- uncache
- updateCache
- updateContext
- willTrigger
Properties
- _animation
- _bounds
- _cacheDataURL deprecated
- _cacheDataURLID deprecated
- _cacheScale deprecated
- _captureListeners
- _currentFrame
- _dispatchAnimationEnd
- _listeners
- _props
- _rectangle
- _skipAdvance
- _webGLRenderStyle
- alpha
- bitmapCache
- cacheCanvas
- cacheID deprecated
- compositeOperation
- currentAnimation
- currentAnimationFrame
- currentFrame
- cursor
- filters
- framerate
- hitArea
- id
- mask
- mouseEnabled
- name
- parent
- paused
- regX
- regY
- rotation
- scale
- scaleX
- scaleY
- shadow
- skewX
- skewY
- snapToPixel
- spriteSheet
- stage
- tickEnabled
- transformMatrix
- visible
- x
- y
Methods
_dispatchEvent
-
eventObj -
eventPhase
_goto
-
frameOrAnimation -
[frame]
Moves the playhead to the specified frame number or animation.
_isMouseOpaque
()
Boolean
protected
Indicates whether the display object has any mouse event listeners or a cursor.
Returns:
_normalizeFrame
()
protected
Normalizes the current frame, advancing animations and dispatching callbacks as appropriate.
_tick
-
evtObj
Advances the currentFrame if paused is not true. This is called automatically when the Stage
ticks.
Parameters:
-
evtObjObjectAn event object that will be dispatched to all tick listeners. This object is reused between dispatchers to reduce construction & GC costs.
_updateState
()
protected
Called before the object gets drawn and is a chance to ensure the display state of the object is correct. Mostly used by MovieClip and BitmapText to correct their internal state and children prior to being drawn.
Is manually called via draw in a Stage but is automatically called when present in a StageGL instance.
addEventListener
-
type -
listener -
[useCapture]
Adds the specified event listener. Note that adding multiple listeners to the same function will result in multiple callbacks getting fired.
Example
displayObject.addEventListener("click", handleClick);
function handleClick(event) {
// Click happened.
}Parameters:
-
typeStringThe string type of the event.
-
listenerFunction | ObjectAn object with a handleEvent method, or a function that will be called when the event is dispatched.
-
[useCapture]Boolean optionalFor events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase.
advance
-
[time]
Advances the playhead. This occurs automatically each tick by default.
Parameters:
-
[time]Number optionalThe amount of time in ms to advance by. Only applicable if framerate is set on the Sprite or its SpriteSheet.
cache
()
Because the content of a Sprite is already in a raster format, cache is unnecessary for Sprite instances. You should not cache Sprite instances as it can degrade performance.
clone
()
Sprite
Returns a clone of the Sprite instance. Note that the same SpriteSheet is shared between cloned instances.
Returns:
a clone of the Sprite instance.
dispatchEvent
-
eventObj -
[bubbles] -
[cancelable]
Dispatches the specified event to all listeners.
Example
// Use a string event
this.dispatchEvent("complete");
// Use an Event instance
var event = new createjs.Event("progress");
this.dispatchEvent(event);Parameters:
-
eventObjObject | String | EventAn object with a "type" property, or a string type. While a generic object will work, it is recommended to use a CreateJS Event instance. If a string is used, dispatchEvent will construct an Event instance if necessary with the specified type. This latter approach can be used to avoid event object instantiation for non-bubbling events that may not have any listeners.
-
[bubbles]Boolean optionalSpecifies the
bubblesvalue when a string was passed to eventObj. -
[cancelable]Boolean optionalSpecifies the
cancelablevalue when a string was passed to eventObj.
Returns:
Returns false if preventDefault() was called on a cancelable event, true otherwise.
draw
-
ctx -
ignoreCache
Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. Returns true if the draw was handled (useful for overriding functionality). NOTE: This method is mainly for internal use, though it may be useful for advanced uses.
Parameters:
-
ctxCanvasRenderingContext2DThe canvas 2D context object to draw into.
-
ignoreCacheBooleanIndicates whether the draw operation should ignore any current cache. For example, used for drawing the cache (to prevent it from simply drawing an existing cache back into itself).
getBounds
()
Rectangle
Returns a Rectangle instance defining the bounds of the current frame relative to
the origin. For example, a 90 x 70 frame with regX=50 and regY=40 would return a
rectangle with [x=-50, y=-40, width=90, height=70]. This ignores transformations on the display object.
Also see the SpriteSheet getFrameBounds method.
Returns:
A Rectangle instance. Returns null if the frame does not exist, or the image is not fully loaded.
getCacheDataURL
()
String
Returns a data URL for the cache, or null if this display object is not cached. Only generated if the cache has changed, otherwise returns last result.
Returns:
The image data url for the cache.
getConcatenatedDisplayProps
-
[props]
Generates a DisplayProps object representing the combined display properties of the object and all of its parent Containers up to the highest level ancestor (usually the Stage).
Parameters:
-
[props]DisplayProps optionalA DisplayProps object to populate with the calculated values. If null, a new DisplayProps object is returned.
Returns:
The combined display properties.
getConcatenatedMatrix
-
[matrix]
Generates a Matrix2D object representing the combined transform of the display object and all of its parent Containers up to the highest level ancestor (usually the Stage). This can be used to transform positions between coordinate spaces, such as with localToGlobal and globalToLocal.
Parameters:
Returns:
The combined matrix.
getMatrix
-
matrix
Returns a matrix based on this object's current transform.
Parameters:
-
matrixMatrix2DOptional. A Matrix2D object to populate with the calculated values. If null, a new Matrix object is returned.
Returns:
A matrix representing this display object's transform.
getTransformedBounds
()
Rectangle
Returns a rectangle representing this object's bounds in its parent's coordinate system (ie. with transformations applied). Objects that have been cached will return the transformed bounds of the cache.
Not all display objects can calculate their own bounds (ex. Shape). For these objects, you can use setBounds so that they are included when calculating Container bounds.
To reduce memory impact, the returned Rectangle instance may be reused internally; clone the instance or copy its values if you need to retain it.
Container instances calculate aggregate bounds for all children that return bounds via getBounds.
Returns:
A Rectangle instance representing the bounds, or null if bounds are not available for this object.
globalToLocal
-
x -
y -
[pt]
Transforms the specified x and y position from the global (stage) coordinate space to the coordinate space of the display object. For example, this could be used to determine the current mouse position within the display object. Returns a Point instance with x and y properties correlating to the transformed position in the display object's coordinate space.
Example
displayObject.x = 300;
displayObject.y = 200;
stage.addChild(displayObject);
var point = displayObject.globalToLocal(100, 100);
// Results in x=-200, y=-100Parameters:
Returns:
A Point instance with x and y properties correlating to the transformed position in the display object's coordinate space.
gotoAndPlay
-
frameOrAnimation
Sets paused to false and plays the specified animation name, named frame, or frame number.
gotoAndStop
-
frameOrAnimation
Sets paused to true and seeks to the specified animation name, named frame, or frame number.
hasEventListener
-
type
Indicates whether there is at least one listener for the specified event type.
Parameters:
-
typeStringThe string type of the event.
Returns:
Returns true if there is at least one listener for the specified event.
hitTest
-
x -
y
Tests whether the display object intersects the specified point in local coordinates (ie. draws a pixel with alpha > 0 at the specified position). This ignores the alpha, shadow, hitArea, mask, and compositeOperation of the display object.
Example
stage.addEventListener("stagemousedown", handleMouseDown);
function handleMouseDown(event) {
var hit = myShape.hitTest(event.stageX, event.stageY);
}Please note that shape-to-shape collision is not currently supported by EaselJS.
Parameters:
Returns:
A Boolean indicating whether a visible portion of the DisplayObject intersect the specified local Point.
initialize
()
deprecated
Constructor alias for backwards compatibility. This method will be removed in future versions. Subclasses should be updated to use Utility Methods/extends.
isVisible
()
Boolean
Returns true or false indicating whether the display object would be visible if drawn to a canvas. This does not account for whether it would be visible within the boundaries of the stage. NOTE: This method is mainly for internal use, though it may be useful for advanced uses.
Returns:
Boolean indicating whether the display object would be visible if drawn to a canvas
localToGlobal
-
x -
y -
[pt]
Transforms the specified x and y position from the coordinate space of the display object to the global (stage) coordinate space. For example, this could be used to position an HTML label over a specific point on a nested display object. Returns a Point instance with x and y properties correlating to the transformed coordinates on the stage.
Example
displayObject.x = 300;
displayObject.y = 200;
stage.addChild(displayObject);
var point = displayObject.localToGlobal(100, 100);
// Results in x=400, y=300Parameters:
Returns:
A Point instance with x and y properties correlating to the transformed coordinates on the stage.
localToLocal
-
x -
y -
target -
[pt]
Transforms the specified x and y position from the coordinate space of this display object to the coordinate space of the target display object. Returns a Point instance with x and y properties correlating to the transformed position in the target's coordinate space. Effectively the same as using the following code with localToGlobal and globalToLocal.
var pt = this.localToGlobal(x, y);
pt = target.globalToLocal(pt.x, pt.y);Parameters:
-
xNumberThe x position in the source display object to transform.
-
yNumberThe y position on the source display object to transform.
-
targetDisplayObjectThe target display object to which the coordinates will be transformed.
-
[pt]Point | Object optionalAn object to copy the result into. If omitted a new Point object with x/y properties will be returned.
Returns:
Returns a Point instance with x and y properties correlating to the transformed position in the target's coordinate space.
off
-
type -
listener -
[useCapture]
A shortcut to the removeEventListener method, with the same parameters and return value. This is a companion to the .on method.
IMPORTANT: To remove a listener added with on, you must pass in the returned wrapper function as the listener. See
on for an example.
on
-
type -
listener -
[scope] -
[once=false] -
[data] -
[useCapture=false]
A shortcut method for using addEventListener that makes it easier to specify an execution scope, have a listener only run once, associate arbitrary data with the listener, and remove the listener.
This method works by creating an anonymous wrapper function and subscribing it with addEventListener.
The wrapper function is returned for use with removeEventListener (or off).
IMPORTANT: To remove a listener added with on, you must pass in the returned wrapper function as the listener, or use
remove. Likewise, each time you call on a NEW wrapper function is subscribed, so multiple calls
to on with the same params will create multiple listeners.
Example
var listener = myBtn.on("click", handleClick, null, false, {count:3});
function handleClick(evt, data) {
data.count -= 1;
console.log(this == myBtn); // true - scope defaults to the dispatcher
if (data.count == 0) {
alert("clicked 3 times!");
myBtn.off("click", listener);
// alternately: evt.remove();
}
}Parameters:
-
typeStringThe string type of the event.
-
listenerFunction | ObjectAn object with a handleEvent method, or a function that will be called when the event is dispatched.
-
[scope]Object optionalThe scope to execute the listener in. Defaults to the dispatcher/currentTarget for function listeners, and to the listener itself for object listeners (ie. using handleEvent).
-
[once=false]Boolean optionalIf true, the listener will remove itself after the first time it is triggered.
-
[data]optionalArbitrary data that will be included as the second parameter when the listener is called.
-
[useCapture=false]Boolean optionalFor events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase.
Returns:
Returns the anonymous function that was created and assigned as the listener. This is needed to remove the listener later using .removeEventListener.
play
()
Play (unpause) the current animation. The Sprite will be paused if either stop or gotoAndStop is called. Single frame animations will remain unchanged.
removeAllEventListeners
-
[type]
Removes all listeners for the specified type, or all listeners of all types.
Example
// Remove all listeners
displayObject.removeAllEventListeners();
// Remove all click listeners
displayObject.removeAllEventListeners("click");Parameters:
-
[type]String optionalThe string type of the event. If omitted, all listeners for all types will be removed.
removeEventListener
-
type -
listener -
[useCapture]
Removes the specified event listener.
Important Note: that you must pass the exact function reference used when the event was added. If a proxy function, or function closure is used as the callback, the proxy/closure reference must be used - a new proxy or closure will not work.
Example
displayObject.removeEventListener("click", handleClick);set
-
props
Provides a chainable shortcut method for setting a number of properties on the instance.
Example
var myGraphics = new createjs.Graphics().beginFill("#ff0000").drawCircle(0, 0, 25);
var shape = stage.addChild(new Shape()).set({graphics:myGraphics, x:100, y:100, alpha:0.5});Parameters:
-
propsObjectA generic object containing properties to copy to the DisplayObject instance.
Returns:
Returns the instance the method is called on (useful for chaining calls.)
setBounds
-
x -
y -
width -
height
Allows you to manually specify the bounds of an object that either cannot calculate their own bounds (ex. Shape & Text) for future reference, or so the object can be included in Container bounds. Manually set bounds will always override calculated bounds.
The bounds should be specified in the object's local (untransformed) coordinates. For example, a Shape instance with a 25px radius circle centered at 0,0 would have bounds of (-25, -25, 50, 50).
setTransform
-
[x=0] -
[y=0] -
[scaleX=1] -
[scaleY=1] -
[rotation=0] -
[skewX=0] -
[skewY=0] -
[regX=0] -
[regY=0]
Shortcut method to quickly set the transform properties on the display object. All parameters are optional. Omitted parameters will have the default value set.
Example
displayObject.setTransform(100, 100, 2, 2);Parameters:
-
[x=0]Number optionalThe horizontal translation (x position) in pixels
-
[y=0]Number optionalThe vertical translation (y position) in pixels
-
[scaleX=1]Number optionalThe horizontal scale, as a percentage of 1
-
[scaleY=1]Number optionalthe vertical scale, as a percentage of 1
-
[rotation=0]Number optionalThe rotation, in degrees
-
[skewX=0]Number optionalThe horizontal skew factor
-
[skewY=0]Number optionalThe vertical skew factor
-
[regX=0]Number optionalThe horizontal registration point in pixels
-
[regY=0]Number optionalThe vertical registration point in pixels
Returns:
Returns this instance. Useful for chaining commands.
stop
()
Stop playing a running animation. The Sprite will be playing if gotoAndPlay is called. Note that calling gotoAndPlay or play will resume playback.
toString
()
String
Returns a string representation of this object.
Returns:
a string representation of the instance.
uncache
()
Because the content of a Sprite is already in a raster format, cache is unnecessary for Sprite instances. You should not cache Sprite instances as it can degrade performance.
updateCache
()
Because the content of a Sprite is already in a raster format, cache is unnecessary for Sprite instances. You should not cache Sprite instances as it can degrade performance.
updateContext
-
ctx
Applies this display object's transformation, alpha, globalCompositeOperation, clipping path (mask), and shadow to the specified context. This is typically called prior to draw.
Parameters:
-
ctxCanvasRenderingContext2DThe canvas 2D to update.
willTrigger
-
type
Indicates whether there is at least one listener for the specified event type on this object or any of its ancestors (parent, parent's parent, etc). A return value of true indicates that if a bubbling event of the specified type is dispatched from this object, it will trigger at least one listener.
This is similar to hasEventListener, but it searches the entire event flow for a listener, not just this object.
Parameters:
-
typeStringThe string type of the event.
Returns:
Returns true if there is at least one listener for the specified event.
Properties
_dispatchAnimationEnd
Function
private
Dispatches the "animationend" event. Returns true if a handler changed the animation (ex. calling stop, gotoAndPlay, etc.)
_skipAdvance
Boolean
protected
Skips the next auto advance. Used by gotoAndPlay to avoid immediately jumping to the next frame
Default: false
_webGLRenderStyle
Number
protected
Where StageGL should look for required display properties, matters only for leaf display objects. Containers or cached objects won't use this property, it's for native display of terminal elements.
Default: 0
alpha
Number
The alpha (transparency) for this display object. 0 is fully transparent, 1 is fully opaque.
Default: 1
bitmapCache
BitmapCache
readonly
If a cache has been made, this returns the class that is managing the cacheCanvas and its properties. See BitmapCache for more information. Use this to control, inspect, and change the cache. In special circumstances this may be a modified or subclassed BitmapCache.
Default: null
cacheCanvas
HTMLCanvasElement | Object
readonly
If a cache is active, this returns the canvas that holds the image of this display object. See cache for more information. Use this to display the result of a cache. This will be a HTMLCanvasElement unless special cache rules have been deliberately enabled for this cache.
Default: null
cacheID
Number
deprecated
Returns an ID number that uniquely identifies the current cache for this display object. This can be used to determine if the cache has changed since a previous check. Moved to BitmapCache
Default: 0
compositeOperation
String
The composite operation indicates how the pixels of this display object will be composited with the elements
behind it. If null, this property is inherited from the parent container. For more information, read the
whatwg spec on compositing. For a list of supported compositeOperation value, visit
the W3C draft on Compositing and Blending.
Default: null
currentAnimationFrame
Number
Specifies the current frame index within the currently playing animation. When playing normally, this will increase from 0 to n-1, where n is the number of frames in the current animation.
This could be a non-integer value if using time-based playback (see Sprite/framerate, or if the animation's speed is not an integer.
Default: 0
currentFrame
Number
readonly
The frame index that will be drawn when draw is called. Note that with some SpriteSheet definitions, this will advance non-sequentially. This will always be an integer value.
Default: 0
cursor
String
A CSS cursor (ex. "pointer", "help", "text", etc) that will be displayed when the user hovers over this display object. You must enable mouseover events using the enableMouseOver method to use this property. Setting a non-null cursor on a Container will override the cursor set on its descendants.
Default: null
filters
Array
An array of Filter objects to apply to this display object. Filters are only applied / updated when Cache or UpdateCache is called on the display object, and only apply to the area that is cached.
Default: null
framerate
Number
By default Sprite instances advance one frame per tick. Specifying a framerate for the Sprite (or its related SpriteSheet) will cause it to advance based on elapsed time between ticks as appropriate to maintain the target framerate.
For example, if a Sprite with a framerate of 10 is placed on a Stage being updated at 40fps, then the Sprite will advance roughly one frame every 4 ticks. This will not be exact, because the time between each tick will vary slightly between frames.
This feature is dependent on the tick event object (or an object with an appropriate "delta" property) being passed into update.
Default: 0
hitArea
DisplayObject
A display object that will be tested when checking mouse interactions or testing getObjectsUnderPoint.
The hit area will have its transformation applied relative to this display object's coordinate space (as though
the hit test object were a child of this display object and relative to its regX/Y). The hitArea will be tested
using only its own alpha value regardless of the alpha value on the target display object, or the target's
ancestors (parents).
If set on a Container, children of the Container will not receive mouse events. This is similar to setting MouseChildren to false.
Note that hitArea is NOT currently used by the hitTest() method, nor is it supported for Stage.
Default: null
id
Number
Unique ID for this display object. Makes display objects easier for some uses.
Default: -1
mask
Shape
A Shape instance that defines a vector mask (clipping path) for this display object. The shape's transformation will be applied relative to the display object's parent coordinates (as if it were a child of the parent).
Default: null
mouseEnabled
Boolean
Indicates whether to include this object when running mouse interactions. Setting this to false for children
of a Container will cause events on the Container to not fire when that child is
clicked. Setting this property to false does not prevent the getObjectsUnderPoint
method from returning the child.
Note: In EaselJS 0.7.0, the mouseEnabled property will not work properly with nested Containers. Please check out the latest NEXT version in GitHub for an updated version with this issue resolved. The fix will be provided in the next release of EaselJS.
Default: true
name
String
An optional name for this display object. Included in toString . Useful for debugging.
Default: null
parent
Container
final
readonly
A reference to the Container or Stage object that contains this display object, or null if it has not been added to one.
Default: null
paused
Boolean
Prevents the animation from advancing each tick automatically. For example, you could create a sprite
sheet of icons, set paused to true, and display the appropriate icon by setting currentFrame.
Default: false
regX
Number
The left offset for this display object's registration point. For example, to make a 100x100px Bitmap rotate around its center, you would set regX and regY to 50. Cached object's registration points should be set based on pre-cache conditions, not cached size.
Default: 0
regY
Number
The y offset for this display object's registration point. For example, to make a 100x100px Bitmap rotate around its center, you would set regX and regY to 50. Cached object's registration points should be set based on pre-cache conditions, not cached size.
Default: 0
scale
Number
Set both the scaleX and the scaleY
property to the same value. Note that when you get the value, if the scaleX and scaleY are different values,
it will return only the scaleX.
Default: 1
scaleX
Number
The factor to stretch this display object horizontally. For example, setting scaleX to 2 will stretch the display object to twice its nominal width. To horizontally flip an object, set the scale to a negative number.
Default: 1
scaleY
Number
The factor to stretch this display object vertically. For example, setting scaleY to 0.5 will stretch the display object to half its nominal height. To vertically flip an object, set the scale to a negative number.
Default: 1
shadow
Shadow
A shadow object that defines the shadow to render on this display object. Set to null to remove a shadow. If
null, this property is inherited from the parent container.
Default: null
snapToPixel
Boolean
Indicates whether the display object should be drawn to a whole pixel when snapToPixelEnabled is true. To enable/disable snapping on whole categories of display objects, set this value on the prototype (Ex. Text.prototype.snapToPixel = true).
Default: true
spriteSheet
SpriteSheet
readonly
The SpriteSheet instance to play back. This includes the source image, frame dimensions, and frame data. See SpriteSheet for more information.
stage
Stage
readonly
Returns the Stage instance that this display object will be rendered on, or null if it has not been added to one.
tickEnabled
Boolean
If false, the tick will not run on this display object (or its children). This can provide some performance benefits. In addition to preventing the "tick" event from being dispatched, it will also prevent tick related updates on some display objects (ex. Sprite & MovieClip frame advancing, and DOMElement display properties).
Default: true
transformMatrix
Matrix2D
If set, defines the transformation for this display object, overriding all other transformation properties (x, y, rotation, scale, skew).
Default: null
visible
Boolean
Indicates whether this display object should be rendered to the canvas and included when running the Stage getObjectsUnderPoint method.
Default: true
Events
added
Dispatched when the display object is added to a parent container.
animationend
Dispatched when an animation reaches its ends.
change
Dispatched any time the current frame changes. For example, this could be due to automatic advancement on a tick, or calling gotoAndPlay() or gotoAndStop().
click
Dispatched when the user presses their left mouse button and then releases it while over the display object. See the MouseEvent class for a listing of event properties.
dblclick
Dispatched when the user double clicks their left mouse button over this display object. See the MouseEvent class for a listing of event properties.
mousedown
Dispatched when the user presses their left mouse button over the display object. See the MouseEvent class for a listing of event properties.
mouseout
Dispatched when the user's mouse leaves this display object. This event must be enabled using enableMouseOver. See also rollout. See the MouseEvent class for a listing of event properties.
mouseover
Dispatched when the user's mouse enters this display object. This event must be enabled using enableMouseOver. See also rollover. See the MouseEvent class for a listing of event properties.
pressmove
After a mousedown occurs on a display object, a pressmove event will be generated on that object whenever the mouse moves until the mouse press is released. This can be useful for dragging and similar operations.
Please note that if the initial mouse target from a mousedown event is removed from the stage after being pressed
(e.g. during a pressmove event), a pressmove event is still generated. However since it is no longer in the
display list, the event can not bubble. This means that previous ancestors (parent containers) will not receive
the event, and therefore can not re-dispatch it. If you intend to listen for pressup
or pressmove on a dynamic object (such as a MovieClip or Container),
then ensure you set mouseChildren to false.
pressup
After a mousedown occurs on a display object, a pressup event will be generated on that object when that mouse press is released. This can be useful for dragging and similar operations.
Please note that if the initial mouse target from a mousedown event is removed from the stage after being pressed
(e.g. during a pressmove event), a pressup event is still generated. However since it is no longer in the
display list, the event can not bubble. This means that previous ancestors (parent containers) will not receive
the event, and therefore can not re-dispatch it. If you intend to listen for pressmove
or pressup on a dynamic object (such as a MovieClip or Container),
then ensure you set mouseChildren to false.
removed
Dispatched when the display object is removed from its parent container.
rollout
This event is similar to mouseout, with the following differences: it does not bubble, and it considers Container instances as an aggregate of their content.
For example, myContainer contains two overlapping children: shapeA and shapeB. The user moves their mouse over shapeA, then directly on to shapeB, then off both. With a listener for Mouseout:event on myContainer, two events would be received, each targeting a child element:
- when the mouse leaves shapeA (target=shapeA)
- when the mouse leaves shapeB (target=shapeB)
This event must be enabled using enableMouseOver. See the MouseEvent class for a listing of event properties.
rollover
This event is similar to mouseover, with the following differences: it does not bubble, and it considers Container instances as an aggregate of their content.
For example, myContainer contains two overlapping children: shapeA and shapeB. The user moves their mouse over shapeA and then directly on to shapeB. With a listener for Mouseover:event on myContainer, two events would be received, each targeting a child element:
- when the mouse enters shapeA (target=shapeA)
- when the mouse enters shapeB (target=shapeB)
This event must be enabled using enableMouseOver. See the MouseEvent class for a listing of event properties.
tick
Dispatched on each display object on a stage whenever the stage updates. This occurs immediately before the rendering (draw) pass. When update is called, first all display objects on the stage dispatch the tick event, then all of the display objects are drawn to stage. Children will have their Tick:event event dispatched in order of their depth prior to the event being dispatched on their parent.