@awayjs/scene

import { Transform, Matrix3D, Rectangle, Vector3D, AssetBase, Loader } from '@awayjs/core'; import { BlendMode } from '@awayjs/stage'; import { BoundingVolumeType, IEntity, BoundsPicker, HierarchicalProperty, AlignmentMode, OrientationMode, IContainer, ContainerNode } from '@awayjs/view'; import { IMaterial, Style, StyleEvent } from '@awayjs/renderer'; import { DisplayObjectContainer } from './DisplayObjectContainer'; import { ControllerBase } from '../controllers/ControllerBase'; import { IBitmapDrawable } from '../base/IBitmapDrawable'; import { IFilter } from '../adapters/IFilter'; /** * The DisplayObject class is the base class for all objects that can be * placed on the display list. The display list manages all objects displayed * in flash. Use the DisplayObjectContainer class to arrange the * display objects in the display list. DisplayObjectContainer objects can * have child display objects, while other display objects, such as Shape and * TextField objects, are "leaf" nodes that have only parents and siblings, no * children. * * The DisplayObject class supports fbasic functionality like the x * and y position of an object, as well as more advanced properties of * the object such as its transformation matrix. * * DisplayObject is an abstract base class; therefore, you cannot call * DisplayObject directly. Invoking <code>new DisplayObject()</code> throws an * <code>ArgumentError</code> exception. * * All display objects inherit from the DisplayObject class. * * The DisplayObject class itself does not include any APIs for rendering * content onscreen. For that reason, if you want create a custom subclass of * the DisplayObject class, you will want to extend one of its subclasses that * do have APIs for rendering content onscreen, such as the Shape, Sprite, * Bitmap, SimpleButton, TextField, or MovieClip class. * * The DisplayObject class contains several broadcast events. Normally, the * target of any particular event is a specific DisplayObject instance. For * example, the target of an <code>added</code> event is the specific * DisplayObject instance that was added to the display list. Having a single * target restricts the placement of event listeners to that target and in * some cases the target's ancestors on the display list. With broadcast * events, however, the target is not a specific DisplayObject instance, but * rather all DisplayObject instances, including those that are not on the * display list. This means that you can add a listener to any DisplayObject * instance to listen for broadcast events. In addition to the broadcast * events listed in the DisplayObject class's Events table, the DisplayObject * class also inherits two broadcast events from the EventDispatcher class: * <code>activate</code> and <code>deactivate</code>. * * Some properties previously used in the ActionScript 1.0 and 2.0 * MovieClip, TextField, and Button classes(such as <code>_alpha</code>, * <code>_height</code>, <code>_pName</code>, <code>_width</code>, * <code>_x</code>, <code>_y</code>, and others) have equivalents in the * ActionScript 3.0 DisplayObject class that are renamed so that they no * longer begin with the underscore(_) character. * * For more information, see the "Display Programming" chapter of the * ActionScript 3.0 Developer's Guide. * * @event added Dispatched when a display object is added to the * display list. The following methods trigger this * event: * <code>DisplayObjectContainer.addChild()</code>, * <code>DisplayObjectContainer.addChildAt()</code>. * @event addedToScene Dispatched when a display object is added to the on * scene display list, either directly or through the * addition of a sub tree in which the display object * is contained. The following methods trigger this * event: * <code>DisplayObjectContainer.addChild()</code>, * <code>DisplayObjectContainer.addChildAt()</code>. * @event enterFrame [broadcast event] Dispatched when the playhead is * entering a new frame. If the playhead is not * moving, or if there is only one frame, this event * is dispatched continuously in conjunction with the * frame rate. This event is a broadcast event, which * means that it is dispatched by all display objects * with a listener registered for this event. * @event exitFrame [broadcast event] Dispatched when the playhead is * exiting the current frame. All frame scripts have * been run. If the playhead is not moving, or if * there is only one frame, this event is dispatched * continuously in conjunction with the frame rate. * This event is a broadcast event, which means that * it is dispatched by all display objects with a * listener registered for this event. * @event frameConstructed [broadcast event] Dispatched after the constructors * of frame display objects have run but before frame * scripts have run. If the playhead is not moving, or * if there is only one frame, this event is * dispatched continuously in conjunction with the * frame rate. This event is a broadcast event, which * means that it is dispatched by all display objects * with a listener registered for this event. * @event removed Dispatched when a display object is about to be * removed from the display list. Two methods of the * DisplayObjectContainer class generate this event: * <code>removeChild()</code> and * <code>removeChildAt()</code>. * * The following methods of a * DisplayObjectContainer object also generate this * event if an object must be removed to make room for * the new object: <code>addChild()</code>, * <code>addChildAt()</code>, and * <code>setChildIndex()</code>. * @event removedFromScene Dispatched when a display object is about to be * removed from the display list, either directly or * through the removal of a sub tree in which the * display object is contained. Two methods of the * DisplayObjectContainer class generate this event: * <code>removeChild()</code> and * <code>removeChildAt()</code>. * * The following methods of a * DisplayObjectContainer object also generate this * event if an object must be removed to make room for * the new object: <code>addChild()</code>, * <code>addChildAt()</code>, and * <code>setChildIndex()</code>. * @event render [broadcast event] Dispatched when the display list * is about to be updated and rendered. This event * provides the last opportunity for objects listening * for this event to make changes before the display * list is rendered. You must call the * <code>invalidate()</code> method of the Scene * object each time you want a <code>render</code> * event to be dispatched. <code>Render</code> events * are dispatched to an object only if there is mutual * trust between it and the object that called * <code>Scene.invalidate()</code>. This event is a * broadcast event, which means that it is dispatched * by all display objects with a listener registered * for this event. * * Note: This event is not dispatched if the * display is not rendering. This is the case when the * content is either minimized or obscured. */ export declare class DisplayObject extends AssetBase implements IBitmapDrawable, IContainer { private _mouseChildren; _material: IMaterial; _style: Style; private _loader; private _mouseX; private _mouseY; private _root; private _boundsVisible; private _boundsPrefab; private _boundsPrefabDirty; private _boundsPrimitive; private _pName; private _scrollRect; private _scrollRectPrimitive; private _scrollRectPrimitiveDirty; protected _parent: DisplayObjectContainer; _sessionID: number; _avmDepthID: number; pickObjectFromTimeline: boolean; private _alignmentMode; private _scale9Grid; protected _transform: Transform; private _visible; private _maskId; protected _masks: DisplayObject[]; protected _scriptMask: DisplayObject; private _mouseEnabled; private _eulers; _registrationMatrix3D: Matrix3D; private _defaultBoundingVolume; cursorType: string; protected _isInFocus: boolean; protected _tabEnabled: boolean; protected _tabIndex: number; private _maskMode; private _pickObject; _hierarchicalPropsDirty: number; private _onInvalidatePropertiesDelegate; private _onInvalidateImagesDelegate; isSlice9ScaledMC: boolean; isSlice9ScaledSprite: boolean; avm1Symbol: any; isAVMScene: boolean; placeObjectTag: any; getScriptPrecedence(): number[]; getMouseCursor(): string; get tabEnabled(): boolean; set tabEnabled(value: boolean); get tabIndex(): number; set tabIndex(value: number); get isInFocus(): boolean; set isInFocus(value: boolean); setFocus(value: boolean, fromMouseDown?: boolean, sendSoftKeyEvent?: boolean): void; /** * */ get alignmentMode(): AlignmentMode; set alignmentMode(value: AlignmentMode); /** * Indicates the alpha transparency value of the object specified. Valid * values are 0(fully transparent) to 1(fully opaque). The default value is * 1. Display objects with <code>alpha</code> set to 0 are active, * even though they are invisible. */ get alpha(): number; set alpha(value: number); /** * A value from the BlendMode class that specifies which blend mode to use. A * bitmap can be drawn internally in two ways. If you have a blend mode * enabled or an external clipping mask, the bitmap is drawn by adding a * bitmap-filled square shape to the vector render. If you attempt to set * this property to an invalid value, Flash runtimes set the value to * <code>BlendMode.NORMAL</code>. * * The <code>blendMode</code> property affects each pixel of the display * object. Each pixel is composed of three constituent colors(red, green, * and blue), and each constituent color has a value between 0x00 and 0xFF. * Flash Player or Adobe AIR compares each constituent color of one pixel in * the movie clip with the corresponding color of the pixel in the * background. For example, if <code>blendMode</code> is set to * <code>BlendMode.LIGHTEN</code>, Flash Player or Adobe AIR compares the red * value of the display object with the red value of the background, and uses * the lighter of the two as the value for the red component of the displayed * color. * * The following table describes the <code>blendMode</code> settings. The * BlendMode class defines string values you can use. The illustrations in * the table show <code>blendMode</code> values applied to a circular display * object(2) superimposed on another display object(1). */ _blendMode: BlendMode; set blendMode(v: BlendMode); get blendMode(): BlendMode; /** * */ get defaultBoundingVolume(): BoundingVolumeType; set defaultBoundingVolume(value: BoundingVolumeType); /** * If set to <code>true</code>, NME will use the software renderer to cache * an internal bitmap representation of the display object. For native targets, * this is often much slower than the default hardware renderer. When you * are using the Flash target, this caching may increase performance for display * objects that contain complex vector content. * * All vector data for a display object that has a cached bitmap is drawn * to the bitmap instead of the main display. If * <code>cacheAsBitmapMatrix</code> is null or unsupported, the bitmap is * then copied to the main display as unstretched, unrotated pixels snapped * to the nearest pixel boundaries. Pixels are mapped 1 to 1 with the parent * object. If the bounds of the bitmap change, the bitmap is recreated * instead of being stretched. * * If <code>cacheAsBitmapMatrix</code> is non-null and supported, the * object is drawn to the off-screen bitmap using that matrix and the * stretched and/or rotated results of that rendering are used to draw the * object to the main display. * * No internal bitmap is created unless the <code>BBitmap</code> * property is set to <code>true</code>. * * After you set the <code>cacheAsBitmap</code> property to * <code>true</code>, the rendering does not change, however the display * object performs pixel snapping automatically. The animation speed can be * significantly faster depending on the complexity of the vector content. * * * The <code>cacheAsBitmap</code> property is automatically set to * <code>true</code> whenever you apply a filter to a display object(when * its <code>filter</code> array is not empty), and if a display object has a * filter applied to it, <code>cacheAsBitmap</code> is reported as * <code>true</code> for that display object, even if you set the property to * <code>false</code>. If you clear all filters for a display object, the * <code>cacheAsBitmap</code> setting changes to what it was last set to. * * A display object does not use a bitmap even if the * <code>cacheAsBitmap</code> property is set to <code>true</code> and * instead renders from vector data in the following cases: * * <ul> * <li>The bitmap is too large. In AIR 1.5 and Flash Player 10, the maximum * size for a bitmap image is 8,191 pixels in width or height, and the total * number of pixels cannot exceed 16,777,215 pixels.(So, if a bitmap image * is 8,191 pixels wide, it can only be 2,048 pixels high.) In Flash Player 9 * and earlier, the limitation is is 2880 pixels in height and 2,880 pixels * in width.</li> * <li>The bitmap fails to allocate(out of memory error). </li> * </ul> * * The <code>cacheAsBitmap</code> property is best used with movie clips * that have mostly static content and that do not scale and rotate * frequently. With such movie clips, <code>cacheAsBitmap</code> can lead to * performance increases when the movie clip is translated(when its x * and y position is changed). */ private _bitmapCache; get cacheAsBitmap(): boolean; set cacheAsBitmap(v: boolean); /** * */ castsShadows: boolean; /** * Defines the rotation of the 3d object as a <code>Vector3D</code> * object containing euler angles for rotation around x, y and z axis. */ get eulers(): Vector3D; set eulers(value: Vector3D); /** * An object that can contain any extra data. */ extra: Object; /** * An indexed array that contains each filter object currently associated * with the display object. The flash.filters package contains several * classes that define specific filters you can use. * * Filters can be applied in Flash Professional at design time, or at run * time by using ActionScript code. To apply a filter by using ActionScript, * you must make a temporary copy of the entire <code>filters</code> array, * modify the temporary array, then assign the value of the temporary array * back to the <code>filters</code> array. You cannot directly add a new * filter object to the <code>filters</code> array. * * To add a filter by using ActionScript, perform the following steps * (assume that the target display object is named * <code>myDisplayObject</code>): * * <ol> * <li>Create a new filter object by using the constructor method of your * chosen filter class.</li> * <li>Assign the value of the <code>myDisplayObject.filters</code> array * to a temporary array, such as one named <code>myFilters</code>.</li> * <li>Add the new filter object to the <code>myFilters</code> temporary * array.</li> * <li>Assign the value of the temporary array to the * <code>myDisplayObject.filters</code> array.</li> * </ol> * * If the <code>filters</code> array is undefined, you do not need to use * a temporary array. Instead, you can directly assign an array literal that * contains one or more filter objects that you create. The first example in * the Examples section adds a drop shadow filter by using code that handles * both defined and undefined <code>filters</code> arrays. * * To modify an existing filter object, you must use the technique of * modifying a copy of the <code>filters</code> array: * * <ol> * <li>Assign the value of the <code>filters</code> array to a temporary * array, such as one named <code>myFilters</code>.</li> * <li>Modify the property by using the temporary array, * <code>myFilters</code>. For example, to set the quality property of the * first filter in the array, you could use the following code: * <code>myFilters[0].quality = 1;</code></li> * <li>Assign the value of the temporary array to the <code>filters</code> * array.</li> * </ol> * * At load time, if a display object has an associated filter, it is * marked to cache itself as a transparent bitmap. From this point forward, * as long as the display object has a valid filter list, the player caches * the display object as a bitmap. This source bitmap is used as a source * image for the filter effects. Each display object usually has two bitmaps: * one with the original unfiltered source display object and another for the * final image after filtering. The final image is used when rendering. As * long as the display object does not change, the final image does not need * updating. * * The flash.filters package includes classes for filters. For example, to * create a DropShadow filter, you would write: * * @throws ArgumentError When <code>filters</code> includes a ShaderFilter * and the shader output type is not compatible with * this operation(the shader must specify a * <code>pixel4</code> output). * @throws ArgumentError When <code>filters</code> includes a ShaderFilter * and the shader doesn't specify any image input or * the first input is not an <code>image4</code> input. * @throws ArgumentError When <code>filters</code> includes a ShaderFilter * and the shader specifies an image input that isn't * provided. * @throws ArgumentError When <code>filters</code> includes a ShaderFilter, a * ByteArray or Vector.<Number> instance as a shader * input, and the <code>width</code> and * <code>height</code> properties aren't specified for * the ShaderInput object, or the specified values * don't match the amount of data in the input data. * See the <code>ShaderInput.input</code> property for * more information. */ private _filters; set filters(v: Array<IFilter>); get filters(): Array<IFilter>; updateFilters(_newFilters: IFilter[]): void; /** * Indicates the instance container index of the DisplayObject. The object can be * identified in the child list of its parent display object container by * calling the <code>getChildByIndex()</code> method of the display object * container. * * If the DisplayObject has no parent container, index defaults to 0. */ get index(): number; /** * Returns a LoaderInfo object containing information about loading the file * to which this display object belongs. The <code>loaderInfo</code> property * is defined only for the root display object of a SWF file or for a loaded * Bitmap(not for a Bitmap that is drawn with ActionScript). To find the * <code>loaderInfo</code> object associated with the SWF file that contains * a display object named <code>myDisplayObject</code>, use * <code>myDisplayObject.root.loaderInfo</code>. * * A large SWF file can monitor its download by calling * <code>this.root.loaderInfo.addEventListener(Event.COMPLETE, * func)</code>. */ get loader(): Loader; /** * The calling display object is masked by the specified <code>mask</code> * object. To ensure that masking works when the Stage is scaled, the * <code>mask</code> display object must be in an active part of the display * list. The <code>mask</code> object itself is not drawn. Set * <code>mask</code> to <code>null</code> to remove the mask. * * To be able to scale a mask object, it must be on the display list. To * be able to drag a mask Sprite object(by calling its * <code>startDrag()</code> method), it must be on the display list. To call * the <code>startDrag()</code> method for a mask sprite based on a * <code>mouseDown</code> event being dispatched by the sprite, set the * sprite's <code>buttonMode</code> property to <code>true</code>. * * When display objects are cached by setting the * <code>cacheAsBitmap</code> property to <code>true</code> an the * <code>cacheAsBitmapMatrix</code> property to a Matrix object, both the * mask and the display object being masked must be part of the same cached * bitmap. Thus, if the display object is cached, then the mask must be a * child of the display object. If an ancestor of the display object on the * display list is cached, then the mask must be a child of that ancestor or * one of its descendents. If more than one ancestor of the masked object is * cached, then the mask must be a descendent of the cached container closest * to the masked object in the display list. * * Note: A single <code>mask</code> object cannot be used to mask * more than one calling display object. When the <code>mask</code> is * assigned to a second display object, it is removed as the mask of the * first object, and that object's <code>mask</code> property becomes * <code>null</code>. */ set mask(value: DisplayObject); get maskMode(): boolean; set maskMode(value: boolean); get pickObject(): DisplayObjectContainer; set pickObject(value: DisplayObjectContainer); /** * Specifies whether this object receives mouse, or other user input, * messages. The default value is <code>true</code>, which means that by * default any InteractiveObject instance that is on the display list * receives mouse events or other user input events. If * <code>mouseEnabled</code> is set to <code>false</code>, 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 <code>mouseEnabled</code> behavior for all * children of an object on the display list, use * <code>flash.display.DisplayObjectContainer.mouseChildren</code>. * * No event is dispatched by setting this property. You must use the * <code>addEventListener()</code> method to create interactive * functionality. */ get mouseEnabled(): boolean; set mouseEnabled(value: boolean); /** * Indicates the x coordinate of the mouse or user input device position, in * pixels. * * Note: For a DisplayObject that has been rotated, the returned x * coordinate will reflect the non-rotated object. */ get mouseX(): number; /** * Indicates the y coordinate of the mouse or user input device position, in * pixels. * * Note: For a DisplayObject that has been rotated, the returned y * coordinate will reflect the non-rotated object. */ get mouseY(): number; /** * Indicates the instance name of the DisplayObject. The object can be * identified in the child list of its parent display object container by * calling the <code>getChildByName()</code> method of the display object * container. * * @throws IllegalOperationError If you are attempting to set this property * on an object that was placed on the timeline * in the Flash authoring tool. */ get name(): string; set name(value: string); /** * */ orientationMode: OrientationMode; /** * Indicates the DisplayObjectContainer object that contains this display * object. Use the <code>parent</code> property to specify a relative path to * display objects that are above the current display object in the display * list hierarchy. * * You can use <code>parent</code> to move up multiple levels in the * display list as in the following: * * @throws SecurityError The parent display object belongs to a security * sandbox to which you do not have access. You can * avoid this situation by having the parent movie call * the <code>Security.allowDomain()</code> method. */ get parent(): DisplayObjectContainer; /** * Defines the local point around which the object rotates. */ get registrationPoint(): Vector3D; set registrationPoint(value: Vector3D); /** * Defines the local scale. */ get registrationScale(): Vector3D; set registrationScale(value: Vector3D); /** * For a display object in a loaded SWF file, the <code>root</code> property * is the top-most display object in the portion of the display list's tree * structure represented by that SWF file. For a Bitmap object representing a * loaded image file, the <code>root</code> property is the Bitmap object * itself. For the instance of the main class of the first SWF file loaded, * the <code>root</code> property is the display object itself. The * <code>root</code> property of the Scene object is the Scene object itself. * The <code>root</code> property is set to <code>null</code> for any display * object that has not been added to the display list, unless it has been * added to a display object container that is off the display list but that * is a child of the top-most display object in a loaded SWF file. * * For example, if you create a new Sprite object by calling the * <code>Sprite()</code> constructor method, its <code>root</code> property * is <code>null</code> until you add it to the display list(or to a display * object container that is off the display list but that is a child of the * top-most display object in a SWF file). * * For a loaded SWF file, even though the Loader object used to load the * file may not be on the display list, the top-most display object in the * SWF file has its <code>root</code> property set to itself. The Loader * object does not have its <code>root</code> property set until it is added * as a child of a display object for which the <code>root</code> property is * set. */ get root(): DisplayObjectContainer; /** * Indicates the rotation of the DisplayObject instance, in degrees, from its * original orientation. Values from 0 to 180 represent clockwise rotation; * values from 0 to -180 represent counterclockwise rotation. Values outside * this range are added to or subtracted from 360 to obtain a value within * the range. For example, the statement <code>my_video.rotation = 450</code> * is the same as <code> my_video.rotation = 90</code>. */ rotation: number; /** * Indicates the x-axis rotation of the DisplayObject instance, in degrees, * from its original orientation relative to the 3D parent container. Values * from 0 to 180 represent clockwise rotation; values from 0 to -180 * represent counterclockwise rotation. Values outside this range are added * to or subtracted from 360 to obtain a value within the range. */ get rotationX(): number; set rotationX(val: number); /** * Indicates the y-axis rotation of the DisplayObject instance, in degrees, * from its original orientation relative to the 3D parent container. Values * from 0 to 180 represent clockwise rotation; values from 0 to -180 * represent counterclockwise rotation. Values outside this range are added * to or subtracted from 360 to obtain a value within the range. */ get rotationY(): number; set rotationY(val: number); /** * Indicates the z-axis rotation of the DisplayObject instance, in degrees, * from its original orientation relative to the 3D parent container. Values * from 0 to 180 represent clockwise rotation; values from 0 to -180 * represent counterclockwise rotation. Values outside this range are added * to or subtracted from 360 to obtain a value within the range. */ get rotationZ(): number; set rotationZ(val: number); /** * The current scaling grid that is in effect. If set to <code>null</code>, * the entire display object is scaled normally when any scale transformation * is applied. * * When you define the <code>scale9Grid</code> property, the display * object is divided into a grid with nine regions based on the * <code>scale9Grid</code> rectangle, which defines the center region of the * grid. The eight other regions of the grid are the following areas: * * <ul> * <li>The upper-left corner outside of the rectangle</li> * <li>The area above the rectangle </li> * <li>The upper-right corner outside of the rectangle</li> * <li>The area to the left of the rectangle</li> * <li>The area to the right of the rectangle</li> * <li>The lower-left corner outside of the rectangle</li> * <li>The area below the rectangle</li> * <li>The lower-right corner outside of the rectangle</li> * </ul> * * You can think of the eight regions outside of the center(defined by * the rectangle) as being like a picture frame that has special rules * applied to it when scaled. * * When the <code>scale9Grid</code> property is set and a display object * is scaled, all text and gradients are scaled normally; however, for other * types of objects the following rules apply: * * <ul> * <li>Content in the center region is scaled normally. </li> * <li>Content in the corners is not scaled. </li> * <li>Content in the top and bottom regions is scaled horizontally only. * Content in the left and right regions is scaled vertically only.</li> * <li>All fills(including bitmaps, video, and gradients) are stretched to * fit their shapes.</li> * </ul> * * If a display object is rotated, all subsequent scaling is normal(and * the <code>scale9Grid</code> property is ignored). * * For example, consider the following display object and a rectangle that * is applied as the display object's <code>scale9Grid</code>: * * A common use for setting <code>scale9Grid</code> is to set up a display * object to be used as a component, in which edge regions retain the same * width when the component is scaled. * * @throws ArgumentError If you pass an invalid argument to the method. */ get scale9Grid(): Rectangle; set scale9Grid(value: Rectangle); /** * Indicates the horizontal scale(percentage) of the object as applied from * the registration point. The default registration point is(0,0). 1.0 * equals 100% scale. * * Scaling the local coordinate system changes the <code>x</code> and * <code>y</code> property values, which are defined in whole pixels. */ get scaleX(): number; set scaleX(val: number); /** * Indicates the vertical scale(percentage) of an object as applied from the * registration point of the object. The default registration point is(0,0). * 1.0 is 100% scale. * * Scaling the local coordinate system changes the <code>x</code> and * <code>y</code> property values, which are defined in whole pixels. */ get scaleY(): number; set scaleY(val: number); /** * Indicates the depth scale(percentage) of an object as applied from the * registration point of the object. The default registration point is(0,0). * 1.0 is 100% scale. * * Scaling the local coordinate system changes the <code>x</code>, * <code>y</code> and <code>z</code> property values, which are defined in * whole pixels. */ get scaleZ(): number; set scaleZ(val: number); /** * Indicates the horizontal skew(angle) of the object as applied from * the registration point. The default registration point is(0,0). */ get skewX(): number; set skewX(val: number); /** * Indicates the vertical skew(angle) of an object as applied from the * registration point of the object. The default registration point is(0,0). */ get skewY(): number; set skewY(val: number); /** * Indicates the depth skew(angle) of an object as applied from the * registration point of the object. The default registration point is(0,0). */ get skewZ(): number; set skewZ(val: number); /** * The scroll rectangle bounds of the display object. The display object is * cropped to the size defined by the rectangle, and it scrolls within the * rectangle when you change the <code>x</code> and <code>y</code> properties * of the <code>scrollRect</code> object. * * The properties of the <code>scrollRect</code> Rectangle object use the * display object's coordinate space and are scaled just like the overall * display object. The corner bounds of the cropped window on the scrolling * display object are the origin of the display object(0,0) and the point * defined by the width and height of the rectangle. They are not centered * around the origin, but use the origin to define the upper-left corner of * the area. A scrolled display object always scrolls in whole pixel * increments. * * You can scroll an object left and right by setting the <code>x</code> * property of the <code>scrollRect</code> Rectangle object. You can scroll * an object up and down by setting the <code>y</code> property of the * <code>scrollRect</code> Rectangle object. If the display object is rotated * 90° and you scroll it left and right, the display object actually scrolls * up and down. */ get scrollRect(): Rectangle; set scrollRect(value: Rectangle); /** * */ get material(): IMaterial; set material(value: IMaterial); /** * */ get style(): Style; set style(value: Style); /** * */ get boundsVisible(): boolean; set boundsVisible(value: boolean); getScrollRectPrimitive(): IContainer; getBoundsPrimitive(picker: BoundsPicker): IContainer; /** * An object with properties pertaining to a display object's matrix, color * transform, and pixel bounds. The specific properties - matrix, * colorTransform, and three read-only properties * (<code>concatenatedMatrix</code>, <code>concatenatedColorTransform</code>, * and <code>pixelBounds</code>) - are described in the entry for the * Transform class. * * Each of the transform object's properties is itself an object. This * concept is important because the only way to set new values for the matrix * or colorTransform objects is to create a new object and copy that object * into the transform.matrix or transform.colorTransform property. * * For example, to increase the <code>tx</code> value of a display * object's matrix, you must make a copy of the entire matrix object, then * copy the new object into the matrix property of the transform object: * <pre xml:space="preserve"><code> public myMatrix:Matrix = * myDisplayObject.transform.matrix; myMatrix.tx += 10; * myDisplayObject.transform.matrix = myMatrix; </code></pre> * * You cannot directly set the <code>tx</code> property. The following * code has no effect on <code>myDisplayObject</code>: * <pre xml:space="preserve"><code> myDisplayObject.transform.matrix.tx += * 10; </code></pre> * * You can also copy an entire transform object and assign it to another * display object's transform property. For example, the following code * copies the entire transform object from <code>myOldDisplayObj</code> to * <code>myNewDisplayObj</code>: * <code>myNewDisplayObj.transform = myOldDisplayObj.transform;</code> * * The resulting display object, <code>myNewDisplayObj</code>, now has the * same values for its matrix, color transform, and pixel bounds as the old * display object, <code>myOldDisplayObj</code>. * * Note that AIR for TV devices use hardware acceleration, if it is * available, for color transforms. */ get transform(): Transform; /** * Whether or not the display object is visible. Display objects that are not * visible are disabled. For example, if <code>visible=false</code> for an * InteractiveObject instance, it cannot be clicked. */ get visible(): boolean; set visible(value: boolean); private _mergeMasks; private _setMasks; /** * * @param mask Masked element, that can be used from script without corruption of timeline mask */ set scriptMask(mask: DisplayObject | null); get scriptMask(): DisplayObject | null; /** * Update mask from timeline and take account that can be a scriptMask * * @param masks Masks from timeline */ updateTimelineMask(masks: DisplayObject[] | null): void; get masks(): Array<DisplayObject>; /** * @dangerous Note that we should not use this setter, right way to use `scriptMask` and `updateTimelineMask` * @param value */ set masks(value: Array<DisplayObject>); /** * Determines whether or not the children of the object are mouse, or user * input device, enabled. If an object is enabled, a user can interact with * it by using a mouse or user input device. The default is * <code>true</code>. * * This property is useful when you create a button with an instance of * the Sprite class(instead of using the SimpleButton class). When you use a * Sprite instance to create a button, you can choose to decorate the button * by using the <code>addChild()</code> method to add additional Sprite * instances. This process can cause unexpected behavior with mouse events * because the Sprite instances you add as children can become the target * object of a mouse event when you expect the parent instance to be the * target object. To ensure that the parent instance serves as the target * objects for mouse events, you can set the <code>mouseChildren</code> * property of the parent instance to <code>false</code>. * * No event is dispatched by setting this property. You must use the * <code>addEventListener()</code> method to create interactive * functionality. */ get mouseChildren(): boolean; set mouseChildren(value: boolean); /** * Indicates the x coordinate of the DisplayObject instance relative * to the local coordinates of the parent DisplayObjectContainer. If the * object is inside a DisplayObjectContainer that has transformations, it is * in the local coordinate system of the enclosing DisplayObjectContainer. * Thus, for a DisplayObjectContainer rotated 90° counterclockwise, the * DisplayObjectContainer's children inherit a coordinate system that is * rotated 90° counterclockwise. The object's coordinates refer to the * registration point position. */ get x(): number; set x(val: number); /** * Indicates the y coordinate of the DisplayObject instance relative * to the local coordinates of the parent DisplayObjectContainer. If the * object is inside a DisplayObjectContainer that has transformations, it is * in the local coordinate system of the enclosing DisplayObjectContainer. * Thus, for a DisplayObjectContainer rotated 90° counterclockwise, the * DisplayObjectContainer's children inherit a coordinate system that is * rotated 90° counterclockwise. The object's coordinates refer to the * registration point position. */ get y(): number; set y(val: number); /** * Indicates the z coordinate position along the z-axis of the DisplayObject * instance relative to the 3D parent container. The z property is used for * 3D coordinates, not screen or pixel coordinates. * * When you set a <code>z</code> property for a display object to * something other than the default value of <code>0</code>, a corresponding * Matrix3D object is automatically created. for adjusting a display object's * position and orientation in three dimensions. When working with the * z-axis, the existing behavior of x and y properties changes from screen or * pixel coordinates to positions relative to the 3D parent container. * * For example, a child of the <code>_root</code> at position x = 100, y = * 100, z = 200 is not drawn at pixel location(100,100). The child is drawn * wherever the 3D projection calculation puts it. The calculation is: * * <code>(x~~cameraFocalLength/cameraRelativeZPosition, * y~~cameraFocalLength/cameraRelativeZPosition)</code> */ get z(): number; set z(val: number); /** * */ zOffset: number; /** * Creates a new <code>DisplayObject</code> instance. */ constructor(); advanceFrame(): void; getEntity(): IEntity; _initNode(node: ContainerNode): void; /** * */ clone(): DisplayObject; copyTo(displayObject: DisplayObject): void; /** * */ dispose(): void; disposeValues(): void; /** * Rotates the 3d object around to face a point defined relative * to the local coordinates of the parent <code>ObjectContainer3D</code>. * * @param scenePosition The vector defining the point to be looked at * @param upAxis An optional vector used to define the desired * up orientation of the 3d object after rotation has occurred */ lookAt(scenePosition: Vector3D, upAxis?: Vector3D): void; /** * Moves the local point around which the object rotates. * * @param dx The amount of movement along the local x axis. * @param dy The amount of movement along the local y axis. * @param dz The amount of movement along the local z axis. */ movePivot(dx: number, dy: number, dz: number): void; reset(): void; /** * @internal */ _iController: ControllerBase; hasDispatchedAddedToStage: boolean; isOnDisplayList(): boolean; /** * @internal */ _setParent(parent: DisplayObjectContainer): void; _invalidateHierarchicalProperty(propDirty: HierarchicalProperty): void; /** * @internal */ get maskId(): number; protected _setScaleX(val: number): void; protected _setScaleY(val: number): void; protected _setScaleZ(val: number): void; private _updateBoundsPrefab; protected _updateMaskMode(): void; _invalidateMaterial(): void; private _invalidateStyle; invalidateElements(): void; protected _onInvalidateProperties(_event?: StyleEvent): void; protected _onInvalidateImages(_event?: StyleEvent): void; protected _getDefaultBoundingVolume(): BoundingVolumeType; } //# sourceMappingURL=DisplayObject.d.ts.map