flash.displayFrameLabel FrameLabel 对象包含用来指定帧编号及相应标签名称的属性。Object FrameLabel 对象包含用来指定帧编号及相应标签名称的属性。Scene 类包括 labels 属性,该属性是场景的 FrameLabel 对象的数组。 Scene.labelsMovieClip.currentLabelMovieClip.currentSceneMovieClip.scenesMovieClip.gotoAndPlay()MovieClip.gotoAndStop()frame 包含标签的帧编号。int 包含标签的帧编号。 name 标签的名称。String 标签的名称。 InteractiveObject InteractiveObject 类是用户可以使用鼠标、键盘或其他用户输入设备与之交互的所有显示对象的抽象基类。flash.display:DisplayObject InteractiveObject 类是用户可以使用鼠标、键盘或其他用户输入设备与之交互的所有显示对象的抽象基类。

不能直接实例化 InteractiveObject 类。调用 new InteractiveObject() 构造函数会引发 ArgumentError 异常。

InteractiveObject 类本身不包含任何用于在屏幕上呈现内容的 API。要创建 InteractiveObject 类的自定义子类,请扩展具有用于在屏幕上呈现内容的 API 的一种子类,例如 Sprite、SimpleButton、TextField 或 MovieClip 类。

下例使用 InteractiveObjectExample 类,该类再使用 ChildSprite 类来绘制矩形,然后基于各种鼠标事件对该矩形进行操作。执行下列步骤可完成该任务:
  1. InteractiveObjectExample 构造函数中,创建一个名为 child 的 Sprite 类型的 ChildSprite 新对象,该对象调用 ChildSprite 构造函数方法来绘制形状,并为所绘制的形状添加鼠标事件(如以下步骤所示)。child 对象添加至坐标 x = 0, y = 0 处的显示列表顶部。
  2. ChildSprite 类中,声明以后在 draw() 方法和 MouseEvent 方法中使用的 sizeoverSize 属性。
  3. 声明各个相关属性,将背景色设置为橙色,将鼠标经过颜色设置为深黄色,将鼠标按下颜色设置为浅蓝色。
  4. ChildSprite 构造函数中,通过使用 Graphics 类的方法和 draw() 方法绘制一个橙色的正方形。
  5. 构造函数添加四个 MouseEvent 事件侦听器方法:
    • mouseOverHandler:使用深黄色在原始坐标处重绘一个更大的 60 x 60 像素正方形。
    • mouseOutHandler:将正方形恢复至其原始大小和颜色。
    • mouseDownHandler:使用浅蓝色在原始坐标处重绘一个更大的 60 x 60 像素正方形。
    • mouseUpHandler:与 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); } }
softKeyboardDeactivate 在隐藏软键盘之后立即调度。flash.events.SoftKeyboardEvent.SOFT_KEYBOARD_DEACTIVATEflash.events.SoftKeyboardEvent在隐藏软键盘之后立即调度。 在隐藏软键盘之后立即调度。 flash.events.SoftKeyboardEventsoftKeyboardActivate 在放开软键盘之后立即调度。flash.events.SoftKeyboardEvent.SOFT_KEYBOARD_ACTIVATEflash.events.SoftKeyboardEvent在放开软键盘之后立即调度。 在放开软键盘之后立即调度。 flash.events.SoftKeyboardEventsoftKeyboardActivating 在放开软键盘之前立即调度。flash.events.SoftKeyboardEvent.SOFT_KEYBOARD_ACTIVATINGflash.events.SoftKeyboardEvent在放开软键盘之前立即调度。 在放开软键盘之前立即调度。 flash.events.SoftKeyboardEventtextInput 当用户输入一个或多个文本字符时调度。flash.events.TextEvent.TEXT_INPUTflash.events.TextEvent 当用户输入一个或多个文本字符时调度。各种文本输入法都可以生成此事件,包括使用标准键盘、输入法编辑器 (IME)、语音识别系统以及粘贴不带格式设置或样式信息的纯文本的操作。 imeStartComposition 此事件被调度到任何支持使用 IME 进行内联输入的客户端应用程序 flash.events.IMEEvent 此事件被调度到任何支持使用 IME 进行内联输入的客户端应用程序 contextMenu 当用户手势触发 AIR 应用程序中与此交互式对象相关联的上下文菜单时调度。flash.events.MouseEvent.CONTEXT_MENUflash.events.MouseEvent 当用户手势触发 AIR 应用程序中与此交互式对象相关联的上下文菜单时调度。 contextMenunativeDragComplete 当用户释放拖动手势时由拖动启动器 InteractiveObject 调度。flash.events.NativeDragEvent.NATIVE_DRAG_COMPLETEflash.events.NativeDragEvent 当用户释放拖动手势时由拖动启动器 InteractiveObject 调度。

该事件的 dropAction 属性表示由拖动目标对象设置的动作;“none”值 (DragActions.NONE) 表示放置动作被取消或未被接受。

nativeDragComplete 事件处理函数是更新启动显示对象的方便场所,例如,通过从列表中删除一个项目(针对“move”的拖动动作),或通过更改可视属性。

nativeDragUpdate 在拖动操作期间由在 DragManager.doDrag() 调用中指定为拖动启动器的 InteractiveObject 调度。flash.events.NativeDragEvent.NATIVE_DRAG_UPDATEflash.events.NativeDragEvent 在拖动操作期间由在 DragManager.doDrag() 调用中指定为拖动启动器的 InteractiveObject 调度。

Linux 中不调度 nativeDragUpdate 事件。

nativeDragStart 在拖动操作开始时由在 DragManager.doDrag() 调用中指定为拖动启动器的 InteractiveObject 调度。flash.events.NativeDragEvent.NATIVE_DRAG_STARTflash.events.NativeDragEvent 在拖动操作开始时由在 DragManager.doDrag() 调用中指定为拖动启动器的 InteractiveObject 调度。 nativeDragExit 当拖动手势离开其边界时由 InteractiveObject 调度。flash.events.NativeDragEvent.NATIVE_DRAG_EXITflash.events.NativeDragEvent 当拖动手势离开其边界时由 InteractiveObject 调度。 nativeDragDrop 在将拖动对象放置到目标上且已通过对 DragManager.acceptDragDrop() 的调用接受该放置操作时,由目标 InteractiveObject 调度。flash.events.NativeDragEvent.NATIVE_DRAG_DROPflash.events.NativeDragEvent 在将拖动对象放置到目标上且已通过对 DragManager.acceptDragDrop() 的调用接受该放置操作时,由目标 InteractiveObject 调度。

使用事件对象的 clipboard 属性访问放置的数据。

此事件的处理函数应该设置 DragManager.dropAction 属性以向启动器提供有关采取了哪种拖动动作的反馈。如果未设置任何值,DragManager 将从允许动作的列表中选择一个默认值。

nativeDragOver 当拖动手势保持在其边界内时,由 InteractiveObject 持续调度。flash.events.NativeDragEvent.NATIVE_DRAG_OVERflash.events.NativeDragEvent 当拖动手势保持在其边界内时,由 InteractiveObject 持续调度。

鼠标只要移动,就会调度 nativeDragOver 事件。在 Windows 和 Mac 中,即使不移动鼠标,每隔一小段时间也会调度这些事件。

处理 nativeDragOvernativeDragEnter 事件以允许显示对象成为放置目标。

要确定执行调度的显示对象是否能接受放置,请检查该事件对象的 clipboard 属性中数据的适用性,并检查 allowedActions 属性中允许的拖动动作。

nativeDragEnter 当拖动手势进入其边界时由 InteractiveObject 调度。flash.events.NativeDragEvent.NATIVE_DRAG_ENTERflash.events.NativeDragEvent 当拖动手势进入其边界时由 InteractiveObject 调度。

处理 nativeDragEnternativeDragOver 事件以允许显示对象成为放置目标。

要确定执行调度的显示对象是否能接受放置,请检查该事件对象的 clipboard 属性中数据的适用性,并检查 allowedActions 属性中允许的拖动动作。

tabIndexChange 对象的 tabIndex 属性值发生更改时调度。flash.events.Event.TAB_INDEX_CHANGEflash.events.Event 对象的 tabIndex 属性值发生更改时调度。 tabEnabledChange 对象的 tabEnabled 标志发生更改时调度。flash.events.Event.TAB_ENABLED_CHANGEflash.events.Event 对象的 tabEnabled 标志发生更改时调度。 tabChildrenChange 对象的 tabChildren 标志值发生更改时调度。flash.events.Event.TAB_CHILDREN_CHANGEflash.events.Event 对象的 tabChildren 标志值发生更改时调度。 keyUp 用户释放某个键时调度。flash.events.KeyboardEvent.KEY_UPflash.events.KeyboardEvent 用户释放某个键时调度。按键与特定字符之间的映射因设备和操作系统而异。此事件类型是在此类映射发生之后、输入法编辑器 (IME) 处理之前生成的。IME 用于输入标准 QWERTY 键盘无法生成的字符(如中国象形文字)。该事件在 keyDown 事件之后发生,并具备以下特征: keyDown 用户按下某个键时调度。flash.events.KeyboardEvent.KEY_DOWNflash.events.KeyboardEvent 用户按下某个键时调度。按键与特定字符之间的映射因设备和操作系统而异。此事件类型是在此类映射发生之后、输入法编辑器 (IME) 处理之前生成的。IME 用于输入标准 QWERTY 键盘无法生成的字符(如中国象形文字)。该事件在 keyUp 事件之前发生。

在 AIR 中,取消此事件会禁止将字符输入到文本字段中。

rightMouseUp 当用户在 InteractiveObject 实例上释放指针设备按钮时调度。flash.events.MouseEvent.RIGHT_MOUSE_UPflash.events.MouseEvent 当用户在 InteractiveObject 实例上释放指针设备按钮时调度。 rightMouseDown 当用户在 InteractiveObject 实例上按下指针设备按钮时调度。flash.events.MouseEvent.RIGHT_MOUSE_DOWNflash.events.MouseEvent 当用户在 InteractiveObject 实例上按下指针设备按钮时调度。 rightClick 当用户在同一 InteractiveObject 上按下并释放用户指针设备的右按钮时调度。flash.events.MouseEvent.RIGHT_CLICKflash.events.MouseEvent 当用户在同一 InteractiveObject 上按下并释放用户指针设备的右按钮时调度。要使 rightClick 事件发生,该事件必须始终按照发生顺序跟在以下一系列事件之后:rightMouseDown 事件,然后是 rightMouseUp。这两个事件的目标对象必须相同,否则不会发生 rightClick 事件。在 rightMouseDownrightMouseUp 事件之间可以随时发生任意数量的其他鼠标事件;rightClick 事件仍会发生。 middleMouseUp 当用户在 InteractiveObject 实例上释放指针设备按钮时调度。flash.events.MouseEvent.MIDDLE_MOUSE_UPflash.events.MouseEvent 当用户在 InteractiveObject 实例上释放指针设备按钮时调度。 middleMouseDown 当用户在 InteractiveObject 实例上按下指针设备的中间按钮时调度。flash.events.MouseEvent.MIDDLE_MOUSE_DOWNflash.events.MouseEvent 当用户在 InteractiveObject 实例上按下指针设备的中间按钮时调度。 middleClick 当用户在同一 InteractiveObject 上按下并释放用户指针设备的中间按钮时调度。flash.events.MouseEvent.MIDDLE_CLICKflash.events.MouseEvent 当用户在同一 InteractiveObject 上按下并释放用户指针设备的中间按钮时调度。要使 middleClick 事件发生,该事件必须始终按照发生顺序跟在以下一系列事件之后:middleMouseDown 事件,然后是 middleMouseUp。这两个事件的目标对象必须相同,否则不会发生 middleClick 事件。在 middleMouseDownmiddleMouseUp 事件之间可以随时发生任意数量的其他鼠标事件;middleClick 事件仍会发生。 gestureSwipe 当用户在接触点处使用 InteractiveObject 实例执行滑动手势(例如,在配有触摸屏的移动电话或绘图板上用三根手指触摸屏幕,然后在一个显示对象上平行移动这三根手指)时调度。flash.events.TransformGestureEvent.GESTURE_SWIPEflash.events.TransformGestureEvent 当用户在接触点处使用 InteractiveObject 实例执行滑动手势(例如,在配有触摸屏的移动电话或绘图板上用三根手指触摸屏幕,然后在一个显示对象上平行移动这三根手指)时调度。平行移动多根手指是一种常见的滑动手势,但每种设备和每种操作系统对滑动都有自己的要求。有些设备也可能将此触摸解释为多个鼠标事件的组合。

具体来说,如果用户在 InteractiveObject 上移动手指,然后移动多根手指,则 InteractiveObject 实例除调度 gestureSwipe 事件外,还会调度 rollOver 事件和 rollOut 事件(也包括其他事件),或者,如果当前环境支持,可以调度所有事件。选择处理用户交互的方式。如果您选择处理 rollOver 事件,则将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 gestureSwipe 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

处理事件对象的属性时,请注意将 localXlocalY 属性设置为主要接触点。offsetXoffsetY 属性是与完成滑动手势的接触点之间的距离。

注意:使用 Mac OS 操作系统的某些设备可解释四指滑动,而此 API 仅支持三指滑动。

以下示例将显示如何对 GESTURE_SWIPE 事件进行事件处理。当用户在启用触摸的设备上执行滑动手势时,myTextField 将使用滑动事件的唯一阶段 all 进行填充。 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; }
rollOver 事件touchOver 事件flash.ui.Multitouch
gestureZoom 当用户在接触点处使用 InteractiveObject 实例执行缩放手势操作时(例如,将两个手指放在屏幕上,然后在配有触摸屏的移动电话或绘图板上的显示对象上快速分开手指)调度。flash.events.TransformGestureEvent.GESTURE_ZOOMflash.events.TransformGestureEvent 当用户在接触点处使用 InteractiveObject 实例执行缩放手势操作时(例如,将两个手指放在屏幕上,然后在配有触摸屏的移动电话或绘图板上的显示对象上快速分开手指)调度。移开手指是一个常用的缩放手势,但每个设备和操作系统都会有自己表示缩放操作的要求。有些设备也可能将此触摸解释为多个鼠标事件的组合。

具体来说,如果用户在 InteractiveObject 上移动手指,然后将手指移开,则 InteractiveObject 实例除调度 gestureZoom 事件外,还会调度 mouseOver 事件和 click 事件(也包括其他事件),或者,如果当前环境支持,可调度所有事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseOver 事件,将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 gestureZoom 事件,您可以设计自己的事件处理程序,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

处理事件对象的属性时,请注意将 localXlocalY 属性设置为主要接触点。offsetXoffsetY 属性是与完成缩放手势的接触点之间的距离。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

以下示例将显示如何对 GESTURE_ZOOM 事件进行事件处理。当用户在启用触摸的设备上执行缩放手势时,myTextField 将使用当前的阶段进行填充。 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"; } }
mouseOver 事件touchOver 事件flash.ui.Multitouch
gestureRotate 当用户在接触点处使用 InteractiveObject 实例执行旋转手势时(例如,将两个手指放在屏幕上,然后在配有触摸屏的移动电话或绘图板上的显示对象上旋转这两个手指)调度。flash.events.TransformGestureEvent.GESTURE_ROTATEflash.events.TransformGestureEvent 当用户在接触点处使用 InteractiveObject 实例执行旋转手势时(例如,将两个手指放在屏幕上,然后在配有触摸屏的移动电话或绘图板上的显示对象上旋转这两个手指)调度。两个手指旋转是一个常用的旋转手势,但每个设备和操作系统都会有自己表示旋转操作的要求。有些设备也可能将此触摸解释为多个鼠标事件的组合。

具体来说,如果用户在 InteractiveObject 上移动手指,则 InteractiveObject 实例除调度 gestureRotate 事件外,还可调度 mouseOver 事件和 click 事件(也包括其他事件),或者,如果当前环境支持,可调度所有事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseOver 事件,将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 gestureRotate 事件,可以设计自己的事件处理函数,以响应启用触摸环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

处理事件对象的属性时,请注意将 localXlocalY 属性设置为主要接触点。offsetXoffsetY 属性是与完成旋转手势的接触点之间的距离。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

以下示例显示针对 GESTURE_ROTATE 事件的事件处理。当用户在启用触摸的设备上执行旋转手势时,mySprite 旋转,myTextField 填充为当前阶段。 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"; } }
mouseOver 事件touchOver 事件flash.ui.Multitouch
gesturePressAndTap 当用户使用 InteractiveObject 实例创建接触点,然后点击启用触屏的设备时(例如,将几个手指放在显示对象上以打开菜单,然后点击一个手指在配有触摸屏的移动电话或绘图板上选择一个菜单项)调度。flash.events.PressAndTapGestureEvent.GESTURE_PRESS_AND_TAPflash.events.PressAndTapGestureEvent 当用户使用 InteractiveObject 实例创建接触点,然后点击启用触屏的设备时(例如,将几个手指放在显示对象上以打开菜单,然后点击一个手指在配有触摸屏的移动电话或绘图板上选择一个菜单项)调度。有些设备也可能将此触摸解释为多个鼠标事件的组合。

具体来说,如果用户在 InteractiveObject 上移动手指,然后执行辅助点击,则 InteractiveObject 实例会调度 mouseOver 事件和 click 事件(也包括其他事件)以及 gesturePressAndTap 事件,或者如果当前环境支持,可调度所有事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseOver 事件,将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 gesturePressAndTap 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

处理事件对象的属性时,请注意将 localXlocalY 属性设置为主要接触点(“推动”)。offsetXoffsetY 属性是与辅助接触点(“点击”)之间的距离。

mouseOver 事件touchOver 事件flash.ui.Multitouch
gesturePan 当用户在启用触摸的设备上的 InteractiveObject 实例上移动接触点时(例如,在配有触摸屏的移动电话或绘图板上的显示对象上从左向右移动手指)调度。flash.events.TransformGestureEvent.GESTURE_PANflash.events.TransformGestureEvent 当用户在启用触摸的设备上的 InteractiveObject 实例上移动接触点时(例如,在配有触摸屏的移动电话或绘图板上的显示对象上从左向右移动手指)调度。某些设备可能还会将此接触解释为 mouseOver 事件和 touchOver 事件。

具体来说,如果用户在 InteractiveObject 上移动手指,则 InteractiveObject 实例会调度 mouseOver 事件或 touchOver 事件或 gesturePan 事件,或者,如果当前环境支持,可调度所有事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseOver 事件,将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 gesturePan 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

以下示例将显示如何对 GESTURE_PAN 事件进行事件处理。当用户在启用触摸的设备上执行平移手势时,myTextField 将使用当前的阶段进行填充。 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"; } }
mouseOver 事件touchOver 事件flash.ui.Multitouch
gestureTwoFingerTap 当用户在启用触摸设备上的同一 InteractiveObject 实例上按下两个接触点时(例如,在配有触摸屏的移动电话或绘图板上的显示对象上按下和释放两个手指)调度。flash.events.GestureEvent.GESTURE_TWO_FINGER_TAPflash.events.GestureEvent 当用户在启用触摸设备上的同一 InteractiveObject 实例上按下两个接触点时(例如,在配有触摸屏的移动电话或绘图板上的显示对象上按下和释放两个手指)调度。某些设备可能还会将此接触解释为 doubleClick 事件。

具体来说,如果用户在 InteractiveObject 上点击两个手指,则 InteractiveObject 实例会调度 doubleClick 事件或 gestureTwoFingerTap 事件,或者,如果当前环境支持,可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 doubleClick 事件,将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 gestureTwoFingerTap 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

doubleClick 事件flash.ui.Multitouch
touchTap 当用户在启用触摸设备上的已启动接触的同一 InteractiveObject 实例上抬起接触点时(例如,在配有触摸屏的移动电话或绘图板的显示对象上的某一点处按下并释放手指)调度。flash.events.TouchEvent.TOUCH_TAPflash.events.TouchEvent 当用户在启用触摸设备上的已启动接触的同一 InteractiveObject 实例上抬起接触点时(例如,在配有触摸屏的移动电话或绘图板的显示对象上的某一点处按下并释放手指)调度。某些设备可能还会将此接触解释为 click 事件。

具体来说,如果用户在 InteractiveObject 上点击一个手指,则 InteractiveObject 实例会调度 click 事件或 touchTap 事件,或者,如果当前环境支持,可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 click 事件,则将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 touchTap 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

以下示例在启用触摸的屏幕上点击在 mySprite 上绘制的正方形时显示一条信息: 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); }
click 事件flash.ui.Multitouch
touchRollOver 当用户在启用触摸的设备的 InteractiveObject 实例上移动接触点时(例如,在配有触摸屏的移动电话或绘图板上,将手指从显示对象外的一点拖动到显示对象上的一点)调度。flash.events.TouchEvent.TOUCH_ROLL_OVERflash.events.TouchEvent 当用户在启用触摸的设备的 InteractiveObject 实例上移动接触点时(例如,在配有触摸屏的移动电话或绘图板上,将手指从显示对象外的一点拖动到显示对象上的一点)调度。某些设备可能还会将此接触解释为 rollOver 事件。

具体来说,如果用户在 InteractiveObject 上移动一个手指,则 InteractiveObject 实例会调度 rollOver 事件或 touchRollOver 事件,或者,如果当前环境支持,则可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 rollOver 事件,则将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 touchRollOver 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

rollOver 事件flash.ui.Multitouch
touchRollOut 当用户移动接触点,使其远离启用触摸的设备上的 InteractiveObject 实例时(例如,在配有触摸屏的移动电话或绘图板上将一个手指从显示对象上的一点移动到显示对象外的一点)调度。flash.events.TouchEvent.TOUCH_ROLL_OUTflash.events.TouchEvent 当用户移动接触点,使其远离启用触摸的设备上的 InteractiveObject 实例时(例如,在配有触摸屏的移动电话或绘图板上将一个手指从显示对象上的一点移动到显示对象外的一点)调度。某些设备可能还会将此接触解释为 rollOut 事件。

具体来说,如果用户在 InteractiveObject 上移动一个手指,则 InteractiveObject 实例会调度 rollOut 事件或 touchRollOut 事件,或者,如果当前环境支持,则可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 rollOut 事件,则将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 touchRollOut 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

rollOut 事件flash.ui.Multitouch
touchOver 当用户在启用触摸的设备的 InteractiveObject 实例上移动接触点时(例如,在配有触摸屏的移动电话或绘图板上,将手指从显示对象外的一点拖动到显示对象上的一点)调度。flash.events.TouchEvent.TOUCH_OVERflash.events.TouchEvent 当用户在启用触摸的设备的 InteractiveObject 实例上移动接触点时(例如,在配有触摸屏的移动电话或绘图板上,将手指从显示对象外的一点拖动到显示对象上的一点)调度。某些设备可能还会将此接触解释为 mouseOver 事件。

具体来说,如果用户在 InteractiveObject 上移动一个手指,则 InteractiveObject 实例会调度 mouseOver 事件或 touchOver 事件,或者,如果当前环境支持,则可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseOver 事件,将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 touchOver 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

mouseOver 事件flash.ui.Multitouch
touchOut 当用户将接触点从启用触摸的设备上的 InteractiveObject 实例移开时(例如,在配有触摸屏的移动电话或绘图板上,将手指从一个显示对象拖到另一个显示对象)调度。flash.events.TouchEvent.TOUCH_OUTflash.events.TouchEvent 当用户将接触点从启用触摸的设备上的 InteractiveObject 实例移开时(例如,在配有触摸屏的移动电话或绘图板上,将手指从一个显示对象拖到另一个显示对象)调度。某些设备可能还会将此接触解释为 mouseOut 事件。

具体来说,如果用户在触摸屏上移动一个手指,则 InteractiveObject 实例会调度 mouseOut 事件或 touchOut 事件,或者,如果当前环境支持,则可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseOut 事件,则将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 touchOut 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

mouseOut 事件flash.ui.Multitouch
touchMove 当用户在启用触摸的设备上移动接触点时(例如,在配有触摸屏的移动电话或绘图板上拖动手指)调度。flash.events.TouchEvent.TOUCH_MOVEflash.events.TouchEvent 当用户在启用触摸的设备上移动接触点时(例如,在配有触摸屏的移动电话或绘图板上拖动手指)调度。某些设备可能还会将此接触解释为 mouseMove 事件。

具体来说,如果用户在触摸屏上移动一个手指,则 InteractiveObject 实例会调度 mouseMove 事件或 touchMove 事件,或者,如果当前环境支持,则可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseMove 事件,则将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 touchMove 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

以下示例显示针对 TOUCH_BEGIN 事件、TOUCH_MOVE 事件和 TOUCH_END 事件的事件处理。当接触点在屏幕上移动 (onTouchMove) 时,会跟踪相对于舞台的 X 坐标以便输出。对于 onTouchBegin 函数中的 Sprite.startTouchDrag 参数,touchPointID 的值是分配给事件对象的值。bounds 参数是定义父显示对象(bg 是包含 MySprite 的显示对象)的边界的矩形。 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"); }
mouseMove 事件flash.ui.Multitouch
touchEnd 当用户移除与启用触摸的设备的接触时(例如,将手指从配有触摸屏的移动电话或绘图板上抬起)调度。flash.events.TouchEvent.TOUCH_ENDflash.events.TouchEvent 当用户移除与启用触摸的设备的接触时(例如,将手指从配有触摸屏的移动电话或绘图板上抬起)调度。某些设备可能还会将此接触解释为 mouseUp 事件。

具体来说,如果用户从触摸屏上抬起一个手指,则 InteractiveObject 实例会调度 mouseUp 事件或 touchEnd 事件,或者,如果当前环境支持,则可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseUp 事件,则将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 touchEnd 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

以下示例显示针对 TOUCH_BEGIN 事件、TOUCH_MOVE 事件和 TOUCH_END 事件的事件处理。当接触点在屏幕上移动 (onTouchMove) 时,会跟踪相对于舞台的 X 坐标以便输出。对于 onTouchBegin 函数中的 Sprite.startTouchDrag 参数,touchPointID 的值是分配给事件对象的值。bounds 参数是定义父显示对象(bg 是包含 MySprite 的显示对象)的边界的矩形。 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"); }
mouseUp 事件flash.ui.Multitouch
touchBegin 当用户第一次触摸启用触摸的设备时(例如,用手指触摸配有触摸屏的移动电话或绘图板)调度。flash.events.TouchEvent.TOUCH_BEGINflash.events.TouchEvent 当用户第一次触摸启用触摸的设备时(例如,用手指触摸配有触摸屏的移动电话或绘图板)调度。某些设备可能还会将此接触解释为 mouseDown 事件。

具体来说,如果用户使用一个手指接触触摸屏,则 InteractiveObject 实例会调度 mouseDown 事件或 touchBegin 事件,或者,如果当前环境支持,则可同时调度这两个事件。选择处理用户交互的方式。使用 flash.ui.Multitouch 类管理触摸事件处理(启用触摸手势事件处理、简单的触摸点事件处理,或禁用触摸事件以仅调度鼠标事件)。如果您选择处理 mouseDown 事件,则将在启用触摸的设备和启用鼠标的设备上运行相同的事件处理函数。但是,如果您选择处理 touchBegin 事件,您可以设计自己的事件处理函数,以响应启用触摸的环境的特定需求并为用户提供更丰富的启用触摸体验。您也可以分别处理这两种事件,为触摸事件和鼠标事件提供不同的响应。

注意:有关环境兼容性的信息,请参阅 Multitouch 类。

以下示例显示针对 TOUCH_BEGIN 事件、TOUCH_MOVE 事件和 TOUCH_END 事件的事件处理。当接触点在屏幕上移动 (onTouchMove) 时,会跟踪相对于舞台的 X 坐标以便输出。对于 onTouchBegin 函数中的 Sprite.startTouchDrag 参数,touchPointID 的值是分配给事件对象的值。bounds 参数是定义父显示对象(bg 是包含 MySprite 的显示对象)的边界的矩形。 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"); }
mouseDown 事件flash.ui.Multitouch
rollOver 用户将指针设备移动到 InteractiveObject 实例上时调度。flash.events.MouseEvent.ROLL_OVERflash.events.MouseEvent 用户将指针设备移动到 InteractiveObject 实例上时调度。事件目标为指针设备下的对象或该对象的父级。relatedObject 是以前在指针设备下的对象。rollOver 事件是沿该对象的父级链向下连续调度的,从 relatedObject 的根或始祖之外的最高父级开始,并以该对象结束。

rollOver 事件的目的是简化带有子级的显示对象容器的移开行为的编码。当鼠标进入某个显示对象区域或者从其子级以外的对象进入任何其子级区域时,该显示对象将调度 rollOver 事件。这种行为与 mouseOver 事件的行为不同,每次鼠标进入显示对象容器的任何子对象区域时都会调度此事件,即使鼠标已在显示对象容器的另一个子对象上也是如此。

rollOut 用户将指针设备从 InteractiveObject 实例上移开时调度。flash.events.MouseEvent.ROLL_OUTflash.events.MouseEvent 用户将指针设备从 InteractiveObject 实例上移开时调度。事件目标是指先前在指针设备下的对象或该对象的父级。relatedObject 是将指针设备向其移动的对象。在该对象的父级链以上连续调度 rollOut 事件,以该对象为开头,并以除 relatedObject 的根或始祖之外的最高级别的父级结束。

rollOut 事件的目的是简化带有子级的显示对象容器的移开行为的编码。当鼠标离开显示对象区域或任何其子级区域并转到除其子级以外的对象时,显示对象调度 rollOut 事件。这是与 mouseOut 事件行为不同的行为,因为该事件是在每次鼠标离开显示对象容器的任何子对象区域时才会被调度,即使鼠标仍保留在显示对象容器的另一个子对象上也是如此。

mouseWheel 当鼠标滚轮滚动到 InteractiveObject 实例上时调度。flash.events.MouseEvent.MOUSE_WHEELflash.events.MouseEvent 当鼠标滚轮滚动到 InteractiveObject 实例上时调度。如果目标为文本字段,则作为默认行为,该文本会滚动。仅在 Microsoft Windows 操作系统中提供。 mouseUp 当用户在 InteractiveObject 实例上释放指针设备按钮时调度。flash.events.MouseEvent.MOUSE_UPflash.events.MouseEvent 当用户在 InteractiveObject 实例上释放指针设备按钮时调度。如果目标为 SimpleButton 实例,该对象会显示 upState 显示对象。如果目标为可选文本字段,则作为默认行为,该文本字段会结束选择。 mouseOver 用户将指针设备移动到 InteractiveObject 实例上时调度。flash.events.MouseEvent.MOUSE_OVERflash.events.MouseEvent 用户将指针设备移动到 InteractiveObject 实例上时调度。relatedObject 是以前在指针设备下的对象。如果目标为 SimpleButton 实例,作为默认行为,该对象会根据是否按下鼠标按键而显示 overStateupState 显示对象。

每次鼠标进入显示对象容器的任何子对象区域时都会调度 mouseOver 事件,即使鼠标已在显示对象容器的另一个子对象上也是如此。此行为不同于 rollOver 事件的用途,此事件用于简化带有子级的显示对象容器的移出行为的编码。当鼠标进入某个显示对象区域或者从其子级以外的对象进入任何其子级区域时,该显示对象将调度 rollOver 事件。rollOver 事件是沿该对象的父级链向下连续调度的,从 relatedObject 的根或始祖之外的最高父级开始,并以该对象结束。

mouseOut 用户将指针设备从 InteractiveObject 实例上移开时调度。flash.events.MouseEvent.MOUSE_OUTflash.events.MouseEvent 用户将指针设备从 InteractiveObject 实例上移开时调度。事件目标是指先前在指针设备下的对象。relatedObject 是将指针设备向其移动的对象。如果目标为 SimpleButton 实例,作为默认行为,该按钮会显示 upState 显示对象。

每次鼠标离开显示对象容器的任何子对象区域时都会调度 mouseOut 事件,即使鼠标停留在显示对象容器的另一个子对象上也是如此。此行为不同于 rollOut 事件的用途,此事件用于简化带有子级的显示对象容器的滑过行为的编码。当鼠标离开某个显示对象区域或任何其子级区域以转到其子级以外的对象时,该显示对象将调度 rollOut 事件。rollOut 事件是沿该对象的父级链向上连续调度的,从该对象开始,并以 relatedObject 的根或始祖之外的最高父级结束。

mouseMove 用户移动 InteractiveObject 上的指针设备时调度。flash.events.MouseEvent.MOUSE_MOVEflash.events.MouseEvent 用户移动 InteractiveObject 上的指针设备时调度。如果目标为用户正在选择的文本字段,则作为默认行为,会更新选择。 mouseDown 当用户在 InteractiveObject 实例上按下指针设备按钮时调度。flash.events.MouseEvent.MOUSE_DOWNflash.events.MouseEvent 当用户在 InteractiveObject 实例上按下指针设备按钮时调度。如果目标为 SimpleButton 实例,作为默认行为,SimpleButton 实例会显示 downState 显示对象。如果目标为可选文本字段,作为默认行为,该文本字段会开始选择。 doubleClick 如果 InteractiveObject 的 doubleClickEnabled 标志设置为 true,当用户在该对象上快速连续按下两次并释放指针设备的主按钮时调度。flash.events.MouseEvent.DOUBLE_CLICKflash.events.MouseEvent 如果 InteractiveObject 的 doubleClickEnabled 标志设置为 true,当用户在该对象上快速连续按下两次并释放指针设备的主按钮时调度。要使 doubleClick 事件发生,它必在以下一系列事件后面:mouseDownmouseUpclickmouseDownmouseUp。所有这些事件必须共享与 doubleClick 事件相同的目标。第二个 mouseDownmouseUp 事件代表第二次单击,该行为必须在 click 事件之后的指定时间段内发生。该时间段的允许长度因操作系统而异,而且通常可由用户配置。如果目标为可选文本字段,作为默认行为,会选择指针下面的单词。如果目标 InteractiveObject 未将其 doubleClickEnabled 标志设置为 true,它将接收两个 click 事件。

doubleClickEnabled 属性默认为 false

TextField 对象的双击文本选择行为与 doubleClick 事件无关。使用 TextField.doubleClickEnabled 控制 TextField 选择。

doubleClickEnabled
click 用户在同一 InteractiveObject 上按下并释放用户指针设备的主按钮时调度。flash.events.MouseEvent.CLICKflash.events.MouseEvent 用户在同一 InteractiveObject 上按下并释放用户指针设备的主按钮时调度。要使单击事件发生,它必须始终在以下顺序的一系列事件后面:mouseDown 事件,然后是 mouseUp 事件。这两个事件的目标对象必须相同,否则不会发生 click 事件。mouseDownmouseUp 事件之间的任何时间都会发生任何数量的其他鼠标事件;click 事件仍会发生。 mouseFocusChange 用户尝试使用指针设备更改焦点时调度。flash.events.FocusEvent.MOUSE_FOCUS_CHANGEflash.events.FocusEvent 用户尝试使用指针设备更改焦点时调度。此事件的默认行为是更改焦点并调度相应的 focusInfocusOut 事件。

将此事件调度到当前具有焦点的对象。如果您没有禁止默认行为,则此事件的相关对象为接收焦点的 InteractiveObject 实例。可以通过调用正确注册到目标对象的事件侦听器中的 preventDefault() 来防止更改焦点。未使用 shiftKey 属性。默认情况下调度焦点更改和 focusInfocusOut 事件。

keyFocusChange 用户尝试使用键盘导航更改焦点时调度。flash.events.FocusEvent.KEY_FOCUS_CHANGEflash.events.FocusEvent 用户尝试使用键盘导航更改焦点时调度。此事件的默认行为是更改焦点并调度相应的 focusInfocusOut 事件。

将此事件调度到当前具有焦点的对象。如果您没有禁止默认行为,则此事件的相关对象为接收焦点的 InteractiveObject 实例。可以通过调用正确注册到目标对象的事件侦听器中的 preventDefault() 方法来防止更改焦点。默认情况下调度焦点更改和 focusInfocusOut 事件。

focusOut 显示对象失去焦点后调度。flash.events.FocusEvent.FOCUS_OUTflash.events.FocusEvent 显示对象失去焦点调度。这种情况会在用户使用指针设备或键盘导航加亮显示不同的对象时发生。失去焦点的对象称为该事件的目标对象,而接收焦点的相应 InteractiveObject 实例称为相关对象。对相关对象的引用存储在目标对象的 relatedObject 属性中。未使用 shiftKey 属性。该事件在相关对象调度 focusIn 事件之前发生。 focusIn 显示对象获得焦点后调度。flash.events.FocusEvent.FOCUS_INflash.events.FocusEvent 显示对象获得焦点调度。这种情况会在用户使用指针设备或键盘导航加亮显示对象时发生。该焦点的接收方称为该事件的目标对象,而因该更改而失去焦点的相应 InteractiveObject 实例称为相关对象。对相关对象的引用存储在接收对象的 relatedObject 属性中。未使用 shiftKey 属性。在该事件在调度前一个对象的 focusOut 事件之后发生。 selectAll 在用户为全选操作激活特定于平台的加速键组合或选择文本上下文菜单中的“全选”时调度。flash.events.Event.SELECT_ALLflash.events.Event 在用户为全选操作激活特定于平台的加速键组合或从文本上下文菜单中选择“全选”时调度。将此事件调度到当前具有焦点的对象。如果当前具有焦点的对象是一个 TextField,则此事件的默认行为是使该文本字段的所有内容处于选定状态。 paste 在用户为粘贴操作激活特定于平台的加速键组合或从文本上下文菜单中选择“粘贴”时调度。flash.events.Event.PASTEflash.events.Event 在用户为粘贴操作激活特定于平台的加速键组合或从文本上下文菜单中选择“粘贴”时调度。将此事件调度到当前具有焦点的对象。如果当前具有焦点的对象是一个 TextField,则此事件的默认行为是将剪贴板的所有内容粘贴到该文本字段的当前插入点,替换文本字段中当前选定的所有文本。 cut 在用户为剪切操作激活特定于平台的加速键组合或从文本上下文菜单中选择“剪切”时调度。flash.events.Event.CUTflash.events.Event 在用户为剪切操作激活特定于平台的加速键组合或从文本上下文菜单中选择“剪切”时调度。将此事件调度到当前具有焦点的对象。如果当前具有焦点的对象是一个 TextField,则此事件的默认行为是将该文本字段中当前选定的所有文本剪切到剪贴板。 copy 在用户为复制操作激活特定于平台的加速键组合或从文本上下文菜单中选择“复制”时调度。flash.events.Event.COPYflash.events.Event 在用户为复制操作激活特定于平台的加速键组合或从文本上下文菜单中选择“复制”时调度。将此事件调度到当前具有焦点的对象。如果当前具有焦点的对象是一个 TextField,则此事件的默认行为是将该文本字段中当前选定的所有文本复制到剪贴板。 clear 当用户从文本上下文菜单中选择“清除”(或“删除”)时调度。flash.events.Event.CLEARflash.events.Event 当用户从文本上下文菜单中选择“清除”(或“删除”)时调度。将此事件调度到当前具有焦点的对象。如果当前具有焦点的对象是一个 TextField,则此事件的默认行为是删除该文本字段中当前选定的所有文本。 InteractiveObject 调用新的 InteractiveObject() 构造函数会引发 ArgumentError 异常。 调用 new InteractiveObject() 构造函数会引发 ArgumentError 异常。但是,可以调用以下 InteractiveObject 的子类的构造函数:
  • new SimpleButton()
  • new TextField()
  • new Loader()
  • new Sprite()
  • new MovieClip()
requestSoftKeyboard 显示虚拟键盘。值为 true 意味着同意软键盘请求;值为 false 意味着未显示软键盘。 Boolean如果当前上下文支持,则显示键盘。 显示虚拟键盘。

调用此方法将焦点设置到 InteractiveObject 实例,并且如果需要,将显示软键盘。needsSoftKeyboard 必须也为 true。如果硬键盘可用,或者客户端系统不支持虚拟键盘,则不会显示键盘。

注意:iOS 上的 AIR 应用程序不支持此方法。

needsSoftKeyboard
accessibilityImplementation InteractiveObject 实例的当前辅助功能实现 (AccessibilityImplementation)。flash.accessibility:AccessibilityImplementation InteractiveObject 实例的当前辅助功能实现 (AccessibilityImplementation)。 flash.accessibility.AccessibilityImplementationcontextMenu 指定与此对象相关联的上下文菜单。flash.display:NativeMenu与此对象相关联的上下文菜单。 指定与此对象相关联的上下文菜单。

对于在 Flash Player 中运行的内容,此属性是一个 ContextMenu 对象。在 AIR 运行时中,ContextMenu 类扩展 NativeMenu 类,但 Flash Player 只支持 ContextMenu 类,不支持 NativeMenu 类。

注意:TextField 对象的上下文菜单中始终包含剪贴板菜单。剪贴板菜单包含“剪切”、“复制”、“粘贴”、“清除”和“全选”命令。您不能从 TextField 对象的上下文菜单中删除这些命令。对于 TextField 对象,选择这些命令(或等效键盘命令)不会生成 clearcopycutpasteselectAll 事件。

以下示例显示如何通过设置 ContextMenu 对象的 Sprite 的 contextMenu 属性向 Sprite 对象中添加自定义上下文菜单项。ActionScriptExamples.com 提供的示例。 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(); }
doubleClickEnabled 指定此对象是否接收 doubleClick 事件。Boolean该对象是否接收双击消息。 指定此对象是否接收 doubleClick 事件。默认值为 false,这意味着在默认情况下,InteractiveObject 实例不接收 doubleClick 事件。如果将 doubleClickEnabled 属性设置为 true,实例在其范围内接收 doubleClick 事件。InteractiveObject 实例的 mouseEnabled 属性也必须设置为 true,以便对象能够接收 doubleClick 事件。

设置此属性不会调度任何事件。必须使用 addEventListener() 方法为 doubleClick 事件添加事件侦听器。

doubleClickmouseEnabledflash.display.DisplayObjectContainer.mouseChildren
focusRect 指定此对象是否显示焦点矩形。Object 指定此对象是否显示焦点矩形。它可以采用三个值中的一个:truefalsenulltruefalse 值按预期工作,指定是否显示焦点矩形。null 值表示此对象遵循舞台的 stageFocusRect 属性。 mouseEnabled 指定此对象是否接收鼠标或其他用户输入、消息。Boolean 指定此对象是否接收鼠标或其他用户输入、消息。默认值为 true,这表示默认情况下,显示列表上的任何 InteractiveObject 实例都会接收鼠标事件或其他用户输入事件。如果将 mouseEnabled 设置为 false,则实例将不接收任何鼠标事件(或其他用户输入事件,例如键盘事件)。显示列表上的该实例的任何子级都不会受到影响。要更改显示列表上对象的所有子级的 mouseEnabled 行为,请使用 flash.display.DisplayObjectContainer.mouseChildren

设置此属性不会调度任何事件。您必须使用 addEventListener() 方法才能创建交互式功能。

flash.display.DisplayObjectContainer.mouseChildren
needsSoftKeyboard 指定当该 InteractiveObject 实例获得焦点时,是否显示虚拟键盘(显示在屏幕上的软键盘)。Boolean 指定当该 InteractiveObject 实例获得焦点时,是否显示虚拟键盘(显示在屏幕上的软键盘)。

默认情况下,该值为 false,因此将焦点设置到 InteractiveObject 实例不会显示软键盘。如果 needsSoftKeyboard 属性设置为 true,则当 InteractiveObject 可以接受用户输入时,运行时会显示软键盘。当以编程方式调用设置舞台的 focus 属性或用户交互(如,点击)后,InteractiveObject 实例即可以接受用户输入。如果客户端系统具有可用的硬键盘或者不支持虚拟键盘,则不会显示软键盘。

当显示或关闭软键盘时,InteractiveObject 实例会调度 softKeyboardActivatingsoftKeyboardActivatesoftKeyboardDeactivate 事件。

注意:iOS 上的 AIR 应用程序不支持此属性。

softKeyboardActivatingsoftKeyboardActivatesoftKeyboardDeactivate
softKeyboardInputAreaOfInterest 定义当显示软键盘时应在屏幕上保留的区域。flash.geom:Rectangle设置当软键盘打开时在屏幕上显示的区域。 定义当显示软键盘时应在屏幕上保留的区域。

如果 InteractiveObject 的 needsSoftKeyboard 属性为 true,则当用户键入时,运行时会根据需要调整显示,以将对象保留在视图中。通常,运行时会使用从 DisplayObject.getBounds() 方法获取的对象边界。您可以通过使用此 softKeyboardInputAreaOfInterest 属性指定不同的区域。

在舞台坐标中指定 softKeyboardInputAreaOfInterest

注意:在 Android 的横向模式中,不遵循 softKeyboardInputAreaOfInterest

flash.display.DisplayObject.getBounds()
tabEnabled 指定此对象是否遵循 Tab 键顺序。Boolean该对象是否遵循 Tab 键顺序。 指定此对象是否遵循 Tab 键顺序。如果该对象遵循 Tab 键顺序,值为 true;否则值为 false。默认情况下,值为 false,但以下情况除外:
  • 对于 SimpleButton 对象,值为 true
  • 对于具有 type = "input" 的 TextField 对象,值为 true
  • 对于具有 buttonMode = true 的 Sprite 对象或 MovieClip 对象,值为 true
tabIndex 指定 SWF 文件中的对象按 Tab 键顺序排列。int该对象的 Tab 键索引。 指定 SWF 文件中的对象按 Tab 键顺序排列。默认情况下,tabIndex 属性为 -1,这意味着没有为该对象设置任何 Tab 索引。

如果 SWF 文件中当前显示的任何对象包含 tabIndex 属性,则禁用 Tab 键自动排序,而使用该 SWF 文件中对象的 tabIndex 属性来计算 Tab 键顺序。这个自定义的 Tab 键排序仅包括指定了 tabIndex 属性的对象。

tabIndex 属性可以是非负整数。这些对象按照其 tabIndex 属性按升序进行排序。tabIndex 值为 1 的对象在 tabIndex 值为 2 的对象的前面。不要对多个对象使用相同的 tabIndex 值。

tabIndex 属性定义的自定义 Tab 键顺序为平构。这意味着不考虑 SWF 文件中对象的层次结构关系。SWF 文件中具有 tabIndex 属性的所有对象都排入 Tab 键顺序中,而 Tab 键顺序由 tabIndex 值的顺序确定。

注意:要设置 TLFTextField 实例的 Tab 键顺序,请将 TLFTextField 的显示子对象转换为 InteractiveObject,然后设置 tabIndex 属性。例如:

	 InteractiveObject(tlfInstance.getChildAt(1)).tabIndex = 3;
	 
要将 TLFTextField 对象三个实例的 Tab 顺序从默认设置(tlfInstance1tlfInstance2tlfInstance3)转变为相反的顺序,请使用:
	 InteractiveObject(tlfInstance1.getChildAt(1)).tabIndex = 3;
	 InteractiveObject(tlfInstance2.getChildAt(1)).tabIndex = 2;
	 InteractiveObject(tlfInstance3.getChildAt(1)).tabIndex = 1;
	 

GraphicsTrianglePath 定义有序的一组三角形,可以使用 (u,v) 填充坐标或普通填充来呈现这些三角形。flash.display:IGraphicsPathflash.display:IGraphicsDataObject 定义有序的一组三角形,可以使用 (u,v) 填充坐标或普通填充来呈现这些三角形。路径中的每个三角形都由三组 (x, y) 坐标表示,其中每组坐标都是三角形的一个点。

三角形顶点不包含 z 坐标,并且不一定表示 3D 面。但是,可以使用三角形路径来支持在 2D 空间中呈现 3D 几何图形。

flash.display.Graphics.drawTriangles()GraphicsTrianglePath 创建新的 GraphicsTrianglePath 对象。verticesnull由数字构成的矢量,其中的每一对数字将被视为一个点(一个 x, y 对)。必需。 indicesnull一个由整数或索引构成的矢量,其中每三个索引定义一个三角形。 uvtDatanull由用于应用纹理映射的标准坐标构成的矢量。 cullingStringnone指定是否呈现面向给定方向的三角形。用于防止呈现在当前视图中看不见的三角形。可设置为由 TriangleCulling 类定义的任何值。 创建新的 GraphicsTrianglePath 对象。 cullingflash.display.TriangleCullingindices 一个由整数或索引构成的矢量,其中每三个索引定义一个三角形。 一个由整数或索引构成的矢量,其中每三个索引定义一个三角形。如果 indexes 参数为 null,则每三个顶点(vertices 矢量中的 6 对 x,y)定义一个三角形。否则,每个索引将引用一个顶点,即 vertices 矢量中的一对数字。例如,indexes[1] 引用 (vertices[2], vertices[3])。 uvtData 由用于应用纹理映射的标准坐标构成的矢量。 由用于应用纹理映射的标准坐标构成的矢量。每个坐标引用用于填充的位图上的一个点。每个顶点必须具有一个 UV 或一个 UVT 坐标。

对于 UV 坐标,(0,0) 是位图的左上角,(1,1) 是位图的右下角。

如果此矢量的长度是 vertices 矢量长度的两倍,则使用标准坐标而不进行透视校正。

如果此矢量的长度是 vertices 矢量长度的三倍,则将第三个坐标解释为“t”,即在视角空间中从视点到纹理的距离。这有助于呈现引擎在 3D 中映射纹理时正确应用透视。

vertices 由数字构成的矢量,其中的每一对数字将被视为一个点(一个 x, y 对)。 由数字构成的矢量,其中的每一对数字将被视为一个点(一个 x, y 对)。 culling 指定是否呈现面向给定方向的三角形。String 指定是否呈现面向给定方向的三角形。用于防止呈现在当前视图中看不见的三角形。

可设置为由 TriangleCulling 类定义的任何值。

flash.display.TriangleCulling
DisplayObject DisplayObject 类是可放在显示列表中的所有对象的基类。flash.display:IBitmapDrawableflash.events:EventDispatcher DisplayObject 类是可放在显示列表中的所有对象的基类。该显示列表管理 Flash 运行时中显示的所有对象。使用 DisplayObjectContainer 类排列显示列表中的显示对象。DisplayObjectContainer 对象可以有子显示对象,而其他显示对象(如 Shape 和 TextField 对象)是“叶”节点,只有父级和同级,没有子级。

DisplayObject 类支持基本功能(如对象的 xy 位置),也支持更高级的对象属性(如它的转换矩阵)。

DisplayObject 是一种抽象基类;因此,不能直接调用 DisplayObject。调用 new DisplayObject() 会引发 ArgumentError 异常。

所有显示对象都继承自 DisplayObject 类。

DisplayObject 类本身不包含任何用于在屏幕上呈现内容的 API。因此,如果要创建 DisplayObject 类的自定义子类,您将需要扩展其中一个具有在屏幕上呈现内容的 API 的子类,如 Shape、Sprite、Bitmap、SimpleButton、TextField 或 MovieClip 类。

DisplayObject 类包含若干广播事件。通常,任何特定事件的目标均为一个特定的 DisplayObject 实例。例如,added 事件的目标是已添加到显示列表的特定 DisplayObject 实例。若只有一个目标,则会将事件侦听器限制为只能放置到该目标上(在某些情况下,可放置到显示列表中该目标的始祖上)。但是,对于广播事件,目标不是特定的 DisplayObject 实例,而是所有 DisplayObject 实例(包括那些不在显示列表中的实例)。这意味着您可以向任何 DisplayObject 实例添加侦听器来侦听广播事件。除了 DisplayObject 类的 Events 表中列出的广播事件,DisplayObject 类还从 EventDispatcher 类继承如下两个广播事件:activatedeactivate

一些以前在 ActionScript 1.0 和 2.0 MovieClip、TextField 和 Button 类中使用的属性(如 _alpha_height_name_width_x_y 等)在 ActionScript 3.0 DisplayObject 类中有等效属性,但它们已被重命名,因此不再以下划线 (_) 字符开头。

有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“显示编程”一章。

下例使用 DisplayObjectExample 类在舞台的角上绘制了一个橙色的正方形,然后通过显示每个事件的文本信息对事件作出响应。执行下列步骤可完成该任务:
  1. 声明用于正方形的颜色和大小的类属性。
  2. 构造函数调用 draw() 方法,在舞台上的默认坐标处 (x = 0, y = 0) 绘制一个橙色的正方形。
  3. 将以下事件侦听器方法附加到该正方形:
    • addedHandler() 侦听 added 事件,该事件在将正方形添加到显示列表中时调度。
    • enterFrameHandler() 侦听 enterFrame 事件,它在本示例中没有实际意义。
    • removedHandler() 侦听 removed 事件,该事件在将正方形从显示列表中删除(单击该正方形时会发生此情况)时调度。
    • clickHandler() 侦听 click 事件,该事件在单击该橙色正方形时调度。
    • renderHandler() 在显示列表更新之后侦听 render 事件。
package { import flash.display.Sprite; public class DisplayObjectExample extends Sprite { public function DisplayObjectExample() { var child:CustomDisplayObject = new CustomDisplayObject(); addChild(child); } } } import flash.display.DisplayObject; import flash.display.Sprite; import flash.display.Stage; import flash.display.StageAlign; import flash.display.StageScaleMode; import flash.events.*; class CustomDisplayObject extends Sprite { private var bgColor:uint = 0xFFCC00; private var size:uint = 80; public function CustomDisplayObject() { draw(); addEventListener(Event.ADDED, addedHandler); addEventListener(Event.ENTER_FRAME, enterFrameHandler); addEventListener(Event.REMOVED, removedHandler); addEventListener(MouseEvent.CLICK, clickHandler); addEventListener(Event.RENDER, renderHandler); } private function draw():void { graphics.beginFill(bgColor); graphics.drawRect(0, 0, size, size); graphics.endFill(); } private function clickHandler(event:MouseEvent):void { trace("clickHandler: " + event); parent.removeChild(this); } private function addedHandler(event:Event):void { trace("addedHandler: " + event); stage.scaleMode = StageScaleMode.NO_SCALE; stage.align = StageAlign.TOP_LEFT; stage.addEventListener("resize", resizeHandler); } private function enterFrameHandler(event:Event):void { trace("enterFrameHandler: " + event); removeEventListener("enterFrame", enterFrameHandler); } private function removedHandler(event:Event):void { trace("removedHandler: " + event); stage.removeEventListener("resize", resizeHandler); } private function renderHandler(event:Event):void { trace("renderHandler: " + event); } private function resizeHandler(event:Event):void { trace("resizeHandler: " + event); } }
flash.display.DisplayObjectContainerrender [广播事件] 将要更新和呈现显示列表时调度。flash.events.Event.RENDERflash.events.Event [广播事件] 将要更新和呈现显示列表时调度。此事件为侦听此事件的对象在呈现显示列表之前进行更改提供了最后的机会。每次希望调度 render 事件时,必须调用 Stage 对象的 invalidate() 方法。只有当 Render 事件与调用 Stage.invalidate() 的对象互相信任时,才会将这些事件调度给某个对象。此事件为广播事件,这意味着具有注册了此事件的侦听器的所有显示对象都会调度此事件。

注意:如果显示未呈现,则不会调度此事件。当内容最小化或遮蔽时会出现这种情况。

removedFromStage 在从显示列表中直接删除显示对象或删除包含显示对象的子树时调度。flash.events.Event.REMOVED_FROM_STAGEflash.events.Event 在从显示列表中直接删除显示对象或删除包含显示对象的子树时调度。DisplayObjectContainer 类的以下两个方法会生成此事件:removeChild()removeChildAt()

如果必须删除某个对象来为新对象提供空间,则 DisplayObjectContainer 对象的下列方法也会生成此事件:addChild()addChildAt()setChildIndex()

removed 将要从显示列表中删除显示对象时调度。flash.events.Event.REMOVEDflash.events.Event 将要从显示列表中删除显示对象时调度。DisplayObjectContainer 类的以下两个方法会生成此事件:removeChild()removeChildAt()

如果必须删除某个对象来为新对象提供空间,则 DisplayObjectContainer 对象的下列方法也会生成此事件:addChild()addChildAt()setChildIndex()

exitFrame [广播事件] 播放头退出当前帧时调度。flash.events.Event.EXIT_FRAMEflash.events.Event [广播事件] 播放头退出当前帧时调度。所有帧脚本已运行。如果播放头不移动,或者只有一帧,则会继续以帧速率调度此事件。此事件为广播事件,这意味着具有注册了此事件的侦听器的所有显示对象都会调度此事件。 frameConstructed [广播事件] 在帧显示对象的构造函数运行之后但在帧脚本运行之前调度。flash.events.Event.FRAME_CONSTRUCTEDflash.events.Event [广播事件] 在帧显示对象的构造函数运行之后但在帧脚本运行之前调度。如果播放头不移动,或者只有一帧,则会继续以帧速率调度此事件。此事件为广播事件,这意味着具有注册了此事件的侦听器的所有显示对象都会调度此事件。 enterFrame [播放事件] 播放头进入新帧时调度。flash.events.Event.ENTER_FRAMEflash.events.Event [播放事件] 播放头进入新帧时调度。如果播放头不移动,或者只有一帧,则会继续以帧速率调度此事件。此事件为广播事件,这意味着具有注册了此事件的侦听器的所有显示对象都会调度此事件。 addedToStage 在将显示对象直接添加到舞台显示列表或将包含显示对象的子树添加至舞台显示列表中时调度。flash.events.Event.ADDED_TO_STAGEflash.events.Event 在将显示对象直接添加到舞台显示列表或将包含显示对象的子树添加至舞台显示列表中时调度。以下方法会触发此事件:DisplayObjectContainer.addChild()DisplayObjectContainer.addChildAt()flash.display.DisplayObjectContainer.addChild()flash.display.DisplayObjectContainer.addChildAt()added 将显示对象添加到显示列表中时调度。flash.events.Event.ADDEDflash.events.Event 将显示对象添加到显示列表中时调度。以下方法会触发此事件:DisplayObjectContainer.addChild()DisplayObjectContainer.addChildAt()flash.display.DisplayObjectContainer.addChild()flash.display.DisplayObjectContainer.addChildAt()getBounds 返回一个矩形,该矩形定义相对于 targetCoordinateSpace 对象坐标系的显示对象区域。定义与 targetCoordinateSpace 对象坐标系统相关的显示对象面积的矩形。 flash.geom:RectangletargetCoordinateSpaceflash.display:DisplayObject定义要使用的坐标系的显示对象。 返回一个矩形,该矩形定义相对于 targetCoordinateSpace 对象坐标系的显示对象区域。考虑以下代码,此代码显示了矩形的返回方式根据您传递给该方法的 targetCoordinateSpace 参数的不同而不同: var container:Sprite = new Sprite(); container.x = 100; container.y = 100; this.addChild(container); var contents:Shape = new Shape(); contents.graphics.drawCircle(0,0,100); container.addChild(contents); trace(contents.getBounds(container)); // (x=-100, y=-100, w=200, h=200) trace(contents.getBounds(this)); // (x=0, y=0, w=200, h=200)

请注意:使用 localToGlobal()globalToLocal() 方法可以分别将显示对象的本地坐标转换为显示坐标,或将显示坐标转换为本地坐标。

getBounds() 方法与 getRect() 方法类似;但是 getBounds() 方法返回的矩形包括形状的所有笔触,然而 getRect() 方法返回的矩形则不包括。例如,请参阅 getRect() 方法的说明。

getRect()globalToLocal()localToGlobal()
getRect 返回一个矩形,该矩形根据 targetCoordinateSpace 参数定义的坐标系定义显示对象的边界,但不包括形状上的任何笔触。定义与 targetCoordinateSpace 对象坐标系统相关的显示对象面积的矩形。 flash.geom:RectangletargetCoordinateSpaceflash.display:DisplayObject定义要使用的坐标系的显示对象。 返回一个矩形,该矩形根据 targetCoordinateSpace 参数定义的坐标系定义显示对象的边界,但不包括形状上的任何笔触。getRect() 方法返回的值等于或小于由 getBounds() 方法返回的值。

请注意:使用 localToGlobal()globalToLocal() 方法可以分别将显示对象的本地坐标转换为舞台坐标,或将舞台坐标转换为本地坐标。

下例显示 getBounds() 方法如何由于笔触占据的更多区域而比 getRect() 方法返回更大的矩形。在这种情况下,triangle Sprite 包括其他笔触,因为有 lineStyle() 方法的 widthjointStyle 参数。trace() 输出(在最后两行中)显示了 getRect()getBounds() 矩形之间的差异: import flash.display.CapsStyle; import flash.display.JointStyle; import flash.display.LineScaleMode; import flash.display.Sprite; import flash.geom.Rectangle; var triangle:Sprite = new Sprite(); var color:uint = 0xFF0044; var width:Number = 20; var alpha:Number = 1.0; var pixelHinting:Boolean = true; var scaleMode:String = LineScaleMode.NORMAL; var caps:String = CapsStyle.SQUARE; var joints:String = JointStyle.MITER; triangle.graphics.lineStyle(width, color, alpha, pixelHinting, scaleMode, caps, joints); var triangleSide:Number = 100; triangle.graphics.moveTo(0, 0); triangle.graphics.lineTo(0, triangleSide); triangle.graphics.lineTo(triangleSide, triangleSide); triangle.graphics.lineTo(0, 0); addChild(triangle); trace(triangle.getBounds(this)); // (x=-10, y=-24.1, w=134.10000000000002, h=134.1) trace(triangle.getRect(this)); // (x=0, y=0, w=100, h=100)
getBounds()
globalToLocal3D 将二维点从舞台(全局)坐标转换为三维显示对象的(本地)坐标。具有相对于三维显示对象的坐标的 Vector3D 对象。 flash.geom:Vector3Dpointflash.geom:Point表示全局 x 坐标和 y 坐标的二维 Point 对象。 将二维点从舞台(全局)坐标转换为三维显示对象的(本地)坐标。

要使用此方法,请先创建 Point 类的一个实例。分配给 Point 对象的 x 和 y 值表示全局坐标,原因是这些坐标相对于主显示区域的原点 (0,0)。然后,将 Point 对象作为 point 参数传递给 globalToLocal3D() 方法。该方法会以一个 Vector3D 对象的形式返回三维坐标,该对象包含相对于三维显示对象的原点的 xyz 值。

globalToLocal 将 point 对象从舞台(全局)坐标转换为显示对象的(本地)坐标。具有相对于显示对象的坐标的 Point 对象。 flash.geom:Pointpointflash.geom:Point用 Point 类创建的对象。 该 Point 对象指定 xy 坐标作为属性。 point 对象从舞台(全局)坐标转换为显示对象的(本地)坐标。 point 对象从舞台(全局)坐标转换为显示对象的(本地)坐标。

要使用此方法,请先创建 Point 类的一个实例。您分配的 xy 值表示全局坐标,因为它们是相对于主显示区域的原点 (0,0) 的。然后将 Point 实例作为参数传递给 globalToLocal() 方法。该方法会返回一个新的 Point 对象,该对象具有相对于显示对象原点(而不是舞台原点)的 xy 值。

以下代码创建一个 Shape 对象,并显示使用不同点作为参数调用 hitTestPoint() 方法的结果。globalToLocal() 方法将点从 Stage 坐标转换到该形状的坐标空间: import flash.display.Shape; import flash.geom.Point; var circle:Shape = new Shape(); circle.graphics.beginFill(0x0000FF); circle.graphics.drawCircle(40, 40, 40); circle.x = 10; addChild(circle); var point1:Point = new Point(0, 0); trace(circle.hitTestPoint(point1.x, point1.y, true)); // false trace(circle.hitTestPoint(point1.x, point1.y, false)); // false trace(circle.globalToLocal(point1)); // [x=-10, y=0] var point2:Point = new Point(10, 1); trace(circle.hitTestPoint(point2.x, point2.y, true)); // false trace(circle.hitTestPoint(point2.x, point2.y, false)); // true trace(circle.globalToLocal(point2)); // [x=0, y=1] var point3:Point = new Point(30, 20); trace(circle.hitTestPoint(point3.x, point3.y, true)); // true trace(circle.hitTestPoint(point3.x, point3.y, false)); // true trace(circle.globalToLocal(point3)); // [x=20, y=20]
localToGlobal()flash.geom.Point 类
hitTestObject 计算显示对象的边框,以确定它是否与 obj 显示对象的边框重叠或相交。如果显示对象的边框相交,则为 true;否则为 falseBooleanobjflash.display:DisplayObject要测试的显示对象。 计算显示对象的边框,以确定它是否与作为参数传递的显示对象的边框重叠或相交。 计算显示对象的边框,以确定它是否与 obj 显示对象的边框重叠或相交。 以下代码创建三个 Shape 对象,并显示调用 hitTestObject() 方法的结果。请注意,尽管 circle2 和 circle3 并未重叠,但它们的边框重叠。因此,circle2 和 circle3 的点击测试返回 true import flash.display.Shape; var circle1:Shape = new Shape(); circle1.graphics.beginFill(0x0000FF); circle1.graphics.drawCircle(40, 40, 40); addChild(circle1); var circle2:Shape = new Shape(); circle2.graphics.beginFill(0x00FF00); circle2.graphics.drawCircle(40, 40, 40); circle2.x = 50; addChild(circle2); var circle3:Shape = new Shape(); circle3.graphics.beginFill(0xFF0000); circle3.graphics.drawCircle(40, 40, 40); circle3.x = 100; circle3.y = 67; addChild(circle3); trace(circle1.hitTestObject(circle2)); // true trace(circle1.hitTestObject(circle3)); // false trace(circle2.hitTestObject(circle3)); // true hitTestPoint 计算显示对象,以确定它是否与 x 和 y 参数指定的点重叠或相交。如果显示对象与指定的点重叠或相交,则为 true;否则为 falseBooleanxNumber要测试的此对象的 x 坐标。 yNumber要测试的此对象的 y 坐标。 shapeFlagBooleanfalse是检查对象 (true) 的实际像素,还是检查边框 (false) 的实际像素。 计算显示对象,以确定它是否与 x 和 y 指定的点重叠或相交。 计算显示对象,以确定它是否与 xy 参数指定的点重叠或相交。xy 参数指定舞台的坐标空间中的点,而不是包含显示对象的显示对象容器中的点(除非显示对象容器是舞台)。 以下代码创建一个 Shape 对象,并显示使用不同点作为参数调用 hitTestPoint() 方法的结果。globalToLocal() 方法将点从 Stage 坐标转换到该形状的坐标空间: import flash.display.Shape; import flash.geom.Point; var circle:Shape = new Shape(); circle.graphics.beginFill(0x0000FF); circle.graphics.drawCircle(40, 40, 40); circle.x = 10; addChild(circle); var point1:Point = new Point(0, 0); trace(circle.hitTestPoint(point1.x, point1.y, true)); // false trace(circle.hitTestPoint(point1.x, point1.y, false)); // false trace(circle.globalToLocal(point1)); // [x=-10, y=0] var point2:Point = new Point(10, 1); trace(circle.hitTestPoint(point2.x, point2.y, true)); // false trace(circle.hitTestPoint(point2.x, point2.y, false)); // true trace(circle.globalToLocal(point2)); // [x=0, y=1] var point3:Point = new Point(30, 20); trace(circle.hitTestPoint(point3.x, point3.y, true)); // true trace(circle.hitTestPoint(point3.x, point3.y, false)); // true trace(circle.globalToLocal(point3)); // [x=20, y=20] opaqueBackgroundlocal3DToGlobal 将三维显示对象的(本地)坐标的三维点转换为舞台(全局)坐标中的二维点。一个表示二维空间中的三维点的二维点。 flash.geom:Pointpoint3dflash.geom:Vector3D一个包含三维点或三维显示对象的坐标的 Vector3D 对象。 将三维显示对象的(本地)坐标的三维点转换为舞台(全局)坐标中的二维点。

例如,您只能使用二维坐标 (x,y) 来通过 display.Graphics 方法进行绘制。要绘制三维对象,您需要将显示对象的三维坐标映射到二维坐标。首先,创建一个保存三维显示对象的 x、y 和 z 坐标的 Vector3D 类的实例。然后,将 Vector3D 对象作为 point3d 参数传递给 local3DToGlobal() 方法。该方法会返回一个二维的 Point 对象,可将该对象与图形 API 一起使用来绘制三维对象。

本示例使用 display.Graphics 方法在二维空间中绘制简单的三维立方体。由于 this 显示对象的位置是偏移位置,因此立方体的注册点将位于其中心。Vector3D 对象的矢量保存立方体的三维坐标。首先绘制立方体的顶部,再绘制底部,然后将顶部的四个角与底部的四个角相连。您需要在绘制立方体之前先将其添加到显示对象容器中,这样才能使用 local3DToGlobal() 方法。 package { import flash.display.MovieClip; import flash.display.Sprite; import flash.display.Graphics; import flash.geom.*; public class Local3DToGlobalExample extends MovieClip { private var myCube:Sprite = new Sprite(); private var v8:Vector.<Vector3D> = new Vector.<Vector3D>(8); public function Local3DToGlobalExample():void { this.x = -(this.stage.stageWidth / 2); this.y = -(this.stage.stageWidth / 2); v8[0] = new Vector3D(-40,-40,-40); v8[1] = new Vector3D(40,-40,-40); v8[2] = new Vector3D(40,-40,40); v8[3] = new Vector3D(-40,-40,40); v8[4] = new Vector3D(-40,100,-40); v8[5] = new Vector3D(40,100,-40); v8[6] = new Vector3D(40,100,40); v8[7] = new Vector3D(-40,100,40); myCube.x = (this.stage.stageWidth / 2); myCube.y = (this.stage.stageWidth / 2); myCube.z = 1; addChild(myCube); Cube(); } private function Cube():void { var ps:Point = new Point(0,0); myCube.graphics.lineStyle(2,0xFF0000); ps = myCube.local3DToGlobal(v8[0]); myCube.graphics.moveTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[1]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[2]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[3]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[0]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[4]); myCube.graphics.moveTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[5]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[6]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[7]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[4]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[0]); myCube.graphics.moveTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[4]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[1]); myCube.graphics.moveTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[5]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[2]); myCube.graphics.moveTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[6]); myCube.graphics.lineTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[3]); myCube.graphics.moveTo(ps.x, ps.y); ps = myCube.local3DToGlobal(v8[7]); myCube.graphics.lineTo(ps.x, ps.y); } } }
localToGlobal 将 point 对象从显示对象的(本地)坐标转换为舞台(全局)坐标。具有相对于舞台的坐标的 Point 对象。 flash.geom:Pointpointflash.geom:Point使用 Point 类创建的点的名称或标识符,指定 xy 坐标作为属性。 point 对象从显示对象的(本地)坐标转换为舞台(全局)坐标。

此方法允许您将任何给定的 xy 坐标从相对于特定显示对象原点 (0,0) 的值(本地坐标)转换为相对于舞台原点的值(全局坐标)。

要使用此方法,请先创建 Point 类的一个实例。您分配的 xy 的值表示本地坐标,因为它们是相对于显示对象原点的值。

然后,您可以将创建的 Point 实例作为参数传递给 localToGlobal() 方法。该方法会返回一个新的 Point 对象,该对象具有相对于舞台原点(而不是显示对象原点)的 xy 值。

以下代码可创建一个 Sprite 对象。该 Sprite 对象的 mouseXmouseY 属性位于显示对象的坐标空间中。此代码使用 localToGlobal() 方法将这些属性转换为全局(舞台)坐标: import flash.display.Sprite; import flash.events.MouseEvent; import flash.geom.Point; var square:Sprite = new Sprite(); square.graphics.beginFill(0xFFCC00); square.graphics.drawRect(0, 0, 100, 100); square.x = 100; square.y = 200; addChild(square); square.addEventListener(MouseEvent.CLICK, traceCoordinates) function traceCoordinates(event:MouseEvent):void { var clickPoint:Point = new Point(square.mouseX, square.mouseY); trace("display object coordinates:", clickPoint); trace("stage coordinates:", square.localToGlobal(clickPoint)); }
globalToLocal()flash.geom.Point 类
accessibilityProperties 此显示对象的当前辅助功能选项。flash.accessibility:AccessibilityProperties 此显示对象的当前辅助功能选项。如果您修改 accessibilityProperties 属性或 accessibilityProperties 内部的任何字段,则必须调用 Accessibility.updateProperties() 方法以使您的更改生效。

请注意:对于在 Flash 创作环境中创建的对象,将使用您在“辅助功能”面板中为该对象输入的所有信息来填充 accessibilityProperties 的值。

下例演示如何将简单的 AccessibilityProperties 对象附加到 TextField 实例: import flash.text.TextField; import flash.accessibility.AccessibilityProperties; import flash.accessibility.Accessibility; import flash.system.Capabilities; var tf:TextField = new TextField(); tf.text = "hello"; var accessProps:AccessibilityProperties = new AccessibilityProperties(); accessProps.name = "Greeting"; tf.accessibilityProperties = accessProps; if (Capabilities.hasAccessibility) { Accessibility.updateProperties(); } trace(tf.accessibilityProperties.name); // Greeting
flash.accessibility.Accessibility.updateProperties()flash.accessibility.AccessibilityProperties
alpha 表示指定对象的 Alpha 透明度值。Number 表示指定对象的 Alpha 透明度值。有效值为 0(完全透明)到 1(完全不透明)。默认值为 1。alpha 设置为 0 的显示对象活动的,即使它们不可见。 当鼠标滑过 Sprite 时,以下代码将 Sprite 的 alpha 属性设置为 50%: import flash.display.Sprite; import flash.events.MouseEvent; var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xFF0000); circle.graphics.drawCircle(40, 40, 40); addChild(circle); circle.addEventListener(MouseEvent.MOUSE_OVER, dimObject); circle.addEventListener(MouseEvent.MOUSE_OUT, restoreObject); function dimObject(event:MouseEvent):void { event.target.alpha = 0.5; } function restoreObject(event:MouseEvent):void { event.target.alpha = 1.0; } blendMode BlendMode 类中的一个值,用于指定要使用的混合模式。String BlendMode 类中的一个值,用于指定要使用的混合模式。 内部绘制位图的方法有两种。如果启用了混合模式或外部剪辑遮罩,则将通过向矢量渲染器添加有位图填充的正方形来绘制位图。 如果尝试将此属性设置为无效值,则 Flash 运行时会将此值设置为 BlendMode.NORMAL

blendMode 属性影响显示对象的每个像素。每个像素都由三种原色(红色、绿色和蓝色)组成,每种原色的值介于 0x00 和 0xFF 之间。Flash Player 或 Adobe AIR 将影片剪辑中一个像素的每种原色与背景中像素的对应颜色进行比较。例如,如果 blendMode 设置为 BlendMode.LIGHTEN,则 Flash Player 或 Adobe AIR 会将显示对象的红色值与背景的红色值进行比较,然后使用两者中较亮的一种颜色作为显示颜色的红色成分的值。

下表将对 blendMode 设置进行说明。BlendMode 类定义可使用的字符串值。表中的插图显示应用于交叠于显示对象 (1) 之上的圆形显示对象 (2) 的 blendMode 值。

BlendMode 常量插图说明BlendMode.NORMAL该显示对象出现在背景前面。显示对象的像素值将覆盖背景的像素值。在显示对象为透明的区域,背景是可见的。BlendMode.LAYER强制为该显示对象创建一个透明度组。这意味着首先在临时缓冲区中预构建显示对象,然后再进行下一步处理。如果显示对象是使用位图缓存进行预缓存的,或显示对象是至少带有一个子对象(具有 BlendMode.NORMAL 以外的 blendMode 设置)的显示对象容器,则这将自动完成。在 GPU 呈现下不支持。 BlendMode.MULTIPLY将显示对象原色的值与背景颜色的值相乘,然后通过除以 0xFF 进行标准化,从而得到较暗的颜色。此设置通常用于阴影和深度效果。

例如,如果显示对象中一个像素的某个原色(例如红色)与背景中对应的像素颜色的值均为 0x88,则相乘结果为 0x4840。除以 0xFF 将得到该原色的值 0x48,这是比显示对象或背景颜色暗的阴影。

BlendMode.SCREEN将显示对象颜色的补色(反色)与背景颜色的补色相乘,会产生漂白效果。此设置通常用于产生加亮效果或用来删除显示对象的黑色区域。BlendMode.LIGHTEN在显示对象原色和背景颜色中选择相对较亮的颜色(具有较大值的颜色)。此设置通常用于叠加类型。

例如,如果显示对象的某个像素的 RGB 值为 0xFFCC33,背景像素的 RGB 值为 0xDDF800,则显示像素的结果 RGB 值为 0xFFF833(因为 0xFF > 0xDD,0xCC < 0xF8,且 0x33 > 0x00 = 33)。在 GPU 呈现下不支持。

BlendMode.DARKEN在显示对象原色和背景颜色中选择相对较暗的颜色(具有较小值的颜色)。此设置通常用于叠加类型。

例如,如果显示对象的某个像素的 RGB 值为 0xFFCC33,背景像素的 RGB 值为 0xDDF800,则显示像素的结果 RGB 值为 0xDDCC00(因为 0xFF > 0xDD,0xCC < 0xF8,且 0x33 > 0x00 = 33)。在 GPU 呈现下不支持。

BlendMode.DIFFERENCE将显示对象的原色与背景颜色进行比较,然后从较亮的原色值中减去较暗的原色值。此设置通常用于得到更明亮的颜色。

例如,如果显示对象的某个像素的 RGB 值为 0xFFCC33,背景像素的 RGB 值为 0xDDF800,则显示像素的结果 RGB 值为 0x222C33(因为 0xFF - 0xDD = 0x22,0xF8 - 0xCC = 0x2C,且 0x33 - 0x00 = 0x33)。

BlendMode.ADD将显示对象的原色值添加到它的背景颜色中,上限值为 0xFF。此设置通常用于使两个对象间的加亮溶解产生动画效果。

例如,如果显示对象的某个像素的 RGB 值为 0xAAA633,背景像素的 RGB 值为 0xDD2200,则显示像素的结果 RGB 值为 0xFFC833(因为 0xAA + 0xDD > 0xFF,0xA6 + 0x22 = 0xC8,且 0x33 + 0x00 = 0x33)。

BlendMode.SUBTRACT从背景颜色的值中减去显示对象原色的值,下限值为 0。此设置通常用于使两个对象间的变暗溶解产生动画效果。

例如,如果显示对象的某个像素的 RGB 值为 0xAA2233,背景像素的 RGB 值为 0xDDA600,则显示像素的结果 RGB 值为 0x338400(因为 0xDD - 0xAA = 0x33,0xA6 - 0x22 = 0x84 且 0x00 - 0x33 < 0x00)。

BlendMode.INVERT反转背景。BlendMode.ALPHA将显示对象的每个像素的 Alpha 值应用于背景。这要求将父显示对象的 blendMode 设置设置为 BlendMode.LAYER。例如,在此插图中,父显示对象是一个白色背景,它具有 blendMode = BlendMode.LAYER。在 GPU 呈现下不支持。BlendMode.ERASE根据显示对象的 Alpha 值擦除背景。这要求将父显示对象的 blendMode 设置为 BlendMode.LAYER。例如,在此插图中,父显示对象是一个白色背景,它具有 blendMode = BlendMode.LAYER。在 GPU 呈现下不支持。BlendMode.OVERLAY根据背景的暗度调整每个像素的颜色。如果背景灰度值高于 50%,则显示对象和背景颜色进行叠加,从而产生较亮的颜色。如果背景灰度值低于 50%,则颜色相乘,从而产生较暗的颜色。此设置通常用于获得阴影效果。在 GPU 呈现下不支持。BlendMode.HARDLIGHT根据显示对象的暗度调整每个像素的颜色。如果显示对象灰度值高于 50%,则显示对象和背景颜色进行叠加,从而产生较亮的颜色。如果显示对象灰度值低于 50%,则颜色相乘,从而产生较暗的颜色。此设置通常用于获得阴影效果。在 GPU 呈现下不支持。BlendMode.SHADER不适用使用自定义着色器例程调整颜色。将使用的着色器指定为赋予 blendShader 属性的 Shader 实例。如果将显示对象的 blendShader 属性设置为 Shader 实例,则会将显示对象的 blendMode 属性自动设置为 BlendMode.SHADER。如果在未首先设置 blendShader 属性的情况下将 blendMode 属性设置为 BlendMode.SHADER,则 blendMode 属性会设置为 BlendMode.NORMAL。在 GPU 呈现下不支持。
以下代码创建两个 Sprite 对象,一个正方形和一个圆形,并在鼠标指针滑过圆形时将圆形(在前景中)的混合模式设置为 BlendMode.SUBTRACT import flash.display.Sprite; import flash.display.BlendMode; import flash.events.MouseEvent; var square:Sprite = new Sprite(); square.graphics.beginFill(0xFF88CC); square.graphics.drawRect(0, 0, 80, 80); addChild(square); var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xAA0022); circle.graphics.drawCircle(40, 40, 40); addChild(circle); circle.addEventListener(MouseEvent.MOUSE_OVER, dimObject); circle.addEventListener(MouseEvent.MOUSE_OUT, restoreObject); function dimObject(event:MouseEvent):void { event.target.blendMode = BlendMode.SUBTRACT; } function restoreObject(event:MouseEvent):void { event.target.blendMode = BlendMode.NORMAL; }
flash.display.BlendModeblendShader
cacheAsBitmapMatrix 如果为非 null,则 Matrix 对象会定义显示对象在 cacheAsBitmap 设置为 true 时的呈现方式。flash.geom:Matrix呈现此显示对象的位图的缓存版本时使用的转换矩阵。 如果为非 null,则 Matrix 对象会定义显示对象在 cacheAsBitmap 设置为 true 时的呈现方式。应用程序使用此矩阵作为呈现显示对象的位图版本时应用的转换矩阵。

AIR 配置文件支持:移动设备支持此功能,但桌面操作系统不支持此功能。另外,它对于用于电视的 AIR 设备只有有限的支持。具体而言,在用于电视的 AIR 设备上,仅支持缩放和平移转换,但是不支持旋转和倾斜。有关在多个配置文件之间支持 API 的详细信息,请参阅 AIR 配置文件支持

使用 cacheAsBitmapMatrix 设置,应用程序将保留经过各种 2D 变形的缓存位图图像,包括平移、旋转和缩放。如果应用程序使用硬件加速,则对象将作为纹理存储在视频内存中。这样可允许 GPU 对对象应用受支持的变形。GPU 执行这些转换的速度比 CPU 快。

要使用硬件加速功能,请在 Flash Professional CS5 中的“iPhone 设置”对话框的“常规”选项卡上将“呈现”设置为 GPU。或在应用程序描述符文件中将 renderMode 属性设置为 gpu。请注意,用于电视的 AIR 设备将自动使用硬件加速(如果可用)。

例如,以下代码将显示对象的未转换的位图表示形式发送到 GPU:

matrix:Matrix = new Matrix(); // creates an identity matrix mySprite.cacheAsBitmapMatrix = matrix; mySprite.cacheAsBitmap = true;

通常,恒等矩阵 (new Matrix()) 就足够了。但是,您可以使用其他矩阵(例如按比例缩小的矩阵)将其他位图上载到 GPU。例如,以下示例应用了对 x 轴和 y 轴按 0.5 缩放的 cacheAsBitmapMatrix 矩阵。GPU 使用的位图对象较小,但是,GPU 将调整其大小,以便与显示对象的 transform.matrix 属性相匹配:

matrix:Matrix = new Matrix(); // creates an identity matrix matrix.scale(0.5, 0.5); // scales the matrix mySprite.cacheAsBitmapMatrix = matrix; mySprite.cacheAsBitmap = true;

通常,您应该选择使用将显示对象的大小转换为在应用程序显示大小的矩阵。例如,如果您的应用程序将 Sprite 的位图版本显示为原来的一半,则应该使用缩小一半的矩阵。如果您的应用程序显示的 Sprite 大于其当前尺寸,则应该使用放大该系数的矩阵。

注意:cacheAsBitmapMatrix 属性适用于 2D 变形。如果需要在 3D 中应用变形,您可能需要通过设置对象的 3D 属性,并且处理它的 transform.matrix3D 属性来应用变形。如果使用 GPU 模式打包应用程序,则允许 GPU 对对象应用 3D 变形。3D 对象将忽略 cacheAsBitmapMatrix

以下示例使用 cacheAsBitmapMatrix 属性对影片剪辑 my_shape 的位图版本进行转换。 import flash.geom.Matrix; import flash.display.*; import flash.utils.Timer; var my_shape:MovieClip = new MovieClip(); my_shape.graphics.beginFill(0xCCFF00); my_shape.graphics.drawRect(200, 0, 100, 100); addChild(my_shape); var my_timer:Timer = new Timer(250); my_timer.start(); my_timer.addEventListener(TimerEvent.TIMER, timerHandler); // make sure this Display Object remains cached for all 2D transforms my_shape.cacheAsBitmap = true; my_shape.cacheAsBitmapMatrix = new Matrix(); // rotation variables const initAngle:Number = 0; const pi:Number = 3.142; const incrAngle:Number = pi/10; // scaling variables const initScale:Number = 0.25; const incrScale: Number = 1.1; var initHeight : Number = my_shape.height; var initWidth : Number = my_shape.width; // translation variables var incrX : Number = root.width / 20; var incrY : Number = root.height / 10; // do some initial transforms var tempMat : Matrix = my_shape.transform.matrix; tempMat.rotate(initAngle); tempMat.scale(initScale, initScale); my_shape.transform.matrix = tempMat; function timerHandler(evt:TimerEvent):void { tempMat = my_shape.transform.matrix; tempMat.rotate(incrAngle); tempMat.translate(incrX, incrY); tempMat.scale(incrScale, incrScale); my_shape.transform.matrix = tempMat; // ensure we are still in a reasonable state or reset if(my_shape.height > stage.stageHeight/2) { my_shape.height = initHeight; } if(my_shape.width > stage.stageWidth/2) { my_shape.width = initWidth; } if(my_shape.x > stage.stageWidth) { my_shape.x = 0; } else if (my_shape.x < 0) { my_shape.x = stage.stageWidth; } if(my_shape.y > stage.stageHeight) { my_shape.y = 0; } else if (my_shape.y < 0) { my_shape.y = stage.stageHeight; } }
cacheAsBitmapflash.geom.Matrix3D
cacheAsBitmap 如果设置为 true,则 Flash 运行时将缓存显示对象的内部位图表示形式。Boolean是否将此 DisplayObject 缓存为位图。 如果设置为 true,则 Flash 运行时将缓存显示对象的内部位图表示形式。此缓存可以提高包含复杂矢量内容的显示对象的性能。

具有已缓存位图的显示对象的所有矢量数据都将被绘制到位图而不是主显示。如果 cacheAsBitmapMatrix 为空或不受支持,位图将作为与最近的像素边界对齐的未拉伸且未旋转的像素复制到主显示。像素按一对一与父对象进行映射。如果位图的边界发生更改,则将重新创建位图而不会拉伸它。

如果支持 cacheAsBitmapMatrix,并且它为非空,则对象将使用该矩阵绘制到屏幕范围外的位图,并且使用该呈现的拉伸和/或旋转结果将对象绘制到主显示。

除非将 cacheAsBitmap 属性设置为 true,否则不会创建内部位图。

cacheAsBitmap 属性设置为 true 后,呈现并不更改,但是,显示对象将自动执行像素贴紧。动画速度可能会大大加快,具体取决于矢量内容的复杂性。

只要对显示对象(当其 filter 数组不为空时)应用滤镜,cacheAsBitmap 属性就自动设置为 true,而且如果对显示对象应用了滤镜,即使将该属性设置为 false,也会将该显示对象的 cacheAsBitmap 报告为 true。如果清除显示对象的所有滤镜,则 cacheAsBitmap 设置将更改为它上次的设置。

在下面的情况下,即使将 cacheAsBitmap 属性设置为 true,显示对象也不使用位图,而是从矢量数据呈现:

  • 位图过大。在 AIR 1.5 和 Flash Player 10 中,位图图像的最大宽度或高度为 8,191 像素,并且像素总数不能超过 16,777,215 像素。(因此,如果位图图像的宽度为 8,191 像素,则其高度只能为 2,048 像素。)在 Flash Player 9 及早期版本中,高度最大为 2880 像素,宽度最大为 2,880 像素。
  • 位图无法分配(内存不足错误)。

最好将 cacheAsBitmap 属性与主要具有静态内容且不频繁缩放和旋转的影片剪辑一起使用。对于这样的影片剪辑,在转换影片剪辑时(更改其 xy 位置时),cacheAsBitmap 可以提高性能。

下例将投影应用于 Shape 实例。然后,它将跟踪 cacheAsBitmap 属性的值,该值在应用滤镜时设置为 true import flash.display.Sprite; import flash.filters.DropShadowFilter var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xAA0022); circle.graphics.drawCircle(40, 40, 40); addChild(circle); trace(circle.cacheAsBitmap); // false var filter:DropShadowFilter = new DropShadowFilter(); circle.filters = [filter]; trace(circle.cacheAsBitmap); // true
cacheAsBitmapMatrixopaqueBackground
filters 包含当前与显示对象关联的每个滤镜对象的索引数组。Arrayfilters 包括 ShaderFilter,并且着色器输出类型与此操作不兼容时(着色器必须指定 pixel4 输出)。 ArgumentErrorArgumentErrorfilters 包括 ShaderFilter,并且着色器未指定任何图像输入或第一个输入不是 image4 输入时。 ArgumentErrorArgumentErrorfilters 包括 ShaderFilter,并且着色器指定了未提供的图像输入时。 ArgumentErrorArgumentErrorfilters 包括 ShaderFilter,使用了 ByteArray 或 Vector.<Number> 实例作为着色器输入,没有为 ShaderInput 对象指定 widthheight 属性,或者指定的值与输入数据中的数据量不匹配。有关详细信息,请参阅 ShaderInput.input 属性。 ArgumentErrorArgumentError 包含当前与显示对象关联的每个滤镜对象的索引数组。flash.filters 包中的多个类定义了可使用的特定滤镜。

在设计时或在运行时,可通过使用 ActionScript 代码在 Flash Professional 中应用筛选器。要通过使用 ActionScript 应用滤镜,您必须制作整个 filters 数组的临时副本,修改临时数组,然后将临时数组的值分配回 filters 数组。无法直接将新滤镜对象添加到 filters 数组。

要通过使用 ActionScript 添加滤镜,请执行以下步骤(假定目标显示对象名为 myDisplayObject):

  1. 使用所选滤镜类的构造函数方法创建一个新的滤镜对象。
  2. myDisplayObject.filters 数组的值分配给临时数组,例如一个名为 myFilters 的数组。
  3. 将新的滤镜对象添加到临时数组 myFilters
  4. 将临时数组的值分配给 myDisplayObject.filters 数组。

如果 filters 数组未定义,则无需使用临时数组。相反,您可以直接赋值包含一个或多个已创建的滤镜对象的一个数组文本值。“示例”部分的第一个示例通过使用处理已定义和未定义的 filters 数组的代码来添加投影滤镜。

要修改现有的滤镜对象,必须使用修改 filters 数组的副本的技术:

  1. filters 数组的值分配给临时数组,例如一个名为 myFilters 的数组。
  2. 使用临时数组 myFilters 修改属性。例如,如果要设置数组中第一个滤镜的品质属性,可以使用以下代码:myFilters[0].quality = 1;
  3. 将临时数组的值分配给 filters 数组。

在加载时,如果显示对象具有关联的滤镜,则将它标记为像透明位图那样缓存自身。从此时起,只要显示对象具有有效的滤镜列表,播放器就会将显示对象缓存为位图。此源位图用作滤镜效果的源图像。每个显示对象通常有两个位图:一个包含原始未过滤的源显示对象,另一个是过滤后的最终图像。呈现时使用最终图像。只要显示对象不发生更改,最终图像就不需要更新。

flash.filters 包含有滤镜类。例如,要创建 DropShadow 滤镜,请输入:

import flash.filters.DropShadowFilter var myFilter:DropShadowFilter = new DropShadowFilter (distance, angle, color, alpha, blurX, blurY, quality, inner, knockout)

您可以使用 is 运算符确定分配给 filter 数组中每个索引位置的滤镜的类型。例如,以下代码显示如何确定是 DropShadowFilter 的 filters 数组中第一个滤镜的位置:

import flash.text.TextField; import flash.filters.~~; var tf:TextField = new TextField(); var filter1:DropShadowFilter = new DropShadowFilter(); var filter2:GradientGlowFilter = new GradientGlowFilter(); tf.filters = [filter1, filter2]; tf.text = "DropShadow index: " + filterPosition(tf, DropShadowFilter).toString(); // 0 addChild(tf) function filterPosition(displayObject:DisplayObject, filterClass:Class):int { for (var i:uint = 0; i < displayObject.filters.length; i++) { if (displayObject.filters[i] is filterClass) { return i; } } return -1; }

注意:由于无法直接将新滤镜对象添加到 DisplayObject.filters 数组,因此以下代码对名为 myDisplayObject 的目标显示对象不起作用:

myDisplayObject.filters.push(myDropShadow);
flash.filters packageflash.display.ShaderInput.input
height 表示显示对象的高度,以像素为单位。Number 表示显示对象的高度,以像素为单位。高度是根据显示对象内容的范围来计算的。如果您设置了 height 属性,则 scaleY 属性会相应调整,如以下代码所示: var rect:Shape = new Shape(); rect.graphics.beginFill(0xFF0000); rect.graphics.drawRect(0, 0, 100, 100); trace(rect.scaleY) // 1; rect.height = 200; trace(rect.scaleY) // 2;

除 TextField 和 Video 对象以外,没有内容的显示对象(如一个空的 Sprite)的高度为 0,即使您尝试将 height 设置为其他值,也是这样。

以下代码创建两个 TextField 对象并调整每个对象的 height 属性(基于每个对象的 textHeight 属性);此外,它还通过设置其 y 属性来定位第二个文本字段: import flash.text.TextField; var tf1:TextField = new TextField(); tf1.text = "Text Field 1"; tf1.border = true; tf1.wordWrap = true; tf1.width = 40; tf1.height = tf1.textHeight + 5; addChild(tf1); var tf2:TextField = new TextField(); tf2.text = "Text Field 2"; tf2.border = true; tf2.wordWrap = true; tf2.width = 40; tf2.height = tf2.textHeight + 5; tf2.y = tf1.y + tf1.height + 5; addChild(tf2);
loaderInfo 返回一个 LoaderInfo 对象,其中包含加载此显示对象所属的文件的相关信息。flash.display:LoaderInfo 返回一个 LoaderInfo 对象,其中包含加载此显示对象所属的文件的相关信息。loaderInfo 属性仅为 SWF 文件的根显示对象或已加载的位图(而不是使用 ActionScript 绘制的位图)定义。要查找与包含名为 myDisplayObject 的显示对象的 SWF 文件相关的 loaderInfo 对象,请使用 myDisplayObject.root.loaderInfo

大的 SWF 文件可以通过调用 this.root.loaderInfo.addEventListener(Event.COMPLETE, func) 来监控其下载。

以下代码假定 this 引用显示对象。代码会输出该显示对象的根 SWF 文件的 URL: trace (this.loaderInfo.url);
LoaderInfo 类
mask 调用显示对象被指定的 mask 对象遮罩。flash.display:DisplayObject为显示对象设置蒙版。 调用显示对象被指定的 mask 对象遮罩。要确保当舞台缩放时蒙版仍然有效,mask 显示对象必须处于显示列表的活动部分。但不绘制 mask 对象本身。将 mask 设置为 null 可删除蒙版。

要能够缩放遮罩对象,它必须在显示列表中。要能够拖动蒙版 Sprite 对象(通过调用其 startDrag() 方法),它必须在显示列表中。要为基于 sprite 正在调度的 mouseDown 事件调用 startDrag() 方法,请将 sprite 的 buttonMode 属性设置为 true

通过将 cacheAsBitmap 属性设置为 true,将 cacheAsBitmapMatrix 属性设置为 Matrix 对象来缓存显示对象时,遮罩对象和被遮罩的显示对象必须是同一缓存位图的一部分。因此,如果缓存显示对象,则遮罩必须是显示对象的子级。如果缓存显示列表上的显示对象的祖代,则遮罩必须是该祖代的子级或其后代之一。如果缓存遮罩对象的多个祖先,则遮罩必须是显示列表中离遮罩对象最近的缓存容器的后代。

注意:单个 mask 对象不能用于遮罩多个执行调用的显示对象。在将 mask 分配给第二个显示对象时,会撤消其作为第一个对象的遮罩,该对象的 mask 属性将变为 null

以下代码创建 TextField 对象以及被设置为 TextField 对象的遮罩的 Sprite 对象。当用户单击文本字段时,drag() 事件侦听器函数会调用遮罩 Sprite 对象的 startDrag() 方法: import flash.text.TextField; import flash.display.Sprite; import flash.events.MouseEvent; var tf:TextField = new TextField(); tf.text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, " + "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. " tf.selectable = false; tf.wordWrap = true; tf.width = 150; addChild(tf); var square:Sprite = new Sprite(); square.graphics.beginFill(0xFF0000); square.graphics.drawRect(0, 0, 40, 40); addChild(square); tf.mask = square; tf.addEventListener(MouseEvent.MOUSE_DOWN, drag); tf.addEventListener(MouseEvent.MOUSE_UP, noDrag); function drag(event:MouseEvent):void { square.startDrag(); } function noDrag(event:MouseEvent):void { square.stopDrag(); }
mouseX 表示此鼠标或用户输入设备位置的 x 坐标,以像素为单位。Number 表示此鼠标或用户输入设备位置的 x 坐标,以像素为单位。

注意:对于已旋转的 DisplayObject,返回的 x 坐标将反映未旋转的对象。

以下代码创建一个 Sprite 对象,并在用户单击该对象时跟踪 mouseXmouseY 的位置: import flash.display.Sprite; import flash.events.MouseEvent; var square:Sprite = new Sprite(); square.graphics.beginFill(0xFF0000); square.graphics.drawRect(0, 0, 200, 200); addChild(square); square.addEventListener(MouseEvent.CLICK, traceCoordinates); function traceCoordinates(event:MouseEvent):void { trace(square.mouseX, square.mouseY); }
mouseY 表示此鼠标或用户输入设备位置的 y 坐标,以像素为单位。Number 表示此鼠标或用户输入设备位置的 y 坐标,以像素为单位。

注意:对于已旋转的 DisplayObject,返回的 y 坐标将反映未旋转的对象。

以下代码创建一个 Sprite 对象,并在用户单击该对象时跟踪 mouseXmouseY 的位置: import flash.display.Sprite; import flash.events.MouseEvent; var square:Sprite = new Sprite(); square.graphics.beginFill(0xFF0000); square.graphics.drawRect(0, 0, 200, 200); addChild(square); square.addEventListener(MouseEvent.CLICK, traceCoordinates); function traceCoordinates(event:MouseEvent):void { trace(square.mouseX, square.mouseY); }
name 表示 DisplayObject 的实例名称。String如果尝试在 Flash 创作工具中对放置在时间轴上的对象设置此属性。 IllegalOperationErrorflash.errors:IllegalOperationError此 DisplayObject 的名称。 表示 DisplayObject 的实例名称。通过调用父显示对象容器的 getChildByName() 方法,可以在父显示对象容器的子列表中标识该对象。 以下代码创建两个 Sprite 对象,并跟踪相关的 name 属性(当用户单击其中一个对象时): import flash.display.Sprite; import flash.events.MouseEvent; var circle1:Sprite = new Sprite(); circle1.graphics.beginFill(0xFF0000); circle1.graphics.drawCircle(40, 40, 40); circle1.name = "circle1"; addChild(circle1); circle1.addEventListener(MouseEvent.CLICK, traceName); var circle2:Sprite = new Sprite(); circle2.graphics.beginFill(0x0000FF); circle2.graphics.drawCircle(140, 40, 40); circle2.name = "circle2"; addChild(circle2); circle2.addEventListener(MouseEvent.CLICK, traceName); function traceName(event:MouseEvent):void { trace(event.target.name); } opaqueBackground 指定显示对象是否由于具有某种背景颜色而不透明。Object 指定显示对象是否由于具有某种背景颜色而不透明。透明的位图包含 Alpha 通道数据,并以透明的方式进行绘制。不透明位图没有 Alpha 通道(呈现速度比透明位图快)。如果位图是不透明的,则您可以指定要使用的其自己的背景颜色。

如果设置为某个数值,则表面是不透明的,并且带有该数值指定的 RGB 背景颜色。如果设置为 null(默认值),则显示对象将有透明背景。

opaqueBackground 属性主要与 cacheAsBitmap 属性一起使用,以优化呈现。对于 cacheAsBitmap 属性设置为 true 的显示对象,设置 opaqueBackground 可以提高呈现性能。

如果在 shapeFlag 参数设置为 true 时调用 hitTestPoint() 方法,则不透明的背景区域 匹配。

不透明背景区域不响应鼠标事件。

以下代码创建一个具有蓝色圆形的 Shape 对象,并将其 opaqueBackground 属性设置为红色 (0xFF0000): import flash.display.Shape; var circle:Shape = new Shape(); circle.graphics.beginFill(0x0000FF); circle.graphics.drawCircle(40, 40, 40); circle.opaqueBackground = 0xFF0000; addChild(circle);
cacheAsBitmaphitTestPoint()
parent 表示包含此显示对象的 DisplayObjectContainer 对象。flash.display:DisplayObjectContainer父显示对象属于您无权访问的安全沙箱。通过让父影片调用 Security.allowDomain() 方法,可以避免发生这种情况。 SecurityErrorSecurityError 表示包含此显示对象的 DisplayObjectContainer 对象。使用 parent 属性可以指定高于显示列表层次结构中当前显示对象的显示对象的相对路径。

可以使用 parent 在显示列表中上移多个级别,如下所示:

this.parent.parent.alpha = 20;
以下代码创建三个 Sprite 对象,并显示 parent 属性如何反映显示列表层次结构: import flash.display.Sprite; var sprite1:Sprite = new Sprite(); sprite1.name = "sprite1"; var sprite2:Sprite = new Sprite(); sprite2.name = "sprite2"; var sprite3:Sprite = new Sprite(); sprite3.name = "sprite3"; sprite1.addChild(sprite2); sprite2.addChild(sprite3); trace(sprite2.parent.name); // sprite1 trace(sprite3.parent.name); // sprite2 trace(sprite3.parent.parent.name); // sprite1
root 对于加载的 SWF 文件中的显示对象,root 属性是此 SWF 文件所表示的显示列表树结构部分中的顶级显示对象。flash.display:DisplayObject返回此对象的根显示对象。 对于加载的 SWF 文件中的显示对象,root 属性是此 SWF 文件所表示的显示列表树结构部分中的顶级显示对象。对于代表已加载图像文件的位图对象,root 属性就是位图对象本身。对于第一个加载的 SWF 文件的主类的实例,root 属性就是显示对象本身。Stage 对象的 root 属性是 Stage 对象本身。对于任何未添加到显示列表的显示对象,root 属性设置为 null,除非它已添加到符合以下条件的显示对象容器:不在显示列表中,但属于已加载 SWF 文件中顶级显示对象的子级。

例如,如果您通过调用 Sprite() 构造函数方法创建新的 Sprite 对象,则其 root 属性将为 null,除非您将其添加到显示列表中(或添加到不在显示列表中但属于 SWF 文件中顶级显示对象的子级的显示对象容器中)。

对于加载的 SWF 文件,即使用于加载文件的 Loader 对象未在显示列表中,SWF 文件中的顶级显示对象也会为其本身设置 root 属性。在 Loader 对象添加为对其设置 root 属性的显示对象的子级前,它不会设置自己的 root 属性。

以下代码显示 Stage 对象、未加载的(添加到显示列表前后)显示对象(Loader 对象)和已加载对象(已加载 Bitmap 对象)的 root 属性之间的差异: import flash.display.Loader; import flash.net.URLRequest; import flash.events.Event; trace(stage.root); // [object Stage] var ldr:Loader = new Loader(); trace (ldr.root); // null addChild(ldr); trace (ldr.root); // [object ...] var urlReq:URLRequest = new URLRequest("example.jpg"); ldr.load(urlReq); ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, loaded); function loaded(event:Event):void { trace(ldr.content.root); // [object Bitmap] }
rotationX 表示 DisplayObject 实例相对于 3D 父容器距离其原始方向的 x 轴旋转(以度为单位)。Number 表示 DisplayObject 实例相对于 3D 父容器距离其原始方向的 x 轴旋转(以度为单位)。从 0 到 180 的值表示顺时针方向旋转;从 0 到 -180 的值表示逆时针方向旋转。对于此范围之外的值,可以通过加上或减去 360 获得该范围内的值。 在本示例中,两个椭圆使用其 rotationXrotationY 属性进行旋转。第一个椭圆的注册点设置为椭圆的中心点。它围绕自身进行旋转。第二个椭圆围绕一个外部点进行旋转。 package { import flash.display.MovieClip; import flash.display.Shape; import flash.geom.*; import flash.display.Graphics; import flash.events.TimerEvent; import flash.utils.Timer; public class RotationExample1 extends MovieClip { private var ellipse:Shape = new Shape(); private var speed:int = 10; private var ellipse1:Shape; private var ellipse2:Shape; public function RotationExample1():void { ellipse1 = drawEllipse(-50, -40, (this.stage.stageWidth / 2), (this.stage.stageHeight / 2)); ellipse2 = drawEllipse(30, 40, (this.stage.stageWidth / 2), (this.stage.stageHeight / 2)); this.addChild(ellipse1); this.addChild(ellipse2); var t:Timer = new Timer(50); t.addEventListener(TimerEvent.TIMER, timerHandler); t.start(); } private function drawEllipse(x1, y1, x2, y2):Shape { var e:Shape = new Shape(); e.graphics.beginFill(0xFF0000); e.graphics.lineStyle(2); e.graphics.drawEllipse(x1, y1, 100, 80); e.graphics.endFill(); e.x = x2; e.y = y2; e.z = 1; return e; } private function timerHandler(event:TimerEvent):void { ellipse1.rotationY += speed; ellipse1.rotationX -= speed; ellipse2.rotationY += speed; ellipse2.rotationX -= speed; } } } 以下示例显示如何通过设置 Sprite 对象的 rotationX 属性使用 Flash Professional、ActionScript 3.0 和 Flash Player 10 使对象绕其 x 轴进行 3D 旋转。ActionScriptExamples.com 提供的示例。 //Requires: // - Slider control UI component in Flash library. // - Publish for Flash Player 10. // [SWF(width="400", height="300")] import fl.controls.Slider; import fl.controls.SliderDirection; import fl.events.SliderEvent; var slider:Slider = new Slider(); slider.direction = SliderDirection.HORIZONTAL; slider.minimum = 0; slider.maximum = 360; slider.value = 45; slider.tickInterval = 45; slider.snapInterval = 1; slider.liveDragging = true; slider.addEventListener(SliderEvent.CHANGE, slider_change); slider.move(10, 10); addChild(slider); var spr:Sprite = new Sprite(); spr.graphics.lineStyle(2, 0xFF0000); spr.graphics.drawRect(0, 0, 100, 80); spr.x = Math.round((stage.stageWidth - spr.width)/2); spr.y = Math.round((stage.stageHeight - spr.height)/2); spr.rotationX = 45; addChild(spr); function slider_change(evt:SliderEvent):void { spr.rotationX = evt.value; } rotationY 表示 DisplayObject 实例相对于 3D 父容器距离其原始方向的 y 轴旋转(以度为单位)。Number 表示 DisplayObject 实例相对于 3D 父容器距离其原始方向的 y 轴旋转(以度为单位)。从 0 到 180 的值表示顺时针方向旋转;从 0 到 -180 的值表示逆时针方向旋转。对于此范围之外的值,可以通过加上或减去 360 获得该范围内的值。 在本示例中,两个椭圆使用其 rotationXrotationY 属性进行旋转。第一个椭圆的注册点设置为椭圆的中心点。它围绕自身进行旋转。第二个椭圆围绕一个外部点进行旋转。 package { import flash.display.MovieClip; import flash.display.Shape; import flash.geom.*; import flash.display.Graphics; import flash.events.TimerEvent; import flash.utils.Timer; public class RotationExample1 extends MovieClip { private var ellipse:Shape = new Shape(); private var speed:int = 10; private var ellipse1:Shape; private var ellipse2:Shape; public function RotationExample1():void { ellipse1 = drawEllipse(-50, -40, (this.stage.stageWidth / 2), (this.stage.stageHeight / 2)); ellipse2 = drawEllipse(30, 40, (this.stage.stageWidth / 2), (this.stage.stageHeight / 2)); this.addChild(ellipse1); this.addChild(ellipse2); var t:Timer = new Timer(50); t.addEventListener(TimerEvent.TIMER, timerHandler); t.start(); } private function drawEllipse(x1, y1, x2, y2):Shape { var e:Shape = new Shape(); e.graphics.beginFill(0xFF0000); e.graphics.lineStyle(2); e.graphics.drawEllipse(x1, y1, 100, 80); e.graphics.endFill(); e.x = x2; e.y = y2; e.z = 1; return e; } private function timerHandler(event:TimerEvent):void { ellipse1.rotationY += speed; ellipse1.rotationX -= speed; ellipse2.rotationY += speed; ellipse2.rotationX -= speed; } } } rotationZ 表示 DisplayObject 实例相对于 3D 父容器距离其原始方向的 z 轴旋转(以度为单位)。Number 表示 DisplayObject 实例相对于 3D 父容器距离其原始方向的 z 轴旋转(以度为单位)。从 0 到 180 的值表示顺时针方向旋转;从 0 到 -180 的值表示逆时针方向旋转。对于此范围之外的值,可以通过加上或减去 360 获得该范围内的值。 rotation 表示 DisplayObject 实例距其原始方向的旋转程度,以度为单位。Number 表示 DisplayObject 实例距其原始方向的旋转程度,以度为单位。从 0 到 180 的值表示顺时针方向旋转;从 0 到 -180 的值表示逆时针方向旋转。对于此范围之外的值,可以通过加上或减去 360 获得该范围内的值。例如,my_video.rotation = 450语句与 my_video.rotation = 90 是相同的。 以下代码可创建一个 Sprite 对象并在用户单击该对象时旋转它: import flash.display.Sprite; import flash.events.MouseEvent; var square:Sprite = new Sprite(); square.graphics.beginFill(0xFFCC00); square.graphics.drawRect(-50, -50, 100, 100); square.x = 150; square.y = 150; addChild(square); square.addEventListener(MouseEvent.CLICK, rotate); function rotate(event:MouseEvent):void { square.rotation += 15; } scale9Grid 当前有效的缩放网格。flash.geom:Rectangle如果向方法传递的参数无效。 ArgumentErrorArgumentError 当前有效的缩放网格。如果设置为 null,则在应用任何缩放转换时,将正常缩放整个显示对象。

当定义 scale9Grid 属性时,该显示对象被分割到以 scale9Grid 矩形为基础的具有九个区域的网格中,该矩形定义网格的中心区域。网格的其他八个区域如下所示:

  • 矩形外的左上角
  • 矩形上方的区域
  • 矩形外的右上角
  • 矩形左侧的区域
  • 矩形右侧的区域
  • 矩形外的左下角
  • 矩形下方的区域
  • 矩形外的右下角

可以认为中心区域(由矩形定义)之外的八个区域类似于在缩放时已应用特殊规则的图片帧。

在设置 scale9Grid 属性并缩放显示对象后,会正常缩放所有文本和渐变;但是,对于其他类型的对象,将应用以下规则:

  • 正常缩放中心区域中的内容。
  • 不缩放转角中的内容。
  • 仅水平缩放顶部和底部区域中的内容。仅垂直缩放左侧和右侧区域中的内容。
  • 拉伸所有填充(包括位图、视频和渐变)以适应其形状。

如果旋转显示对象,则所有后续缩放都是正常的(并会忽略 scale9Grid 属性)。

例如,请考虑以下显示对象和作为该显示对象的 scale9Grid 属性应用的矩形:

显示对象。

红色矩形显示 scale9Grid

缩放或拉伸显示对象时,矩形内的对象正常缩放,但是矩形外的对象则按照 scale9Grid 规则进行缩放:

缩放到 75%:缩放到 50%:缩放到 25%:水平拉伸 150%:

设置 scale9Grid 的常见用法是设置用作组件的显示对象,当缩放该组件时,其中的边缘区域保持相同的宽度。

以下代码创建一个 Shape 对象,并用该对象的 graphics 属性绘制一个矩形。该矩形将一个 20 像素宽的线条作为边框,并且用渐变填充。该 timer 事件调用 scale() 函数,该函数通过调整 scaleXscaleY 属性来缩放 Shape 对象。应用于 Shape 对象的 scale9Grid 会阻止缩放矩形的边框线,而只缩放渐变填充: import flash.display.Shape; import flash.display.GradientType; import flash.display.SpreadMethod; import flash.display.InterpolationMethod; import flash.geom.Matrix; import flash.geom.Rectangle; import flash.utils.Timer; import flash.events.TimerEvent; var square:Shape = new Shape(); square.graphics.lineStyle(20, 0xFFCC00); var gradientMatrix:Matrix = new Matrix(); gradientMatrix.createGradientBox(15, 15, Math.PI, 10, 10); square.graphics.beginGradientFill(GradientType.RADIAL, [0xffff00, 0x0000ff], [100, 100], [0, 0xFF], gradientMatrix, SpreadMethod.REFLECT, InterpolationMethod.RGB, 0.9); square.graphics.drawRect(0, 0, 100, 100); var grid:Rectangle = new Rectangle(20, 20, 60, 60); square.scale9Grid = grid ; addChild(square); var tim:Timer = new Timer(100); tim.start(); tim.addEventListener(TimerEvent.TIMER, scale); var scaleFactor:Number = 1.01; function scale(event:TimerEvent):void { square.scaleX *= scaleFactor; square.scaleY *= scaleFactor; if (square.scaleX > 2.0) { scaleFactor = 0.99; } if (square.scaleX < 1.0) { scaleFactor = 1.01; } }
flash.geom.Rectangle
scaleX 表示从注册点开始应用的对象的水平缩放比例(百分比)。Number 表示从注册点开始应用的对象的水平缩放比例(百分比)。默认注册点为 (0,0)。1.0 等于 100% 缩放。

缩放本地坐标系统将更改 xy 属性值,这些属性值是以整像素定义的。

以下代码创建一个 Sprite 对象,并用该对象的 graphics 属性绘制一个矩形。当用户单击该 Sprite 对象时,它将按 10% 的比例进行缩放: import flash.display.Sprite; import flash.events.MouseEvent; var square:Sprite = new Sprite(); square.graphics.beginFill(0xFFCC00); square.graphics.drawRect(0, 0, 100, 100); addChild(square); square.addEventListener(MouseEvent.CLICK, scale); function scale(event:MouseEvent):void { square.scaleX *= 1.10; square.scaleY *= 1.10; }
scaleY 表示从对象注册点开始应用的对象的垂直缩放比例(百分比)。Number 表示从对象注册点开始应用的对象的垂直缩放比例(百分比)。默认注册点为 (0,0)。1.0 是 100% 缩放。

缩放本地坐标系统将更改 xy 属性值,这些属性值是以整像素定义的。

以下代码创建一个 Sprite 对象,并用该对象的 graphics 属性绘制一个矩形。当用户单击该 Sprite 对象时,它将按 10% 的比例进行缩放: import flash.display.Sprite; import flash.events.MouseEvent; var square:Sprite = new Sprite(); square.graphics.beginFill(0xFFCC00); square.graphics.drawRect(0, 0, 100, 100); addChild(square); square.addEventListener(MouseEvent.CLICK, scale); function scale(event:MouseEvent):void { square.scaleX *= 1.10; square.scaleY *= 1.10; }
scaleZ 表示从对象的注册点开始应用的对象的深度缩放比例(百分比)。Number 表示从对象的注册点开始应用的对象的深度缩放比例(百分比)。默认注册点为 (0,0)。1.0 是 100% 缩放。

缩放本地坐标系统将更改 xyz 属性值,这些属性值是以整像素定义的。

z
scrollRect 显示对象的滚动矩形范围。flash.geom:Rectangle 显示对象的滚动矩形范围。显示对象被裁切为矩形定义的大小,当您更改 scrollRect 对象的 xy 属性时,它会在矩形内滚动。

scrollRect Rectangle 对象的属性使用显示对象的坐标空间,并缩放到像整个显示对象一样。滚动显示对象上已裁切窗口的转角范围是显示对象的原点 (0,0) 和矩形的宽度和高度定义的点。它们不按原点居中,而是使用原点定义区域的左上角。滚动的显示对象始终以整像素为增量进行滚动。

您可以通过设置 scrollRect Rectangle 对象的 x 属性来左右滚动对象, 还可以通过设置 scrollRect 对象的 y 属性来上下滚动对象。如果显示对象旋转了 90 度,并且您左右滚动它,则实际上显示对象会上下滚动。

下例显示 scrollRect 属性如何为显示对象 circle 定义滚动区域。单击 circle 对象时,clicked() 事件处理函数方法会调整 circle 对象 scrollRect 属性的 y 属性,从而使对象向下滚动: import flash.display.Sprite; import flash.geom.Rectangle; import flash.events.MouseEvent; var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xFFCC00); circle.graphics.drawCircle(200, 200, 200); circle.scrollRect = new Rectangle(0, 0, 200, 200); addChild(circle); circle.addEventListener(MouseEvent.CLICK, clicked); function clicked(event:MouseEvent):void { var rect:Rectangle = event.target.scrollRect; rect.y -= 5; event.target.scrollRect = rect; }
flash.geom.Rectangle
stage 显示对象的舞台。flash.display:Stage 显示对象的舞台。Flash 运行时应用程序仅包含一个 Stage 对象。例如,您可以创建多个显示对象并加载到显示列表中,每个显示对象的 stage 属性是指相同的 Stage 对象(即使显示对象属于已加载的 SWF 文件)。

如果显示对象未添加到显示列表,则其 stage 属性会设置为 null

以下代码创建两个 TextField 对象并使用 Stage 对象的 width 属性来定位文本字段: import flash.text.TextField; var tf1:TextField = new TextField(); tf1.text = "Text Field 1"; tf1.border = true; tf1.x = 10; addChild(tf1); tf1.width = tf1.stage.stageWidth / 2 - 10; var tf2:TextField = new TextField(); tf2.text = "Text Field 2"; tf2.border = true; tf2.x = tf1.x + tf1.width + 5; addChild(tf2); tf2.width = tf2.stage.stageWidth / 2 - 10; trace(stage.stageWidth);
transform 一个对象,具有与显示对象的矩阵、颜色转换和像素范围有关的属性。flash.geom:Transform 一个对象,具有与显示对象的矩阵、颜色转换和像素范围有关的属性。在 Transform 类的条目中对特定属性 matrix、colorTransform 和三个只读属性(concatenatedMatrixconcatenatedColorTransformpixelBounds)进行了说明。

transform 对象的每个属性本身都是一个对象。此概念很重要,因为设置 matrix 或 colorTransform 对象的新值的唯一方法是,创建新对象并将该对象复制到 transform.matrix 或 transform.colorTransform 属性。

例如,要增加显示对象矩阵的 tx 值,您必须制作整个矩阵对象的副本,然后将新对象复制到 transform 对象的 matrix 属性中:


    var myMatrix:Matrix = myDisplayObject.transform.matrix;  
    myMatrix.tx += 10; 
    myDisplayObject.transform.matrix = myMatrix;  
    

不能直接设置 tx 属性。下面的代码对 myDisplayObject 不起作用:


    myDisplayObject.transform.matrix.tx += 10;
    

您也可以复制整个 transform 对象并为其赋予另一个显示对象的 transform 属性。例如,下面的代码将整个 transform 对象从 myOldDisplayObj 复制到 myNewDisplayObj

myNewDisplayObj.transform = myOldDisplayObj.transform;

现在,新显示对象 myNewDisplayObj 与旧显示对象 myOldDisplayObj 具有相同的矩阵、颜色转换和像素范围值。

请注意,用于电视的 AIR 设备使用硬件加速器(如果可用)进行颜色转换。

以下代码设置一个 square Sprite 对象。当用户单击 Sprite 时,transformer() 方法会调整 Sprite transform 属性的 colorTransformmatrix 属性: import flash.display.Sprite; import flash.geom.ColorTransform; import flash.geom.Matrix; import flash.geom.Transform; import flash.events.MouseEvent; var square:Sprite = new Sprite(); square.graphics.lineStyle(20, 0xFF2200); square.graphics.beginFill(0x0000DD); square.graphics.drawRect(0, 0, 100, 100); addChild(square); var resultColorTransform:ColorTransform = new ColorTransform(); resultColorTransform.alphaMultiplier = 0.5; resultColorTransform.redOffset = 155; resultColorTransform.greenMultiplier = 0.5; var skewMatrix:Matrix = new Matrix(1, 1, 0, 1); square.addEventListener(MouseEvent.CLICK, transformer); function transformer(event:MouseEvent):void { var transformation:Transform = square.transform; var tempMatrix:Matrix = square.transform.matrix; tempMatrix.concat(skewMatrix); square.transform.colorTransform = resultColorTransform; square.transform.matrix = tempMatrix; }
Transform 类
visible 显示对象是否可见。Boolean 显示对象是否可见。不可见的显示对象已被禁用。例如,如果 InteractiveObject 实例的 visible=false,则无法单击该对象。 以下代码使用 Timer 对象调用定期更改显示对象的 visible 属性的函数,从而会产生闪烁的效果: import flash.text.TextField; import flash.utils.Timer; import flash.events.TimerEvent; var tf:TextField = new TextField(); tf.text = "Hello."; addChild(tf); var tim:Timer = new Timer(250); tim.start(); tim.addEventListener(TimerEvent.TIMER, blinker); function blinker(event:TimerEvent):void { tf.visible = !tf.visible; } width 表示显示对象的宽度,以像素为单位。Number 表示显示对象的宽度,以像素为单位。宽度是根据显示对象内容的范围来计算的。如果您设置了 width 属性,则 scaleX 属性会相应调整,如以下代码所示: var rect:Shape = new Shape(); rect.graphics.beginFill(0xFF0000); rect.graphics.drawRect(0, 0, 100, 100); trace(rect.scaleX) // 1; rect.width = 200; trace(rect.scaleX) // 2;

除 TextField 和 Video 对象以外,没有内容的显示对象(如一个空的 Sprite)的宽度为 0,即使您尝试将 width 设置为其他值,也是这样。

以下代码设置一个 square Sprite 对象。当用户单击 Sprite 时,widen() 方法会增加 Sprite 的 width 属性: import flash.display.Sprite; import flash.events.MouseEvent; var square:Sprite = new Sprite(); square.graphics.beginFill(0xFF0000); square.graphics.drawRect(0, 0, 100, 100); addChild(square); square.addEventListener(MouseEvent.CLICK, widen); function widen(event:MouseEvent):void { square.width += 10; }
x 表示 DisplayObject 实例相对于父级 DisplayObjectContainer 本地坐标的 x 坐标。Number 表示 DisplayObject 实例相对于父级 DisplayObjectContainer 本地坐标的 x 坐标。如果该对象位于具有变形的 DisplayObjectContainer 内,则它也位于包含 DisplayObjectContainer 的本地坐标系中。因此,对于逆时针旋转 90 度的 DisplayObjectContainer,该 DisplayObjectContainer 的子级将继承逆时针旋转 90 度的坐标系。对象的坐标指的是注册点的位置。 以下代码设置一个 circle Sprite 对象。Timer 对象用于每 50 毫秒更改一次 Sprite 的 x 属性: import flash.display.Sprite; import flash.utils.Timer; import flash.events.TimerEvent; var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xFF0000); circle.graphics.drawCircle(100, 100, 100); addChild(circle); var tim:Timer = new Timer(50); tim.start(); tim.addEventListener(TimerEvent.TIMER, bounce); var xInc:Number = 2; function bounce(event:TimerEvent):void { circle.x += xInc; if (circle.x > circle.width) { xInc = -2; } if (circle.x < 0) { xInc = 2; } } y 表示 DisplayObject 实例相对于父级 DisplayObjectContainer 本地坐标的 y 坐标。Number 表示 DisplayObject 实例相对于父级 DisplayObjectContainer 本地坐标的 y 坐标。如果该对象位于具有变形的 DisplayObjectContainer 内,则它也位于包含 DisplayObjectContainer 的本地坐标系中。因此,对于逆时针旋转 90 度的 DisplayObjectContainer,该 DisplayObjectContainer 的子级将继承逆时针旋转 90 度的坐标系。对象的坐标指的是注册点的位置。 以下代码创建两个 TextField 对象并调整每个对象的 height 属性(基于每个对象的 textHeight 属性);此外,它还通过设置其 y 属性来定位第二个文本字段: import flash.text.TextField; var tf1:TextField = new TextField(); tf1.text = "Text Field 1"; tf1.border = true; tf1.wordWrap = true; tf1.width = 40; tf1.height = tf1.textHeight + 5; addChild(tf1); var tf2:TextField = new TextField(); tf2.text = "Text Field 2"; tf2.border = true; tf2.wordWrap = true; tf2.width = 40; tf2.height = tf2.textHeight + 5; tf2.y = tf1.y + tf1.height + 5; addChild(tf2); z 表示 DisplayObject 实例相对于 3D 父容器沿 z 轴的 z 坐标位置。Number 表示 DisplayObject 实例相对于 3D 父容器沿 z 轴的 z 坐标位置。z 属性用于 3D 坐标,而不是屏幕坐标或像素坐标。

当您将显示对象的 z 属性设置为默认值 0 之外的其他值时,将自动创建一个相对应的 Matrix3D 对象,以便调整显示对象在三维中的位置和方向。在使用 z 轴时,x 和 y 属性的现有行为将从屏幕坐标或像素坐标更改为相对于 3D 父容器的位置。

例如,位于 x = 100、y = 100、z = 200 位置的 _root 的子级不在像素位置 (100,100) 处进行绘制。将在 3D 投影计算将其所置之处绘制该子级。计算方法为:

(x*cameraFocalLength/cameraRelativeZPosition, y*cameraFocalLength/cameraRelativeZPosition)

本示例绘制了两个椭圆并使其朝着消失点前后移动(沿 z 轴上下移动)。一个椭圆设置的移动速度要快于另一个。 package { import flash.display.MovieClip; import flash.display.Shape; import flash.display.Graphics; import flash.events.Event; import flash.geom.*; public class ZAxisExample1 extends MovieClip { private var ellipse1Back:int = 1; private var ellipse2Back:int = 1; private var depth:int = 1000; public function ZAxisExample1():void { var ellipse1 = drawEllipse((this.stage.stageWidth / 2) - 100, (this.stage.stageHeight / 2), 100, 80, 10); var ellipse2 = drawEllipse((this.stage.stageWidth / 2) + 100, (this.stage.stageHeight / 2), 100, 80, 300); this.addChild(ellipse1); this.addChild(ellipse2); ellipse1.addEventListener(Event.ENTER_FRAME, ellipse1FrameHandler); ellipse2.addEventListener(Event.ENTER_FRAME, ellipse2FrameHandler); } private function drawEllipse(x:Number, y:Number, w:Number, h:Number, z:Number):Shape { var s:Shape = new Shape(); s.z = z; s.graphics.beginFill(0xFF0000); s.graphics.lineStyle(2); s.graphics.drawEllipse(x, y, w, h); s.graphics.endFill(); return s; } private function ellipse1FrameHandler(e:Event):void { ellipse1Back = setDepth(e, ellipse1Back); e.currentTarget.z += ellipse1Back * 10; } private function ellipse2FrameHandler(e:Event):void { ellipse2Back = setDepth(e, ellipse2Back); e.currentTarget.z += ellipse2Back * 20; } private function setDepth(e:Event, d:int):int { if(e.currentTarget.z > depth) { e.currentTarget.z = depth; d = -1; }else if (e.currentTarget.z < 0) { e.currentTarget.z = 0; d = 1; } return d; } } }
flash.geom.PerspectiveProjectionflash.geom.Matrix3Dtransform
blendShader 设置用于混合前景和背景的着色器。flash.display:Shader当着色器输出类型与此操作不兼容时(着色器必须指定 pixel4 输出)。 ArgumentErrorArgumentError当着色器指定的图像输入少于两个,或者前两个输入不是 image4 输入时。 ArgumentErrorArgumentError当着色器指定了未提供的图像输入时。 ArgumentErrorArgumentError当使用 ByteArray 或 Vector.<Number> 实例作为输入,并且没有为 ShaderInput 指定 widthheight 属性或指定的值与输入对象中的数据量不匹配时。有关详细信息,请参阅 ShaderInput.input 属性。 ArgumentErrorArgumentError 设置用于混合前景和背景的着色器。当 blendMode 属性设置为 BlendMode.SHADER 时,将使用指定的着色器为显示对象创建混合模式输出。

如果将显示对象的 blendShader 属性设置为 Shader 实例,则会将显示对象的 blendMode 属性自动设置为 BlendMode.SHADER。如果设置了 blendShader 属性(这会将 blendMode 属性设置为 BlendMode.SHADER),则 blendMode 属性的值会发生变化,只需将 blendMode 属性设置为 BlendMode.SHADER 即可将混合模式重置为使用混合着色器。除非要更改用于混合模式的着色器,否则无需再次设置 blendShader 属性。

赋予 blendShader 属性的 Shader 至少必须指定两个 image4 输入。无需使用关联 ShaderInput 对象的 input 属性在代码中指定输入。会自动使用背景显示对象作为第一个输入(index 为 0 的输入)。使用前景显示对象作为第二个输入(index 为 1 的输入)。用作混合着色器的着色器可以指定超过两个输入。在这种情况下,必须通过设置其 ShaderInput 实例的 input 属性来指定任何附加输入。

将 Shader 实例赋予此属性时,会在内部复制着色器。混合操作将使用该内部副本,而不是对原始着色器的引用。对着色器进行的任何更改(比如更改参数值、输入或字节代码)不会应用于所复制的用于混合模式的着色器。

flash.display.BlendModeflash.display.Shaderflash.display.ShaderInput
Loader Loader 类可用于加载 SWF 文件或图像(JPG、PNG 或 GIF)文件。flash.display:DisplayObjectContainer Loader 类可用于加载 SWF 文件或图像(JPG、PNG 或 GIF)文件。使用 load() 方法来启动加载。被加载的显示对象将作为 Loader 对象的子级添加。

使用 URLLoader 类加载文本或二进制数据。

Loader 类会覆盖其继承的以下方法,因为 Loader 对象只能有一个子显示对象 -- 其加载的显示对象。调用以下方法将引发异常:addChild()addChildAt()removeChild()removeChildAt()setChildIndex()。要删除被加载的显示对象,必须从其父 DisplayObjectContainer 子级数组中删除 Loader 对象。

注意:在 ActionScript 3.0 中使用的不是 ActionScript 2.0 MovieClipLoader 和 LoadVars 类,而是 Loader 和 URLLoader 类。

在使用 Loader 类时,请考虑 Flash Player 和 Adobe AIR 的安全模型:

  • 您可以加载来自任何可访问源的内容。
  • 如果执行调用的 SWF 文件位于网络沙箱中并且要加载的文件是本地的,则不允许加载。
  • 如果加载的内容为用 ActionScript 3.0 编写的 SWF 文件,那么除非可以通过调用加载的内容文件中的 System.allowDomain()System.allowInsecureDomain() 方法来允许跨脚本排列,否则另一个安全沙箱中的 SWF 文件不能对它执行跨脚本操作。
  • 如果被加载的内容为 AVM1 SWF 文件(用 ActionScript 1.0 或 2.0 编写),则 AVM2 SWF 文件(用 ActionScript 3.0 编写)不能对它执行跨脚本操作。但是,可以通过使用 LocalConnection 类在两个 SWF 文件之间实现通信。
  • 如果加载的内容为图像,则安全沙箱之外的 SWF 文件将无法访问其数据,除非该 SWF 文件的域包含在该图像的原始域上的 URL 策略文件中。
  • 在只能与本地文件系统的内容交互的沙箱中的影片剪辑不能对只能与远程内容交互的沙箱中的影片剪辑使用脚本,反之亦然。
  • 无法连接到常用的保留端口。有关已阻止的端口的完整列表,请参阅《ActionScript 3.0 开发人员指南》中的“限制网络 API”。

但在 AIR 中,application 安全沙箱中的内容(使用 AIR 应用程序安装的内容)不受这些安全限制的约束。

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

当从不受信任的源(如除 Loader 对象的根 SWF 文件以外的域)加载 SWF 文件时,您可能需要为 Loader 对象定义蒙版,以防止将加载的内容(Loader 对象的子级)绘画到该蒙版之外的舞台部分中,如以下代码所示:

import flash.display.~~; import flash.net.URLRequest; var rect:Shape = new Shape(); rect.graphics.beginFill(0xFFFFFF); rect.graphics.drawRect(0, 0, 100, 100); rect.graphics.endFill(); addChild(rect); var ldr:Loader = new Loader(); ldr.mask = rect; var url:String = "http://www.unknown.example.com/content.swf"; var urlReq:URLRequest = new URLRequest(url); ldr.load(urlReq); addChild(ldr);
下例用 LoaderExample 类来说明如何使用各种事件侦听器。执行下列步骤可完成该任务:
  1. 创建 url 属性,它是图像文件的位置和名称
  2. LoaderExample 构造函数中,创建一个新的 Loader 对象,名为 loader,该对象随后被传递给 configureListeners() 方法,如步骤 3 所述。
  3. 构造函数创建一个 URLRequest 对象的新实例 request,该实例带有传递的 url,这样,就可以知道文件的名称和位置。
  4. request 对象传递给 loader 对象的 load() 方法,该方法会将图像加载到显示列表上。
  5. 为加载器上的 click 事件注册 clickHandler 事件侦听器。在单击鼠标后,便可卸载加载的图像。
  6. configureListeners() 方法通过以下方法添加 7 个事件侦听器:
    • 图像加载完成时,执行 completeHandler() 方法。
    • 图像不是在本地加载,并且只有在网络请求可用并可被 Flash Player 检测到的情况下,才会执行 httpStatusHandler() 方法。
    • initHandler() 方法在 completeHandler() 方法之前、progressHandler() 方法之后执行。通常,init 事件在加载 SWF 文件时更有用。
    • 图像文件不可用或不可访问,则执行 ioErrorHandler() 方法。
    • 首次打开图像文件时,执行 openHandler() 方法。
    • 图像文件开始下载和下载完成时,执行 progressHandler() 方法。
    • 通过使用用户单击图像时使用的 unload() 方法卸载图像时,执行 unLoadHandler() 方法。

请牢记以下要求:

  • 该示例要求您将名为 Image.gif 的文件放置在与经过编译的 SWF 文件相同的目录中。使用具有一个适合主 SWF 文件尺寸的区域的图像。
  • 虽然该示例使用可用于 LoaderInfo 对象的所有事件,但是在大部分情况下,只需要一个子集。特别是在只加载图像文件时,complete 事件(还可能是 ioError 事件)足够用于加载本地图像。
package { import flash.display.Loader; import flash.display.Sprite; import flash.events.*; import flash.net.URLRequest; public class LoaderExample extends Sprite { private var url:String = "Image.gif"; public function LoaderExample() { var loader:Loader = new Loader(); configureListeners(loader.contentLoaderInfo); loader.addEventListener(MouseEvent.CLICK, clickHandler); var request:URLRequest = new URLRequest(url); loader.load(request); addChild(loader); } private function configureListeners(dispatcher:IEventDispatcher):void { dispatcher.addEventListener(Event.COMPLETE, completeHandler); dispatcher.addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler); dispatcher.addEventListener(Event.INIT, initHandler); dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); dispatcher.addEventListener(Event.OPEN, openHandler); dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler); dispatcher.addEventListener(Event.UNLOAD, unLoadHandler); } private function completeHandler(event:Event):void { trace("completeHandler: " + event); } private function httpStatusHandler(event:HTTPStatusEvent):void { trace("httpStatusHandler: " + event); } private function initHandler(event:Event):void { trace("initHandler: " + event); } private function ioErrorHandler(event:IOErrorEvent):void { trace("ioErrorHandler: " + event); } private function openHandler(event:Event):void { trace("openHandler: " + event); } private function progressHandler(event:ProgressEvent):void { trace("progressHandler: bytesLoaded=" + event.bytesLoaded + " bytesTotal=" + event.bytesTotal); } private function unLoadHandler(event:Event):void { trace("unLoadHandler: " + event); } private function clickHandler(event:MouseEvent):void { trace("clickHandler: " + event); var loader:Loader = Loader(event.target); loader.unload(); } } }
flash.display.LoaderInfoflash.net.URLLoaderflash.display.DisplayObjectLoader 创建一个可用于加载文件(如 SWF、JPEG、GIF 或 PNG 文件)的 Loader 对象。 创建一个可用于加载文件(如 SWF、JPEG、GIF 或 PNG 文件)的 Loader 对象。调用 load() 方法可将资源加载为 Loader 实例的子级。然后,可以将 Loader 对象添加到显示列表(例如,通过使用 DisplayObjectContainer 实例的 addChild() 方法)。这样,资源在加载时会出现在舞台上。

您也可以在“offlist”模式下使用 Loader 实例,这样就不会将 Loader 实例添加到显示列表的显示对象容器中。在该模式下,Loader 实例可以用于加载包含应用程序的其它模块的 SWF 文件。

要检测何时可以完成 SWF 文件的加载,您可以使用与 Loader 对象的 contentLoaderInfo 属性相关联的 LoaderInfo 对象的事件。此时,便可执行模块 SWF 文件中的代码以初始化和启动模块。在 offlist 模式下,还可以使用 Loader 实例来加载包含组件或媒体资源的 SWF 文件。同时,您可以使用 LoaderInfo 对象事件通知来检测组件的加载何时完成。此时,应用程序可以通过实例化代表这些组件和资源的 ActionScript 3.0 类来开始使用 SWF 文件库中的组件和媒体资源。

要确定 Loader 对象的状态,请监视与 Loader 对象的 contentLoaderInfo 属性相关联的 LoaderInfo 对象的以下事件:

  • 在加载开始时调度 open 事件。
  • 在无法加载文件或在加载过程中出现错误时,调度 ioErrorsecurityError 事件。
  • 在文件加载过程中会不断引发 progress 事件。
  • 在文件完成下载但加载的影片剪辑的方法和属性尚不可用时调度 complete 事件。
  • 在可以访问加载的 SWF 文件的属性和方法,即可以开始操作加载的 SWF 文件时调度 init 事件。在 complete 处理函数之前调度该事件。在流式 SWF 文件中,init 事件可以在明显早于 complete 事件的时间发生。在大多数情况下,请使用 init 处理函数。
flash.display.Loader.load()flash.display.LoaderInfo
close 取消当前正在对 Loader 实例执行的 load() 方法操作。 取消当前正在对 Loader 实例执行的 load() 方法操作。 flash.display.Loader.load()loadBytes 从 ByteArray 对象中所存储的二进制数据中加载。如果 ByteArray 对象的 length 属性不大于 0。 ArgumentErrorArgumentError如果 context 参数的 checkPolicyFilesecurityDomain 属性为非空。 IllegalOperationErrorflash.errors:IllegalOperationError如果 context 参数的 requestedContentParent 属性为 LoaderIllegalOperationErrorflash.errors:IllegalOperationError如果 LoaderContext.parameters 参数设置为非 null,并且具有不是字符串的某些值。 IllegalOperationErrorflash.errors:IllegalOperationError如果提供的 context 属性的 applicationDomain 属性来自不允许的域。 SecurityErrorSecurityError无法连接到常用的保留端口。有关已阻止的端口的完整列表,请参阅《ActionScript 3.0 开发人员指南》中的“限制网络 API”。 SecurityErrorSecurityErrorbytesflash.utils:ByteArray一个 ByteArray 对象。ByteArray 的内容可以采用受 Loader 类支持的任何文件格式:SWF、GIF、JPEG 或 PNG。 contextflash.system:LoaderContextnull一个 LoaderContext 对象。只应用 LoaderContext 对象的 applicationDomain 属性;不应用 LoaderContext 对象的 checkPolicyFilesecurityDomain 属性。

如果未指定 context 参数或者该参数引用了 null 对象,则内容将加载到当前的安全域(在 Flash Player 安全文档中称为“导入加载”的进程)中。具体来说,如果执行加载的 SWF 文件通过将远程 SWF 并入到其代码中来信任远程 SWF,则执行加载的 SWF 可直接将其导入到自己的安全域中。

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

从 ByteArray 对象中所存储的二进制数据中加载。

loadBytes() 方法是异步的。必须等待“init”事件出现才能访问已加载对象的属性。

使用此方法时,请考虑 Loader 类说明中描述的 Flash Player 安全模型。

flash.utils.ByteArrayflash.system.LoaderContext.applicationDomainasyncErrorflash.events:AsyncErrorEvent如果 LoaderContext.requestedContentParent 属性已指定并且不可能将加载的内容作为子级添加到指定的 DisplayObjectContainer,则由 contentLoaderInfo 对象调度。如果加载的内容为 flash.display.AVM1Movie,或者 addChild() 调用 requestedContentParent 时引发了错误,则可能发生这种情况。 如果 LoaderContext.requestedContentParent 属性已指定并且不可能将加载的内容作为子级添加到指定的 DisplayObjectContainer,则由 contentLoaderInfo 对象调度。completeflash.events:Event当操作完成时由 contentLoaderInfo 对象调度。complete 事件始终在 init 事件之后调度。 当操作完成时由 contentLoaderInfo 对象调度。initflash.events:Event当已加载数据的属性和方法可以访问时由 contentLoaderInfo 对象调度。init 事件始终在 complete 事件之前。 当已加载数据的属性和方法可以访问时由 contentLoaderInfo 对象调度。ioErrorflash.events:IOErrorEvent当运行时无法分析字节数组中的数据时由 contentLoaderInfo 对象调度。 当运行时无法分析字节数组中的数据时由 contentLoaderInfo 对象调度。openflash.events:Event当操作开始时由 contentLoaderInfo 对象调度。 当操作开始时由 contentLoaderInfo 对象调度。progressflash.events:ProgressEvent当数据传输至内存时由 contentLoaderInfo 对象调度。 当数据传输至内存时由 contentLoaderInfo 对象调度。securityErrorflash.events:SecurityErrorEvent如果 LoaderContext.requestedContentParent 属性已指定并且 LoaderContext.requestedContentParent 的安全沙箱不能访问加载的 SWF,则由 contentLoaderInfo 对象调度。 如果 LoaderContext.requestedContentParent 属性已指定并且 LoaderContext.requestedContentParent 的安全沙箱不能访问加载的 SWF,则由 contentLoaderInfo 对象调度。unloadflash.events:Event在删除所加载的对象时,由 contentLoaderInfo 对象调度。 在删除所加载的对象时,由 contentLoaderInfo 对象调度。
loadFilePromise 加载 IFilePromise 实例。如果 context 参数的 requestedContentParent 属性为 LoaderIllegalOperationErrorflash.errors:IllegalOperationError如果 LoaderContext.parameters 参数设置为非 null,并且具有不是字符串的某些值。 IllegalOperationErrorflash.errors:IllegalOperationError如果作为参数传递的 IFilePromise 对象为 null。 ArgumentErrorArgumentErrorpromiseflash.desktop:IFilePromiseIFilePromise 对象。对象的数据源可以采用 Loader 类支持的任何文件格式:SWF、GIF、JPEG 或 PNG。 contextflash.system:LoaderContextnull一个 LoaderContext 对象。只应用 LoaderContext 对象的 applicationDomain 属性;不应用 LoaderContext 对象的 checkPolicyFilesecurityDomain 属性。

如果未指定 context 参数或者该参数引用了 null 对象,则内容将加载到当前的安全域(在 Flash Player 安全文档中称为“导入加载”的进程)中。具体来说,如果执行加载的 SWF 文件通过将远程 SWF 并入到其代码中来信任远程 SWF,则执行加载的 SWF 可直接将其导入到自己的安全域中。

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

加载 IFilePromise 实例。

loadFilePromise 方法使用 IFilePromise 对象并加载二进制数据。如果数据是渐进流,例如视频,则在访问加载的对象的属性之前等待“init”或 progress 事件。否则,等待 complete 事件以确保完全加载了数据。

使用此方法时,请考虑 Loader 类说明中描述的 Flash Player 安全模型。

MediaPromiseCameraRoll.browseForImage()CameraUIasyncErrorflash.events:AsyncErrorEvent如果 LoaderContext.requestedContentParent 属性已指定并且不可能将加载的内容作为子级添加到指定的 DisplayObjectContainer,则由 contentLoaderInfo 对象调度。如果加载的内容为 flash.display.AVM1Movie,或者 addChild() 调用 requestedContentParent 时引发了错误,则可能发生这种情况。 如果 LoaderContext.requestedContentParent 属性已指定并且不可能将加载的内容作为子级添加到指定的 DisplayObjectContainer,则由 contentLoaderInfo 对象调度。completeflash.events:Event当操作完成时由 contentLoaderInfo 对象调度。complete 事件始终在 init 事件之后调度。 当操作完成时由 contentLoaderInfo 对象调度。initflash.events:Event当已加载数据的属性和方法可以访问时由 contentLoaderInfo 对象调度。init 事件始终在 complete 事件之前。 当已加载数据的属性和方法可以访问时由 contentLoaderInfo 对象调度。ioErrorflash.events:IOErrorEvent如果运行时无法分析数据源中的数据或数据源流不可读,则由 contentLoaderInfo 对象调度。 如果运行时无法分析数据源中的数据或数据源流不可读,则由 contentLoaderInfo 对象调度。openflash.events:Event当操作开始时由 contentLoaderInfo 对象调度。 当操作开始时由 contentLoaderInfo 对象调度。progressflash.events:ProgressEvent当数据传输至内存时由 contentLoaderInfo 对象调度。 当数据传输至内存时由 contentLoaderInfo 对象调度。securityErrorflash.events:SecurityErrorEvent如果 LoaderContext.requestedContentParent 属性已指定并且 LoaderContext.requestedContentParent 的安全沙箱不能访问加载的 SWF,则由 contentLoaderInfo 对象调度。 如果 LoaderContext.requestedContentParent 属性已指定并且 LoaderContext.requestedContentParent 的安全沙箱不能访问加载的 SWF,则由 contentLoaderInfo 对象调度。unloadflash.events:Event在删除所加载的对象时,由 contentLoaderInfo 对象调度。 在删除所加载的对象时,由 contentLoaderInfo 对象调度。
load 将 SWF、JPEG、渐进式 JPEG、非动画 GIF 或 PNG 文件加载到此 Loader 对象的子对象中。request 对象的 digest 属性不是 null。如果在加载 SWZ 文件(一个 Adobe 平台组件)时调用 URLLoader.load() 方法,仅应设置 URLRequest 对象的 digest 属性。 IOErrorflash.errors:IOErrorLoaderContext.securityDomain 的值必须是 nullSecurityDomain.currentDomain。这说明您只能将被加载的媒体放置在其原始的安全沙箱或您自己的安全沙箱中(后者需要策略文件)。 SecurityErrorSecurityError本地 SWF 文件可能只会将 LoaderContext.securityDomain 设置为 null。不允许将非本地媒体导入到本地沙箱中,或者将其它本地媒体放置在除其原始沙箱以外的其它位置。 SecurityErrorSecurityError 无法连接到常用的保留端口。有关已阻止的端口的完整列表,请参阅《ActionScript 3.0 开发人员指南》中的“限制网络 API”。 SecurityErrorSecurityError如果 context 参数的 applicationDomainsecurityDomain 属性来自不允许的域。 SecurityErrorSecurityError如果本地 SWF 文件尝试使用 context 参数的 securityDomain 属性。 SecurityErrorSecurityError如果 context 参数的 requestedContentParent 属性为 LoaderIllegalOperationErrorflash.errors:IllegalOperationError如果 LoaderContext.parameters 参数设置为非 null,并且具有不是字符串的某些值。 IllegalOperationErrorflash.errors:IllegalOperationErrorrequestflash.net:URLRequest 要加载的 SWF、JPEG、GIF 或 PNG 文件的绝对或相对 URL。相对路径必须相对于主 SWF 文件。绝对 URL 必须包括协议引用,如 http:// 或 file:///。文件名不能包括磁盘驱动器指定。 contextflash.system:LoaderContextnullLoaderContext 对象,它具有定义下列内容的属性:
  • 是否应在加载对象时检查策略文件是否存在
  • 被加载的对象的 ApplicationDomain
  • 加载的对象的 SecurityDomain
  • 加载的图像对象的 ImageDecodingPolicy

如果未指定 context 参数或者该参数引用了 null 对象,则已加载的内容将保留在自己的安全域中。

有关完整的详细信息,请参阅 LoaderContext 类中的属性说明。

将 SWF 文件或图像文件加载到该 Loader 实例的 DisplayObject 子级中。
将 SWF、JPEG、渐进式 JPEG、非动画 GIF 或 PNG 文件加载到此 Loader 对象的子对象中。如果加载 GIF 动画文件,将仅显示第一帧。由于 Loader 对象可以只包含一个子级,因此,发出后续 load() 请求将终止先前的请求,如果仍然存在未处理的请求,则会开始新的加载。

注意:在 AIR 1.5 和 Flash Player 10 中,所加载图像的最大宽度或高度为 8,191 像素,并且像素总数不能超过 16,777,215 像素。(因此,如果所加载图像的宽度为 8,191 像素,则其高度只能为 2,048 像素。)在 Flash Player 9 及早期版本和 AIR 1.1 及早期版本中,高度最大为 2,880 像素,宽度最大为 2,880 像素。

加载到 Loader 对象中的 SWF 文件或图像会继承该 Loader 对象的父显示对象的位置、旋转和缩放属性。

使用 unload() 方法可删除用此方法加载的影片或图像,或者取消正在进行中的加载操作。

可以在包含 SWF 内容的 HTML 页中设置 objectembed 标签的 allowNetworking 参数,防止 SWF 文件使用此方法。

使用此方法时,请考虑 Loader 类说明中描述的 Flash Player 安全模型。

在 Flash Player 10 和更高版本中,如果使用包含上载(由 POST 体内的“content-disposition”标头中的“filename”参数表示)的 multipart Content-Type(例如“multipart/form-data”),则 POST 操作会受应用于上载的安全规则的约束:

  • 必须执行 POST 操作以响应用户启动的操作(如鼠标单击或按键)。
  • 如果 POST 操作是跨域的(POST 目标与发送 POST 请求的 SWF 文件不在同一台服务器上),则目标服务器必须提供一个允许跨域访问的 URL 策略文件。

同样,对于任何 multipart Content-Type,语法必须有效(根据 RFC2046 标准)。如果语法无效,则 POST 操作受应用于上载的安全规则约束。

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

contentLoaderInfoflash.net.URLRequestflash.display.DisplayObjectflash.display.Loader.unload()flash.display.LoaderInfoflash.system.LoaderContextasyncErrorflash.events:AsyncErrorEvent如果 LoaderContext.requestedContentParent 属性已指定并且不可能将加载的内容作为子级添加到指定的 DisplayObjectContainer,则由 contentLoaderInfo 对象调度。如果加载的内容为 flash.display.AVM1Movie,或者 addChild() 调用 requestedContentParent 时引发了错误,则可能发生这种情况。 如果 LoaderContext.requestedContentParent 属性已指定并且不可能将加载的内容作为子级添加到指定的 DisplayObjectContainer,则由 contentLoaderInfo 对象调度。completeflash.events:Event在文件完成加载时由 contentLoaderInfo 对象调度。complete 事件始终在 init 事件之后调度。 在文件完成加载时由 contentLoaderInfo 对象调度。httpStatusflash.events:HTTPStatusEvent在通过 HTTP 发出网络请求并且 Flash Player 可以检测到 HTTP 状态代码时,由 contentLoaderInfo 对象调度。 在通过 HTTP 发出网络请求并且 Flash Player 可以检测到 HTTP 状态代码时,由 contentLoaderInfo 对象调度。initflash.events:Event在可以访问所加载的 SWF 文件的属性和方法时,由 contentLoaderInfo 对象调度。init 事件始终在 complete 事件之前。 在可以访问所加载的 SWF 文件的属性和方法时,由 contentLoaderInfo 对象调度。ioErrorflash.events:IOErrorEvent在发生会导致加载操作失败的输入或输出错误时,由 contentLoaderInfo 对象调度。 在发生会导致加载操作失败的输入或输出错误时,由 contentLoaderInfo 对象调度。openflash.events:Event在加载操作开始时,由 contentLoaderInfo 对象调度。 在加载操作开始时,由 contentLoaderInfo 对象调度。progressflash.events:ProgressEvent在加载操作进行过程中接收到数据时,由 contentLoaderInfo 对象调度。 在加载操作进行过程中接收到数据时,由 contentLoaderInfo 对象调度。securityErrorflash.events:SecurityErrorEvent当位于只能与本地文件系统内容交互的沙箱中的 SWF 文件尝试加载只能与远程内容交互的沙箱中的内容时(反之亦然),由 contentLoaderInfo 对象调度。 当位于只能与本地文件系统内容交互的沙箱中的 SWF 文件尝试加载只能与远程内容交互的沙箱中的内容时(反之亦然),由 contentLoaderInfo 对象调度。securityErrorflash.events:SecurityErrorEvent如果 LoaderContext.requestedContentParent 属性已指定并且 LoaderContext.requestedContentParent 的安全沙箱不能访问加载的 SWF,则由 contentLoaderInfo 对象调度。 如果 LoaderContext.requestedContentParent 属性已指定并且 LoaderContext.requestedContentParent 的安全沙箱不能访问加载的 SWF,则由 contentLoaderInfo 对象调度。unloadflash.events:Event在删除所加载的对象时,由 contentLoaderInfo 对象调度。 在删除所加载的对象时,由 contentLoaderInfo 对象调度。
unloadAndStop 尝试卸载子 SWF 文件内容并停止执行已加载的 SWF 文件中的命令。gcBooleantrue提示垃圾回收器对 SWF 子对象执行 (true) 还是不执行 (false) 垃圾回收。如果要以异步方式卸载很多对象,则将 gc 参数设置为 false 可能会提高应用程序的性能。但是,如果将该参数设置为 false,则在运行 unloadAndStop() 命令之后,子 SWF 文件的媒体和显示对象可能还会保存在内存中。 尝试卸载子 SWF 文件内容并停止执行已加载的 SWF 文件中的命令。此方法尝试通过删除对子 SWF 文件的 EventDispatcher、NetConnection、Timer、Sound 或 Video 对象的引用,从而卸载使用 Loader.load()Loader.loadBytes() 加载的 SWF 文件。因此,针对子 SWF 文件和子 SWF 文件的显示列表将发生以下行为:
  • 停止声音。
  • 删除舞台事件侦听器。
  • 删除 enterFrameframeConstructedexitFrameactivatedeactivate 的事件侦听器。
  • 停止计时器。
  • 断开摄像机和麦克风实例
  • 停止影片剪辑。
flash.display.DisplayObjectflash.display.Loader.load()
unload 删除此 Loader 对象中使用 load() 方法加载的子项。 删除此 Loader 对象中使用 load() 方法加载的子项。将关联 LoaderInfo 对象的 property 重置为 null。不必破坏子级,因为其它对象可能要引用它;但是,它不再是 Loader 对象的子级。

最佳做法是,在卸载子 SWF 文件之前,您应该显式关闭子 SWF 文件的对象(如 LocalConnection、NetConnection、NetStream 和 Sound 对象)中的任何流。否则,子 SWF 文件中的音频可能会继续播放,即使已卸载子级 SWF 文件。要关闭子 SWF 文件中的流,请向子文件中添加事件侦听器以侦听 unload 事件。当父文件调用 Loader.unload() 时,将为子文件调度 unload 事件。以下代码显示了完成上述任务的方法:

function closeAllStreams(evt:Event) { 
    myNetStream.close();
    mySound.close();
    myNetConnection.close();
    myLocalConnection.close();
}

myMovieClip.loaderInfo.addEventListener(Event.UNLOAD, closeAllStreams);
Loader.load()flash.media.Sound.close()flash.net.LocalConnection.close()flash.net.NetConnection.close()flash.net.NetStream.close()delete 运算符
contentLoaderInfo 返回与正在加载的对象相对应的 LoaderInfo 对象。flash.display:LoaderInfo 返回与正在加载的对象相对应的 LoaderInfo 对象。LoaderInfo 对象在 Loader 对象和加载的内容对象之间共享。LoaderInfo 对象提供有关加载的文件的加载进度信息和统计。

与加载相关的事件由 Loader 对象的 contentLoaderInfo 属性引用的 LoaderInfo 对象调度。contentLoaderInfo 属性设置为有效的 LoaderInfo 对象(即使在加载内容之前),这样您就可以在加载前将事件侦听器添加到该对象。

要检测加载的 SWF 中发生的未捕获错误,请使用 Loader.uncaughtErrorEvents 属性而不是 Loader.contentLoaderInfo.uncaughtErrorEvents 属性。

以下示例显示如何使用 Loader 对象的 contentLoaderInfo 属性上的 Loader 类和 complete 事件在 ActionScript 3.0 中加载和定位图像。ActionScriptExamples.com 提供的示例。 var url:String = "http://www.helpexamples.com/flash/images/image2.jpg"; var urlRequest:URLRequest = new URLRequest(url); var loader:Loader = new Loader(); loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loader_complete); loader.load(urlRequest); addChild(loader); function loader_complete(evt:Event):void { var target_mc:Loader = evt.currentTarget.loader as Loader; target_mc.x = (stage.stageWidth - target_mc.width) / 2; target_mc.y = (stage.stageHeight - target_mc.height) / 2; }
flash.display.LoaderInfo
content 包含使用 load() 或 loadBytes() 方法加载的 SWF 文件或图像(JPG、PNG 或 GIF)文件的根显示对象。flash.display:DisplayObject加载的 SWF 文件或图像文件属于您无权访问的安全沙箱。对于加载的 SWF 文件,可以避免这种情况的方法是:使该文件调用 Security.allowDomain() 方法,或在您调用 load()loadBytes() 方法时使加载文件指定 loaderContext 参数,并将该参数的 securityDomain 属性设置为 SecurityDomain.currentDomainSecurityErrorSecurityError 包含使用 load()loadBytes() 方法加载的 SWF 文件或图像(JPG、PNG 或 GIF)文件的根显示对象。 flash.display.DisplayObjectflash.display.Loader.load()uncaughtErrorEvents 在此 Loader 对象加载的 SWF 中发生未处理错误时调度 uncaughtError 事件的对象。flash.events:UncaughtErrorEvents 在此 Loader 对象加载的 SWF 中发生未处理错误时调度 uncaughtError 事件的对象。当任何 try..catch 块引发错误时,或调度的 ErrorEvent 对象没有注册的侦听器时,会发生未被捕获的错误。

请注意,Loader 对象的 uncaughtErrorEvents 属性调度通过该对象冒泡的事件,而不是该对象直接调度的事件。它永远不会在目标阶段调度 uncaughtErrorEvent。它仅在捕获阶段和冒泡阶段调度该事件。要检测当前 SWF(在其中定义 Loader 对象)中未被捕获的错误,请改用 LoaderInfo.uncaughtErrorEvents 属性。

如果 Loader 对象加载的内容是 AVM1 (ActionScript 2) SWF 文件,则 AVM1 SWF 文件中未被捕获的错误不会导致 uncaughtError 事件。

以下示例演示了使用未被捕获的错误事件处理程序检测加载的 SWF 中的未被捕获的错误的过程。此示例定义了一个 uncaughtError 事件处理程序来检测未被捕获的错误。

在构造函数中,代码创建了一个 Loader 对象并为由 Loader 对象的 uncaughtErrorEvents 属性调度的 uncaughtError 事件注册了一个侦听器。

uncaughtErrorHandler() 方法中,代码检查 error 属性的数据类型并做出相应的响应。

package { import flash.display.Loader; import flash.display.Sprite; import flash.events.ErrorEvent; import flash.events.UncaughtErrorEvent; import flash.net.URLRequest; public class LoaderUncaughtErrorEventExample extends Sprite { private var ldr:Loader; public function LoaderUncaughtErrorEventExample() { ldr = new Loader(); ldr.load(new URLRequest("child.swf")); ldr.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaughtErrorHandler); } private function uncaughtErrorHandler(event:UncaughtErrorEvent):void { if (event.error is Error) { var error:Error = event.error as Error; // do something with the error } else if (event.error is ErrorEvent) { var errorEvent:ErrorEvent = event.error as ErrorEvent; // do something with the error } else { // a non-Error, non-ErrorEvent type was thrown and uncaught } } } }
UncaughtErrorEventLoaderInfo.uncaughtErrorEvents
NativeMenuItem NativeMenuItem 类表示菜单中的单个项目。flash.events:EventDispatcher NativeMenuItem 类表示菜单中的单个项目。

菜单项可以是一个命令、一个子菜单或一条分隔线:

  • 要创建一个命令项,请调用 NativeMenuItem 构造函数,为标签传递一个字符串,并为 isSeparator 参数传递 false
  • 要创建一个子菜单,请为父菜单创建一个命令项,并将子菜单的 NativeMenu 对象分配给该命令项的 submenu 属性。也可以调用父级 NativeMenu 对象的 addSubmenu() 方法来创建该项并同时设置 submenu 属性。
  • 要创建一个分隔符,请调用 NativeMenuItem 构造函数,为标签传递一个空字符串,并为 isSeparator 参数传递 true

在一个项目或父菜单上侦听 select 事件可以检测何时选择某一菜单命令。子菜单和分隔符都不调度 select 事件。侦听 preparing 事件以确定菜单项何时要通过等效键显示或激活。

flash.display.NativeMenuflash.display.NativeMenu.addSubmenu()preparing 在包含它的菜单显示之前的一瞬间且按下其等效键时由此 NativeMenuItem 对象调度。flash.events.Event.PREPARINGflash.events.Event 在包含它的菜单显示之前的一瞬间且按下其等效键时由此 NativeMenuItem 对象调度。

在包含它的菜单显示之前或用户按下其等效键时,侦听此事件以更新该项。在完全计算等效键之前调度 preparing 事件。您可以在 preparing 事件处理函数中从菜单中启用、禁用或删除菜单项,这些更改将在处理等效键时生效。例如,如果您删除或禁用此菜单项,则事件顺序将有效地被取消,不调度 select 事件。preparing 事件还由菜单中的其他项调度。

preparing 事件替代 displaying 事件并提供其他功能。侦听 preparing 事件或 displaying 事件,但不能同时侦听两者。

displaying 在显示包含此项目的菜单的前一刻由此 NativeMenuItem 对象调度。flash.events.Event.DISPLAYINGflash.events.Event 在显示包含此项目的菜单的前一刻由此 NativeMenuItem 对象调度。

preparing 事件替代 displaying 事件并提供其他功能。侦听 preparing 事件或 displaying 事件,但不能同时侦听两者。

select 每当用户选择菜单项时调度。flash.events.Event.SELECTflash.events.Event 每当用户选择菜单项时调度。

select 事件将从此项目冒泡 到包含菜单,并贯穿父菜单链到达根菜单对象。该事件对象的 target 属性将引用此 NativeMenuItem 对象;currentTarget 属性将引用调度对象(此 NativeMenuItem 或祖先级 NativeMenu 对象)。

注意:如果包含该菜单的窗口处于全屏模式 (stage.displayState == StageDisplayState.FULL_SCREEN),则当用户输入菜单项的键盘等效项时,NativeMenuItem 对象不会 调度 select 事件。

NativeMenuItem 创建新的 NativeMenuItem 对象。labelString用于该项目的显示标签,或用于分隔符的空字符串。 isSeparatorBooleanfalse设置为 true 可创建分隔符;否则设置为 false 创建新的 NativeMenuItem 对象。

要创建一个菜单命令,请将 label 参数设置为包含该显示标签的字符串,并将 isSeparator 设置为 false

要创建一个子菜单命令,请创建一个命令项,然后将子菜单的 NativeMenu 对象分配给该命令项的 submenu 属性。将该项添加到父菜单。

要创建一个分隔符,请将 label 参数设置为空字符串,并将 isSeparator 设置为 true

使用 NativeMenu addItem()removeItem() 方法在菜单中添加和删除项目。

flash.display.NativeMenu.addSubmenu()
clone 创建 NativeMenuItem 对象的副本。flash.display:NativeMenuItem 创建 NativeMenuItem 对象的副本。 toString 返回一个字符串,其中包含 NativeMenuItem 对象的所有属性。一个字符串,其中包含 Event 对象的所有属性。 String 返回一个字符串,其中包含 NativeMenuItem 对象的所有属性。 checked 控制此菜单项是否显示复选标记。Boolean 控制此菜单项是否显示复选标记。 data 与此菜单项关联的任意数据对象。Object 与此菜单项关联的任意数据对象。

可以向此属性分配任何对象。分配的对象不会由菜单系统使用,但可供事件处理代码使用,(通过事件对象的 target 属性)。默认情况下,此属性的值为 null

enabled 控制是否启用此菜单项。Boolean 控制是否启用此菜单项。 isSeparator 报告此项目是否为菜单分隔线。Boolean 报告此项目是否为菜单分隔线。

通过将 NativeMenuItem 构造函数中的 isSeparator 属性设置为 true 创建一条分隔线。

keyEquivalentModifiers 等效功能键的键控代码数组。Array 等效功能键的键控代码数组。

使用 Keyboard 类中定义的常量可以指定功能键代码。有效的功能键包括:

  • Keyboard.ALTERNATE
  • Keyboard.COMMAND
  • Keyboard.CONTROL

如果未指定任何功能键,则默认情况下,将在 Windows 或 Linux 中分配 Keyboard.CONTROL 键,在 Mac OS X 中分配 Keyboard.COMMAND 键。如果不希望等效键包括这些功能键,可将此属性设置为空数组。

如果为 keyEquivalent 属性分配一个大写字母,则会自动将 Shift 键用作修饰符。将 keyEquivalentModifier 设置为一个空数组不会撤消将 Shift 键用作修饰符。

flash.ui.Keyboard
keyEquivalent 此菜单项的等效键。String 此菜单项的等效键。

使用小写字母设置 keyEquivalent 可以分配无 Shift 功能键的快捷键。使用大写字母设置此属性可以分配具有 Shift 功能键的快捷键。

默认情况下,等效功能键(Windows 或 Linux 中为 Ctrl,Mac OS X 中为 Command)作为等效键的一部分包括在内。如果希望等效键是一个没有修饰符的键,可将 keyEquivalentModifiers 属性设置为一个空数组。

label 此菜单项的显示字符串。String 此菜单项的显示字符串。 menu 包含此项目的菜单。flash.display:NativeMenu 包含此项目的菜单。 mnemonicIndex 菜单项标签中的助记键字符的位置。int 菜单项标签中的助记键字符的位置。

位于指定位置的字符是该菜单项的助记键字符。索引是从 0 开始的,所以第一个字符的索引为 0。

在不使用菜单助记键的操作系统中将忽略此属性。

name 此菜单项的名称。String 此菜单项的名称。

名称值不显示,并可用作独立于区域设置的标识符。不自动分配名称。

submenu 与此菜单项关联的子菜单。flash.display:NativeMenu 与此菜单项关联的子菜单。

将 NativeMenu 对象分配给此属性将更改该菜单项的外观和行为。子菜单项将显示子菜单图标,并且不再调度 select 事件。

注意:将菜单添加为其自身的一个子菜单(在循环引用中)可能导致应用程序挂起。

flash.display.NativeMenu.addSubmenu()
NativeMenu NativeMenu 类包含用于定义本机菜单的方法和属性。flash.events:EventDispatcher NativeMenu 类包含用于定义本机菜单的方法和属性。

AIR 配置文件支持:所有桌面操作系统均支持此功能,但移动设备或用于电视的 AIR 设备不支持此功能。您可以使用 NativeMenu.isSupported 属性在运行时测试是否受支持。有关在多个配置文件之间支持 API 的详细信息,请参阅 AIR 配置文件支持

本机菜单是一种由操作系统(而不是您的应用程序)控制和调出的菜单。AIR 支持下列类型的本机菜单:

  • 应用程序菜单,OS X 支持此类型的菜单。使用 NativeApplication.supportsMenu 属性测试主机操作系统是否支持应用程序菜单。应用程序菜单显示在 Mac 桌面顶部的菜单栏中。OS X 为每个应用程序都提供了一个默认菜单,但其中许多菜单命令不起作用。您可以向默认项添加事件侦听器,替换单个菜单和项目或甚至替换整个默认菜单。使用 NativeApplication menu 属性访问应用程序菜单对象。
  • 窗口菜单,Windows 和 Linux 支持此类型的菜单。使用 NativeWindow.supportsMenu 属性测试主机操作系统是否支持窗口菜单。窗口菜单显示在窗口标题栏的底部。菜单所占用的区域不是窗口舞台的一部分。应用程序无法进入此区域。使用 NativeWindow menu 属性将菜单分配给窗口。
  • 停靠图标菜单,OS X 支持此类型的菜单。使用 NativeApplication.supportsDockIcon 属性测试主机操作系统是否支持停靠图标。停靠图标菜单中的项显示在操作系统提供的默认项的上方。应用程序代码无法访问这些默认项。将菜单分配给应用程序的 DockIcon 对象的 menu 属性。
  • 系统任务栏图标菜单,Windows 和大部分 Linux 操作系统都支持此类型的菜单。使用 NativeApplication.supportsSystemTrayIcon 属性测试主机操作系统是否支持系统任务栏图标。右键单击系统任务栏图标即可显示该图标菜单,这与上下文菜单的形式基本相同。将菜单分配给应用程序 SystemTrayIcon 对象的 menu 属性。
  • 上下文菜单,所有操作系统都支持此类型的菜单。例如,在应用程序中显示的 InteractiveObject 上右键单击或按住 Command 键单击时,作为对用户界面事件的响应,将显示上下文菜单。用于显示菜单的 UI 机制会随主机操作系统和硬件的不同而有所差异。将菜单分配给 InteractiveObject 的 contextMenu 属性。在 AIR 中,可使用 NativeMenu 类或 ContextMenu 类创建上下文菜单。在 Flash Player 中,只能使用 ContextMenu 类。在 AIR 中,ContextMenus 不包含内置项;不显示默认的上下文菜单。
  • 弹出菜单,所有操作系统都支持此类型的菜单。弹出菜单与上下文菜单的功能相同,但是弹出菜单要使用菜单 display() 方法才能显示,而不是作为对用户界面事件的响应显示。弹出菜单不会附加到任何其他对象中。仅创建本机菜单和调用 display() 方法。

菜单对象包含菜单项。菜单项可表示命令、子菜单或分隔线。使用 addItem()addItemAt() 方法向菜单中添加菜单项。菜单项的显示顺序与菜单的 items 数组中的项的显示顺序匹配。

要创建子菜单,可向父级菜单对象添加一个菜单项。将表示子菜单的菜单对象分配给父级菜单中匹配菜单项的 submenu 属性。

注意:窗口的根菜单和应用程序菜单必须只包含子菜单项;不表示子菜单的项可能不予显示,这些项与用户对这些菜单类型的预期相反。

当选择了菜单中的命令项或其子菜单之一时,菜单将调度 select 事件。(子菜单和分隔符项不可选择。)事件对象的 target 属性将引用所选项目。

在显示菜单前的一瞬间并且按下附加到菜单项之一的等效键时,菜单调度 preparing 事件。您可以根据应用程序的当前状态使用此事件来更新菜单内容。

注意:如果正在使用 Flex Framework,请考虑使用 FlexNativeMenu 类。以声明方式在 MXML 中定义菜单通常比编写 ActionScript 代码来逐项创建菜单结构更简单。

flash.display.InteractiveObject.contextMenuflash.display.NativeMenuItemflash.display.NativeWindow.menuflash.desktop.DockIconflash.desktop.SystemTrayIconflash.desktop.NativeApplication.menuflash.desktop.NativeApplication.iconmx.controls.FlexNativeMenupreparing 在显示菜单之前的一瞬间且按下等效键时,由 NativeMenu 对象调度。flash.events.Event.PREPARINGflash.events.Event 在显示菜单之前的一瞬间且按下等效键时,由 NativeMenu 对象调度。

在显示菜单之前或用户按下等效键时,侦听此事件以更新菜单。在完全计算等效键之前调度 preparing 事件。您可以在 preparing 事件处理函数中从菜单中启用、禁用或删除菜单项,这些更改将在处理等效键时生效。例如,如果您删除或禁用分配给触发等效键的菜单项,则事件顺序将有效地被取消,不调度 select 事件。preparing 事件还由菜单中的项调度。

preparing 事件替代 displaying 事件并提供其他功能。侦听 preparing 事件或 displaying 事件,但不能同时侦听两者。

displaying 此 NativeMenu 对象在显示菜单前立即进行调度。flash.events.Event.DISPLAYINGflash.events.Event 此 NativeMenu 对象在显示菜单前立即进行调度。

侦听此事件可在显示菜单之前更新菜单。displaying 事件还由菜单中的项调度。

preparing 事件替代 displaying 事件并提供其他功能。侦听 preparing 事件或 displaying 事件,但不能同时侦听两者。

注意:在 Mac OS X 上,AIR 2.6 之前的版本,当用户按下等效键时,菜单和菜单项调度 displaying 事件。(在其他操作系统上,不为等效键交互调度此事件。)从 AIR 2.6 开始,当用户按下等效键时,不再调度 displaying 事件。而是使用 preparing 事件。

select 在选择其菜单项之一或其后代子菜单之一中的项目时由此 NativeMenu 对象调度。flash.events.Event.SELECTflash.events.Event 在选择其菜单项之一或其后代子菜单之一中的项目时由此 NativeMenu 对象调度。

select 事件将从菜单项冒泡 到包含它的菜单,并贯穿父菜单链到达根菜单对象。该事件对象的 target 属性将引用所选的 NativeMenuItem 对象;currentTarget 属性将引用此 NativeMenu 对象。

NativeMenu 创建新的 NativeMenu 对象。 创建新的 NativeMenu 对象。 addItemAt 在指定位置插入一个菜单项。如果 itemnullArgumentErrorArgumentError如果 item 为其他菜单的成员。 ArgumentErrorArgumentError如果 index 位于菜单的 items 数组的范围以外。 RangeErrorRangeErrorflash.display:NativeMenuItemitemflash.display:NativeMenuItem要插入的 NativeMenuItem 对象。 indexint菜单中要插入该菜单项的位置(从 0 开始)。

注意:将一个项添加到菜单时,如果该项的子菜单设置为菜单本身(造成循环引用),可能导致应用程序挂起。

在指定位置插入一个菜单项。该位置从顶部索引。将 index 参数设置为零,在菜单顶部插入项。所有菜单类型:窗口、应用程序、系统任务栏图标、停靠图标、上下文和弹出菜单,均从顶部索引菜单位置。
addItem 在菜单底部添加一个菜单项。如果 itemnullArgumentErrorArgumentError如果 item 为其他菜单的成员。 ArgumentErrorArgumentErrorflash.display:NativeMenuItemitemflash.display:NativeMenuItem要在菜单底部添加的 NativeMenuItem 对象。 在菜单底部添加一个菜单项。

创建上下文菜单时,可以添加 NativeMenuItem 或 ContextMenuItem 对象。但是,建议在上下文菜单中仅使用一种类型的对象,以使菜单中的所有项都具有相同的属性。

注意:将一个项添加到菜单时,如果该项的子菜单设置为菜单本身(造成循环引用),可能导致应用程序挂起。

addSubmenuAt 通过在指定位置插入新菜单项,在菜单中添加子菜单。为该子菜单创建的 NativeMenuItem 对象。 flash.display:NativeMenuItemsubmenuflash.display:NativeMenu定义要添加的子菜单的 NativeMenu 对象。 indexint此菜单的 items 数组中要插入将添加的菜单项的位置。 labelString要添加的菜单项的显示标签。 通过在指定位置插入新菜单项,在菜单中添加子菜单。

调用 addSubMenuAt() 方法等效于创建一个新菜单项、将其插入到菜单中需要的位置,并将 NativeMenu 对象分配给该项目的 submenu 属性。

注意:将菜单添加为其自身的一个子菜单(在循环引用中)可能导致应用程序挂起。

addSubmenu 通过插入新菜单项,在菜单中添加子菜单。为该子菜单创建的 NativeMenuItem 对象。 flash.display:NativeMenuItemsubmenuflash.display:NativeMenu定义要添加的子菜单的 NativeMenu 对象。 labelString要添加的菜单项的显示标签。 通过插入新菜单项,在菜单中添加子菜单。

调用 addSubMenu() 方法等效于创建一个新菜单项、将其添加到菜单,并将 NativeMenu 对象分配给该项目的 submenu 属性。

注意:将菜单添加为其自身的一个子菜单(在循环引用中)可能导致应用程序挂起。

clone 创建菜单和所有项目的副本。flash.display:NativeMenu 创建菜单和所有项目的副本。 containsItem 报告此菜单是否包含指定的菜单项。如果 item 位于此菜单中,则为 trueBooleanitemflash.display:NativeMenuItem要查找的 NativeMenuItem 对象。 报告此菜单是否包含指定的菜单项。 display 在指定位置弹出此菜单。stageflash.display:Stage要显示此菜单的 Stage 对象。 stageXNumber相对于要显示此菜单的舞台原点的水平像素数。 stageYNumber相对于要显示此菜单的舞台原点的垂直像素数。 在指定位置弹出此菜单。 getItemAt 获取指定索引处的菜单项。如果 index 位于此菜单的 items 数组的范围以外。 RangeErrorRangeError位于菜单中指定位置的 NativeMenuItem 对象。 flash.display:NativeMenuItemindexint要返回的项目的位置(从 0 开始)。 获取指定索引处的菜单项。 getItemByName 获取具有指定名称的菜单项。具有指定名称的 NativeMenuItem 对象,如果菜单中没有这样的项目,则为 nullflash.display:NativeMenuItemnameString要查找的字符串。 获取具有指定名称的菜单项。

注意:默认情况下不分配菜单项的 name 属性。

getItemIndex 获取指定项目的位置。此菜单中指定项目的位置(从零开始),如果项目不在此菜单中,为 -1intitemflash.display:NativeMenuItem要查找的 NativeMenuItem 对象。 获取指定项目的位置。 removeAllItems 删除菜单中的所有项目。 删除菜单中的所有项目。 removeItemAt 删除并返回指定索引处的菜单项。如果 index 位于此菜单的 items 数组的范围以外。 RangeErrorRangeError已删除的 NativeMenuItem 对象。 flash.display:NativeMenuItemindexint要删除的项目的位置(从 0 开始)。 删除并返回指定索引处的菜单项。 removeItem 删除指定的菜单项。如果 item 不在此菜单中 RangeErrorRangeErrorflash.display:NativeMenuItemitemflash.display:NativeMenuItem要从此菜单删除的 NativeMenuItem 对象。 删除指定的菜单项。 setItemIndex 将菜单项移到指定位置。如果 index 位于此菜单的 items 数组的范围以外。 RangeErrorRangeErroritemflash.display:NativeMenuItem要移动的 NativeMenuItem 对象。 indexint菜单中要将 item 移动到的位置(从 0 开始)。 将菜单项移到指定位置。如果菜单中还没有该项目,调用此方法时会将项目添加到菜单中。 isSupported 表示客户端系统上是否支持任何形式的本机菜单。Boolean 表示客户端系统上是否支持任何形式的本机菜单。 flash.display.NativeWindow.supportsMenuflash.desktop.NativeApplicationitems 此菜单中 NativeMenuItem 对象的数组。Array 此菜单中 NativeMenuItem 对象的数组。

数组按显示顺序排序。

注意:此属性在 AIR 1.0 中是只读的, 而在 AIR 1.1 中则变为可读/写的。

numItems 此菜单中 NativeMenuItem 对象的数量。int 此菜单中 NativeMenuItem 对象的数量。 parent 父菜单。flash.display:NativeMenu 父菜单。

根(顶级)菜单对象的 parentnull

StageOrientation StageOrientation 类定义枚举此舞台和设备的可能方向的常量。StageOrientation 类提供 Stage 类的 orientation 属性和引用 Stage 方向的其他属性和方法的值。 Object StageOrientation 类定义枚举此舞台和设备的可能方向的常量。 flash.display.Stage.orientationflash.display.Stage.setOrientation()flash.display.Stage.deviceOrientationflash.events.StageOrientationEvent.afterOrientationflash.events.StageOrientationEvent.beforeOrientationDEFAULT 指定舞台当前位于设备的默认方向(正面向上)。defaultString 指定舞台当前位于设备的默认方向(正面向上)。 ROTATED_LEFT 指定舞台当前相对于默认方向向左旋转。rotatedLeftString 指定舞台当前相对于默认方向向左旋转。

注意:当设备的方向向左旋转时,舞台方向必须向右旋转,以保持直立。

ROTATED_RIGHT 指定舞台当前相对于默认方向向右旋转。rotatedRightString 指定舞台当前相对于默认方向向右旋转。

注意:当设备的方向向右旋转时,舞台方向必须向左旋转,以保持直立。

UNKNOWN 指定设备尚未确定方向。unknownString 指定设备尚未确定方向。当设备平放在桌子上并且应用程序初始化时,会出现此状态。 UPSIDE_DOWN 指定舞台当前相对于默认方向向下翻转。upsideDownString 指定舞台当前相对于默认方向向下翻转。
DisplayObjectContainer DisplayObjectContainer 类是可用作显示列表中显示对象容器的所有对象的基类。可以包含子对象的所有显示对象的抽象基类。 flash.display:InteractiveObject DisplayObjectContainer 类是可用作显示列表中显示对象容器的所有对象的基类。该显示列表管理 Flash 运行时中显示的所有对象。使用 DisplayObjectContainer 类排列显示列表中的显示对象。每个 DisplayObjectContainer 对象都有自己的子级列表,用于组织对象的 Z 轴顺序。Z 轴顺序是由前至后的顺序,可确定哪个对象绘制在前,哪个对象绘制在后等。

DisplayObject 是一种抽象基类;因此,不能直接调用 DisplayObject。调用 new DisplayObject() 会引发 ArgumentError 异常。

DisplayObjectContainer 类是可以包含子对象的所有对象的抽象基类。无法直接对其进行实例化;调用 new DisplayObjectContainer() 构造函数会引发 ArgumentError 异常。

有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“显示编程”一章。

下例使用类 DisplayObjectContainerExample 连续创建五个橙色正方形。执行下列步骤可完成该任务:
  1. 构造函数调用 configureAssets() 方法。
  2. configureAssets() 方法创建 childlastChild Sprite 对象。
  3. for 循环创建 5 个橙色正方形并依次放置它们。
  4. 每次创建 CustomSprite 对象时,其构造函数都调用 CustomSprite 对象的 draw() 方法,该方法通过调用 Graphics 类的 beginFill()drawRect()endFill() 方法创建 50 x 50 像素的正方形。addChild() 将每个正方形添加到显示列表。
package { import flash.display.DisplayObject; import flash.display.Sprite; public class DisplayObjectContainerExample extends Sprite { private var gutter:uint = 5; private var childCount:uint = 5; public function DisplayObjectContainerExample() { configureAssets(); } private function configureAssets():void { var child:Sprite = new CustomSprite(); var lastChild:Sprite = child; for (var i:uint = 1; i <= childCount; i++) { child = new CustomSprite(); child.x = lastChild.x + lastChild.width + gutter; addChild(child); lastChild = child; } } } } import flash.display.Sprite; class CustomSprite extends Sprite { private var size:uint = 50; private var bgColor:uint = 0xFFCC00; public function CustomSprite() { draw(size, size); } private function draw(w:uint, h:uint):void { graphics.beginFill(bgColor); graphics.drawRect(0, 0, w, h); graphics.endFill(); } }
flash.display.DisplayObjectDisplayObjectContainer 调用新的 DisplayObjectContainer() 构造函数会引发 ArgumentError 异常。 调用 new DisplayObjectContainer() 构造函数会引发 ArgumentError 异常。但是,可以调用 DisplayObjectContainer 的以下子类的构造函数:
  • new Loader()
  • new Sprite()
  • new MovieClip()
addChildAt 将一个 DisplayObject 子实例添加到该 DisplayObjectContainer 实例中。在子级列表中不存在索引位置时引发。 RangeErrorRangeError在子项与父项相同时引发。此外,当调用方是要添加的子项的子项(即孙项等)时也会引发。 ArgumentErrorArgumentErrorchild 参数中传递的 DisplayObject 实例。 flash.display:DisplayObjectchildflash.display:DisplayObject要作为该 DisplayObjectContainer 实例的子项添加的 DisplayObject 实例。 indexint添加该子项的索引位置。如果指定当前占用的索引位置,则该位置以及所有更高位置上的子对象会在子级列表中上移一个位置。 向此 DisplayObjectContainer 示例中添加子对象。 将一个 DisplayObject 子实例添加到该 DisplayObjectContainer 实例中。该子项将被添加到指定的索引位置。索引为 0 表示该 DisplayObjectContainer 对象的显示列表的后(底)部。

例如,下例在索引位置 0、2、1 处分别显示 a、b、c 三个显示对象:

如果添加一个已将其它显示对象容器作为父项的子对象,则会从其它显示对象容器的子列表中删除该对象。

下例创建一个 container 显示对象容器,并将一个显示对象 circle1 添加到其显示列表。然后,通过调用 container.addChildAt(circle2, 0),它将 circle2 对象添加到索引位置零(后面),并将 circle1 对象移动到索引位置 1: import flash.display.Sprite; var container:Sprite = new Sprite(); var circle1:Sprite = new Sprite(); var circle2:Sprite = new Sprite(); container.addChild(circle1); container.addChildAt(circle2, 0); trace(container.getChildAt(0) == circle2); // true trace(container.getChildAt(1) == circle1); // true
addChild()addedflash.events:Event将显示对象添加到显示列表中时调度。 将显示对象添加到显示列表中时调度。
addChild 将一个 DisplayObject 子实例添加到该 DisplayObjectContainer 实例中。在子项与父项相同时引发。此外,当调用方是要添加的子项的子项(即孙项等)时也会引发。 ArgumentErrorArgumentErrorchild 参数中传递的 DisplayObject 实例。 flash.display:DisplayObjectchildflash.display:DisplayObject要作为该 DisplayObjectContainer 实例的子项添加的 DisplayObject 实例。 向此 DisplayObjectContainer 示例中添加子对象。 将一个 DisplayObject 子实例添加到该 DisplayObjectContainer 实例中。子项将被添加到该 DisplayObjectContainer 实例中其他所有子项的前(上)面。(要将某子项添加到特定索引位置,请使用 addChildAt() 方法。)

如果添加一个已将其它显示对象容器作为父项的子对象,则会从其它显示对象容器的子列表中删除该对象。

注意:stage.addChild() 命令可导致与发布的 SWF 文件有关的问题,包括安全性问题和与其他加载的 SWF 文件的冲突。无论将多少 SWF 文件加载到运行时中,Flash 运行时实例中都只有一个 Stage。因此,通常无论如何也不应将对象直接添加到 Stage。Stage 应该包含的唯一对象是根对象。创建 DisplayObjectContainer 以包含显示列表上的所有项目。如果需要,随后将 DisplayObjectContainer 实例添加到 Stage。

下例设置了两个名称分别为 container1container2 的 Sprite 对象。Sprite 是一种显示对象容器。该示例调用 addChild() 方法以设置显示层次结构:container1container2 的子项,其他两个显示对象 circle1circle2container1 的子项。trace() 方法的调用显示每个对象的子项数。请注意,孙项并不包括在 numChildren 计数中: import flash.display.Sprite; var container1:Sprite = new Sprite(); var container2:Sprite = new Sprite(); var circle1:Sprite = new Sprite(); circle1.graphics.beginFill(0xFFCC00); circle1.graphics.drawCircle(40, 40, 40); var circle2:Sprite = new Sprite(); circle2.graphics.beginFill(0x00CCFF); circle2.graphics.drawCircle(80, 40, 40); container2.addChild(container1); container1.addChild(circle1); container1.addChild(circle2); trace(container1.numChildren); // 2 trace(container2.numChildren); // 1 trace(circle1.numChildren); // 0 trace(circle2.numChildren); // 0
addChildAt()addedflash.events:Event将显示对象添加到显示列表中时调度。 将显示对象添加到显示列表中时调度。
areInaccessibleObjectsUnderPoint 表示安全限制是否会导致出现以下情况:在列表中忽略了使用指定 point 点调用 DisplayObjectContainer.getObjectsUnderPoint() 方法时返回的所有显示对象。如果点包含具有安全限制的子显示对象,则为 trueBooleanpointflash.geom:Point要查看其下方内容的点。 表示安全限制是否会导致出现以下情况:在列表中忽略了使用指定 point 点调用 DisplayObjectContainer.getObjectsUnderPoint() 方法时返回的所有显示对象。默认情况下,一个域中的内容无法访问另一个域中的对象,除非通过调用 Security.allowDomain() 方法来允许它们这样做。有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

point 参数位于舞台的坐标空间中,此坐标空间可能与显示对象容器的坐标空间不同(除非显示对象容器是舞台)。您可以使用 globalToLocal()localToGlobal() 方法在这些坐标空间之间转换点。

下面的代码将创建一个名为 container 的显示对象容器。下一个代码块使用 Loader 对象从远程文件服务器中加载一个名为“test.jpg”的 JPEG 文件。请注意,LoaderContext 对象的 checkPolicyFile 属性(在 load() 方法中用作参数)被设置为 false。加载了该文件后,代码将调用 loaded() 方法,后者又将调用 container.areInaccessibleObjectsUnderPoint(),这将返回 true 值,因为假定被加载的内容来自无法访问的域: import flash.display.Sprite; import flash.display.Loader; import flash.system.LoaderContext; import flash.net.URLRequest; import flash.events.Event; import flash.geom.Point; var container:Sprite = new Sprite(); var urlReq:URLRequest = new URLRequest("http://localhost/RemoteFile.swf"); var ldr:Loader = new Loader(); var context:LoaderContext = new LoaderContext(); context.checkPolicyFile = false; ldr.load(urlReq, context); ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, loaded); ldr.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, urlNotFound); function loaded(event:Event):void { var pt:Point = new Point(1, 1); trace(container.areInaccessibleObjectsUnderPoint(pt)); // true } function urlNotFound(event:Event):void { trace("The URL was not found."); } 此示例假定由此代码生成的 SWF 文件从与 JPEG 文件不同的域中加载,并且加载的 JPEG 文件占用点 (1, 1)。
flash.system.Security.allowDomain()getObjectsUnderPoint()DisplayObject.globalToLocal()DisplayObject.localToGlobal()
contains 确定指定显示对象是 DisplayObjectContainer 实例的子项还是该实例本身。如果 child 对象是 DisplayObjectContainer 的子项或容器本身,则为 true;否则为 falseBooleanchildflash.display:DisplayObject要测试的子对象。 确定指定显示对象是 DisplayObjectContainer 实例的子项还是该实例本身。搜索包括整个显示列表(其中包括此 DisplayObjectContainer 实例)。孙项、曾孙项等,每项都返回 true 下例设置多个 Sprite 对象并将其中一些对象添加到其它对象的子列表中。(Sprite 对象是一种显示对象容器。) 通过调用 contains() 方法可显示各种对象之间的关系: import flash.display.Sprite; var sprite1:Sprite = new Sprite(); var sprite2:Sprite = new Sprite(); var sprite3:Sprite = new Sprite(); var sprite4:Sprite = new Sprite(); sprite1.addChild(sprite2); sprite2.addChild(sprite3); trace(sprite1.contains(sprite1)); // true trace(sprite1.contains(sprite2)); // true trace(sprite1.contains(sprite3)); // true trace(sprite1.contains(sprite4)); // false getChildAt 返回位于指定索引处的子显示对象实例。在子级列表中不存在索引时引发。 RangeErrorRangeError此子显示对象属于您无权访问的沙箱。通过让子影片调用 Security.allowDomain(),可以避免发生这种情况。 SecurityErrorSecurityError位于指定索引位置处的子显示对象。 flash.display:DisplayObjectindexint子对象的索引位置。 返回位于指定索引处的子显示对象实例。 下例创建一个名为 container 的显示对象容器,然后将 3 个显示对象添加到 container 对象的子级列表。getChildAt() 方法的调用随后会显示这些子对象的位置: import flash.display.Sprite; var container:Sprite = new Sprite(); var sprite1:Sprite = new Sprite(); var sprite2:Sprite = new Sprite(); var sprite3:Sprite = new Sprite(); container.addChild(sprite1); container.addChild(sprite2); container.addChildAt(sprite3, 0); trace(container.getChildAt(0) == sprite3); // true trace(container.getChildAt(1) == sprite1); // true trace(container.getChildAt(2) == sprite2); // true getChildByName()getChildByName 返回具有指定名称的子显示对象。此子显示对象属于您无权访问的沙箱。通过让子影片调用 Security.allowDomain() 方法,可以避免发生这种情况。 SecurityErrorSecurityError具有指定名称的子显示对象。 flash.display:DisplayObjectnameString要返回的子项的名称。 返回具有指定名称的子显示对象。如果多个子显示对象具有指定名称,则该方法会返回子级列表中的第一个对象。

getChildAt() 方法比 getChildByName() 方法快。getChildAt() 方法从缓存数组中访问子项,而 getChildByName() 方法则必须遍历链接的列表来访问子项。

下例创建一个名为 container 的显示对象容器,然后向该容器中添加两个子显示对象。然后,代码会调用 getChildByName()getChildIndex() 方法来返回具有 name "sprite1"container 对象子项的索引位置。 import flash.display.Sprite; import flash.display.DisplayObject; var container:Sprite = new Sprite(); var sprite1:Sprite = new Sprite(); sprite1.name = "sprite1"; var sprite2:Sprite = new Sprite(); sprite2.name = "sprite2"; container.addChild(sprite1); container.addChild(sprite2); var target:DisplayObject = container.getChildByName("sprite1"); trace(container.getChildIndex(target)); // 0
getChildAt()flash.display.DisplayObject.name
getChildIndex 返回 DisplayObject 的 child 实例的索引位置。在子参数不是此对象的子项时引发。 ArgumentErrorArgumentError要标识的子显示对象的索引位置。 intchildflash.display:DisplayObject要标识的 DisplayObject 实例。 返回 DisplayObject 子实例的索引编号。 返回 DisplayObject 的 child 实例的索引位置。 下例创建一个名为 container 的显示对象容器,然后向该容器中添加两个子显示对象。然后,代码会调用 getChildByName()getChildIndex() 方法来返回具有 name "sprite1"container 对象子项的索引位置。 import flash.display.Sprite; import flash.display.DisplayObject; var container:Sprite = new Sprite(); var sprite1:Sprite = new Sprite(); sprite1.name = "sprite1"; var sprite2:Sprite = new Sprite(); sprite2.name = "sprite2"; container.addChild(sprite1); container.addChild(sprite2); var target:DisplayObject = container.getChildByName("sprite1"); trace(container.getChildIndex(target)); // 0 getObjectsUnderPoint 返回对象的数组,这些对象位于指定点下,并且是该 DisplayObjectContainer 实例的子项(或孙子项,依此类推)。一个对象数组,这些对象位于指定点下方,并且是该 DisplayObjectContainer 实例的子项(或孙项等等)。 Arraypointflash.geom:Point要查看其下方内容的点。 返回对象的数组,这些对象位于指定点下,并且是该 DisplayObjectContainer 实例的子项(或孙子项,依此类推)。返回的数组中将省略出于安全原因而无法访问的任何子对象。要确定此安全限制是否影响返回的数组,请调用 areInaccessibleObjectsUnderPoint() 方法。

point 参数位于舞台的坐标空间中,此坐标空间可能与显示对象容器的坐标空间不同(除非显示对象容器是舞台)。您可以使用 globalToLocal()localToGlobal() 方法在这些坐标空间之间转换点。

下例创建一个名为 container 的显示对象容器,然后向该容器中添加两个重叠的子显示对象。然后,代码会调用 getObjectsUnderPoint() 两次(第一次使用只接触到一个对象的点,第二次使用对象的重叠点),并且返回数组的 length 将显示容器中每个点上的对象数量: import flash.display.Sprite; import flash.geom.Point; var container:Sprite = new Sprite(); var square1:Sprite = new Sprite(); square1.graphics.beginFill(0xFFCC00); square1.graphics.drawRect(0, 0, 40, 40); var square2:Sprite = new Sprite(); square2.graphics.beginFill(0x00CCFF); square2.graphics.drawRect(20, 0, 30, 40); container.addChild(square1); container.addChild(square2); var pt:Point = new Point(10, 20); var objects:Array = container.getObjectsUnderPoint(pt); trace(objects.length); // 1 pt = new Point(35, 20); objects = container.getObjectsUnderPoint(pt); trace(objects.length); // 2
areInaccessibleObjectsUnderPoint()DisplayObject.globalToLocal()DisplayObject.localToGlobal()
removeChildAt 从 DisplayObjectContainer 的子列表中指定的 index 位置删除子 DisplayObject。此子显示对象属于执行调用的对象无权访问的沙箱。通过让子影片调用 Security.allowDomain() 方法,可以避免发生这种情况。 SecurityErrorSecurityError在子级列表中不存在索引时引发。 RangeErrorRangeError已删除的 DisplayObject 实例。 flash.display:DisplayObjectindexint要删除的 DisplayObject 的子索引。 从 DisplayObjectContainer 实例中删除指定 index 位置上的子显示对象。 从 DisplayObjectContainer 的子列表中指定的 index 位置删除子 DisplayObject。将已删除子项的 parent 属性设置为 null;如果没有对该子项的任何其他引用,则将该对象作为垃圾回收。DisplayObjectContainer 中该子项之上的任何显示对象的索引位置都减去 1。

垃圾回收器重新分配未使用的内存空间。当在某处变量或对象不再被主动地引用或存储时,如果不存在对该变量或对象的任何其它引用,则垃圾回收器将清理并擦除其过去占用的内存空间。

下例创建一个名为 container 的显示对象容器,然后向该容器中添加两个子显示对象。接着代码会显示:当您调用 removeChildAt() 方法以删除最低索引位置 (0) 上的子项时,列表中的任何其他子对象将下移一个位置: import flash.display.Sprite; var container:Sprite = new Sprite(); var sprite1:Sprite = new Sprite(); sprite1.name = "sprite1"; var sprite2:Sprite = new Sprite(); sprite2.name = "sprite2"; container.addChild(sprite1); container.addChild(sprite2); trace(container.numChildren) // 2 container.removeChildAt(0); trace(container.numChildren) // 1 trace(container.getChildAt(0).name); // sprite2
removeChild 从 DisplayObjectContainer 实例的子列表中删除指定的 child DisplayObject 实例。在子参数不是此对象的子项时引发。 ArgumentErrorArgumentErrorchild 参数中传递的 DisplayObject 实例。 flash.display:DisplayObjectchildflash.display:DisplayObject要删除的 DisplayObject 实例。 删除 DisplayObjectContainer 实例中的子显示对象。 从 DisplayObjectContainer 实例的子列表中删除指定的 child DisplayObject 实例。将已删除子项的 parent 属性设置为 null;如果不存在对该子项的任何其它引用,则将该对象作为垃圾回收。DisplayObjectContainer 中该子项之上的任何显示对象的索引位置都减去 1。

垃圾回收器重新分配未使用的内存空间。当在某处变量或对象不再被主动地引用或存储时,如果不存在对该变量或对象的任何其它引用,则垃圾回收器将清理并擦除其过去占用的内存空间。

下例创建一个名为 container 的显示对象容器,然后向该容器中添加两个子显示对象。将事件侦听器添加到 container 对象,以便在用户单击容器的子对象时,removeChild() 方法从容器的子级列表中删除单击的子项: import flash.display.DisplayObject; import flash.display.Sprite; import flash.events.MouseEvent; var container:Sprite = new Sprite(); addChild(container); var circle1:Sprite = new Sprite(); circle1.graphics.beginFill(0xFFCC00); circle1.graphics.drawCircle(40, 40, 40); var circle2:Sprite = new Sprite(); circle2.graphics.beginFill(0x00CCFF); circle2.graphics.drawCircle(120, 40, 40); container.addChild(circle1); container.addChild(circle2); container.addEventListener(MouseEvent.CLICK, clicked); function clicked(event:MouseEvent):void { container.removeChild(DisplayObject(event.target)); }
setChildIndex 更改现有子项在显示对象容器中的位置。在子级列表中不存在索引时引发。 RangeErrorRangeError在子参数不是此对象的子项时引发。 ArgumentErrorArgumentErrorchildflash.display:DisplayObject要为其更改索引编号的 DisplayObject 子实例。 indexint生成的 child 显示对象的索引编号。 更改现有子项的索引编号。 更改现有子项在显示对象容器中的位置。这会影响子对象的分层。例如,下例在索引位置 0、1、2 处分别显示 a、b、c 三个显示对象:

在使用 setChildIndex() 方法并指定一个已经占用的索引位置时,唯一发生更改的位置是显示对象先前的位置和新位置之间的位置。所有其他位置将保持不变。如果将一个子项移动到比它当前的索引更低的索引处,则这两个索引之间的所有子项的索引引用都将增加 1。如果将一个子项移动到比它当前的索引更高的索引处,则这两个索引之间的所有子项的索引引用都将减小 1。例如,如果上例中的显示对象容器名为 container,则可以通过调用以下代码来交换带有 a 和 b 标记的显示对象的位置:

container.setChildIndex(container.getChildAt(1), 0);

该代码产生以下对象排列:

下例创建一个名为 container 的显示对象容器,然后向该容器添加三个稍微重叠的子显示对象。当用户单击这些对象中的任何一个对象时,clicked() 方法调用 setChildIndex() 方法,将单击的对象移动到 container 对象的子级列表中最上面的位置: import flash.display.Sprite; import flash.events.MouseEvent; var container:Sprite = new Sprite(); addChild(container); var circle1:Sprite = new Sprite(); circle1.graphics.beginFill(0xFF0000); circle1.graphics.drawCircle(40, 40, 40); circle1.addEventListener(MouseEvent.CLICK, clicked); var circle2:Sprite = new Sprite(); circle2.graphics.beginFill(0x00FF00); circle2.graphics.drawCircle(100, 40, 40); circle2.addEventListener(MouseEvent.CLICK, clicked); var circle3:Sprite = new Sprite(); circle3.graphics.beginFill(0x0000FF); circle3.graphics.drawCircle(70, 80, 40); circle3.addEventListener(MouseEvent.CLICK, clicked); container.addChild(circle1); container.addChild(circle2); container.addChild(circle3); addChild(container); function clicked(event:MouseEvent):void { var circle:Sprite = Sprite(event.target); var topPosition:uint = container.numChildren - 1; container.setChildIndex(circle, topPosition); }
addChildAt()getChildIndex()
swapChildrenAt 在子级列表中两个指定的索引位置,交换子对象的 Z 轴顺序(前后顺序)。如果子级列表中不存在任何一个索引。 RangeErrorRangeErrorindex1int第一个子对象的索引位置。 index2int第二个子对象的索引位置。 在子级列表中两个指定的索引位置,交换子对象的 Z 轴顺序(前后顺序)。显示对象容器中所有其他子对象的索引位置保持不变。 下例创建一个名为 container 的显示对象容器,接着向该容器添加三个子显示对象,然后显示对 swapChildrenAt() 方法的调用如何重新排列该显示对象容器的子级列表: import flash.display.Sprite; var container:Sprite = new Sprite(); var sprite1:Sprite = new Sprite(); sprite1.name = "sprite1"; var sprite2:Sprite = new Sprite(); sprite2.name = "sprite2"; var sprite3:Sprite = new Sprite(); sprite3.name = "sprite3"; container.addChild(sprite1); container.addChild(sprite2); container.addChild(sprite3); trace(container.getChildAt(0).name); // sprite1 trace(container.getChildAt(1).name); // sprite2 trace(container.getChildAt(2).name); // sprite3 container.swapChildrenAt(0, 2); trace(container.getChildAt(0).name); // sprite3 trace(container.getChildAt(1).name); // sprite2 trace(container.getChildAt(2).name); // sprite1 swapChildren 交换两个指定子对象的 Z 轴顺序(从前到后顺序)。在子参数不是此对象的子项时引发。 ArgumentErrorArgumentErrorchild1flash.display:DisplayObject第一个子对象。 child2flash.display:DisplayObject第二个子对象。 交换两个指定子对象的 Z 轴顺序(从前到后顺序)。显示对象容器中所有其他子对象的索引位置保持不变。 下例创建一个名为 container 的显示对象容器,接着向该容器添加两个子显示对象,然后显示调用 swapChildren() 方法的效果: import flash.display.Sprite; var container:Sprite = new Sprite(); var sprite1:Sprite = new Sprite(); sprite1.name = "sprite1"; var sprite2:Sprite = new Sprite(); sprite2.name = "sprite2"; container.addChild(sprite1); container.addChild(sprite2); trace(container.getChildAt(0).name); // sprite1 trace(container.getChildAt(1).name); // sprite2 container.swapChildren(sprite1, sprite2); trace(container.getChildAt(0).name); // sprite2 trace(container.getChildAt(1).name); // sprite1 mouseChildren 确定对象的子级是否支持鼠标或用户输入设备。Boolean 确定对象的子级是否支持鼠标或用户输入设备。如果对象支持鼠标或用户输入设备,用户可以通过使用鼠标或用户输入设备与之交互。默认值为 true

当您使用 Sprite 类的实例(而不是使用 SimpleButton 类)来创建按钮时,此属性很有用。当您使用 Sprite 实例来创建按钮时,可以选择使用 addChild() 方法添加其他 Sprite 实例来修饰该按钮。此过程可能导致鼠标事件出现意外行为,因为当您期望父实例成为鼠标事件的目标对象时,作为子项添加的 Sprite 实例却可能成为目标对象。要确保父实例用作鼠标事件的目标对象,您可以将父实例的 mouseChildren 属性设置为 false

设置此属性不会调度任何事件。您必须使用 addEventListener() 方法才能创建交互式功能。

下例设置一个名为 container 的 Sprite 对象(一种显示对象容器),并显示:当您将该对象的 mouseChildren 属性设置为 false 时,mouseClick 事件的目标为 container 对象,而不是其子对象中的任一个: import flash.display.Sprite; import flash.events.MouseEvent; var container:Sprite = new Sprite(); container.name = "container"; addChild(container); var circle:Sprite = new Sprite(); circle.name = "circle"; circle.graphics.beginFill(0xFFCC00); circle.graphics.drawCircle(40, 40, 40); container.addChild(circle); container.mouseChildren = false; container.addEventListener(MouseEvent.CLICK, clicked); function clicked(event:MouseEvent):void { trace(event.target.name); // container }
flash.display.Sprite.buttonModeflash.events.EventDispatcher.addEventListener()
numChildren 返回此对象的子项数目。int 返回此对象的子项数目。 下例设置了两个名称分别为 container1container2 的 Sprite 对象。Sprite 是一种显示对象容器。该示例调用 addChild() 方法以设置显示层次结构:container1container2 的子项,其他两个显示对象 circle1circle2container1 的子项。trace() 方法的调用显示每个对象的子项数。请注意,孙项并不包括在 numChildren 计数中: import flash.display.Sprite; var container1:Sprite = new Sprite(); var container2:Sprite = new Sprite(); var circle1:Sprite = new Sprite(); circle1.graphics.beginFill(0xFFCC00); circle1.graphics.drawCircle(40, 40, 40); var circle2:Sprite = new Sprite(); circle2.graphics.beginFill(0x00CCFF); circle2.graphics.drawCircle(80, 40, 40); container2.addChild(container1); container1.addChild(circle1); container1.addChild(circle2); trace(container1.numChildren); // 2 trace(container2.numChildren); // 1 trace(circle1.numChildren); // 0 trace(circle2.numChildren); // 0 tabChildren 确定对象的子项是否支持 Tab 键。Boolean调用 Stage 对象的此属性会引发异常。Stage 对象未实现此属性。 IllegalOperationErrorflash.errors:IllegalOperationError 确定对象的子项是否支持 Tab 键。为对象的子项启用或禁用 Tab 切换。默认值为 true

注意:不要将 tabChildren 属性用于 Flex。而应使用 mx.core.UIComponent.hasFocusableChildren 属性。

下例创建一个 container1 显示对象容器,并将两个显示对象 circle1circle2 添加到其子级列表。该示例将子项的 tabChildren 设置为 false,以便它可以使用 tabIndex 管理自己的 Tab 键顺序: import flash.display.Sprite; var container:Sprite = new Sprite(); container.tabChildren = false; var circle1:Sprite = new Sprite(); circle1.graphics.beginFill(0xFFCC00); circle1.graphics.drawCircle(40, 40, 40); circle1.tabIndex = 1; var circle2:Sprite = new Sprite(); circle2.graphics.beginFill(0x00CCFF); circle2.graphics.drawCircle(120, 40, 40); circle2.tabIndex = 0; container.addChild(circle1); container.addChild(circle2); 要查看此示例的结果,请编译并运行文件。当选择其中一个圆时,可以按 Tab 键切换具有焦点(显示为黄色加亮矩形)的显示对象。
textSnapshot 返回此 DisplayObjectContainer 实例的 TextSnapshot 对象。flash.text:TextSnapshot 返回此 DisplayObjectContainer 实例的 TextSnapshot 对象。 下例只适用于 Flash 创作环境。Flex 没有提供用于将静态文本添加到文件的任何方法。要为此示例准备 Flash 文件,请在影片的第一帧中添加一个或多个静态文本字段。然后将以下脚本插入到第一帧并运行该文件。输出将为所添加的静态文本: trace(this.textSnapshot.getText(0, this.textSnapshot.charCount)); flash.text.TextSnapshot
GraphicsGradientFill 定义渐变填充。flash.display:IGraphicsFillflash.display:IGraphicsDataObject 定义渐变填充。

将 GraphicsGradientFill 对象与 Graphics.drawGraphicsData() 方法一起使用。绘制 GraphicsGradientFill 对象与调用 Graphics.beginGradientFill() 方法是等效的。

flash.display.Graphics.beginGradientFill()flash.display.Graphics.drawGraphicsData()GraphicsGradientFill 创建新的 GraphicsGradientFill 对象。typeStringlinear用于指定要使用哪种渐变类型的 GradientType 类的值:GradientType.LINEARGradientType.RADIALcolorsArraynull渐变中使用的 RGB 十六进制颜色值的数组(例如,红色为 0xFF0000,蓝色为 0x0000FF,等等)。可以至多指定 15 种颜色。对于每种颜色,请在 alphas 和 ratios 参数中指定对应值。 alphasArraynullcolors 数组中对应颜色的 alpha 值数组;有效值为 0 到 1。如果值小于 0,则使用 0。如果值大于 1,则使用 1。 ratiosArraynull颜色分布比率的数组;有效值为 0 到 255。该值定义 100% 采样的颜色所在位置的宽度百分比。值 0 表示渐变框中的左侧位置,255 表示渐变框中的右侧位置。 matrixnull一个由 flash.geom.Matrix 类定义的转换矩阵。flash.geom.Matrix 类包括 createGradientBox() 方法,通过该方法可以方便地设置矩阵,以便与 beginGradientFill() 方法一起使用。 spreadMethodpad用于指定要使用哪种 spread 方法的 SpreadMethod 类的值:SpreadMethod.PADSpreadMethod.REFLECTSpreadMethod.REPEATinterpolationMethodStringrgb用于指定要使用哪个值的 InterpolationMethod 类的值:InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB focalPointRatioNumber0.0一个控制渐变的焦点位置的数字。值 0 将焦点设置在中心。值 1 将焦点设置在渐变圆的一条边界上。值 -1 将焦点设置在渐变圆的另一条边界上。小于 -1 或大于 1 的值将分别舍入为 -1 或 1。 创建新的 GraphicsGradientFill 对象。 flash.display.Graphics.beginGradientFill()flash.display.GradientTypeflash.geom.Matrixflash.display.SpreadMethodflash.display.InterpolationMethodalphas colors 数组中的对应颜色的 Alpha 值的数组。Array colors 数组中的对应颜色的 Alpha 值的数组。有效值为 0 到 1。如果值小于 0,则使用 0。如果值大于 1,则使用 1。 colors 渐变中使用的 RGB 十六进制颜色值数组。Array 渐变中使用的 RGB 十六进制颜色值数组。例如,红色为 0xFF0000,蓝色为 0x0000FF 等等。可以至多指定 15 种颜色。对于每种颜色,请在 alphas 和 ratios 属性中指定对应值。 focalPointRatio 一个控制渐变的焦点位置的数字。Number 一个控制渐变的焦点位置的数字。值 0 将焦点设置在中心。值 1 表示焦点位于渐变圆的一条边界上;值 -1 表示焦点位于渐变圆的另一条边界上。小于 -1 或大于 1 的值将分别舍入为 -1 或 1。例如,下例显示了设置为 0.75 的 focalPointRatio

matrix 一个由 Matrix 类定义的转换矩阵。flash.geom:Matrix 一个由 Matrix 类定义的转换矩阵。flash.geom.Matrix 类包括一个 createGradientBox() 方法,可通过该方法设置与 beginGradientFill() 方法一起使用的矩阵。 flash.geom.Matrix.createGradientBox()ratios 颜色分布比例的数组。Array 颜色分布比例的数组。有效值为 0 到 255。该值定义 100% 采样的颜色所在位置的宽度百分比。值 0 表示渐变框中的左侧位置,值 255 表示渐变框中的右侧位置。

注意:此值表示渐变框中的位置,而不是最终渐变的坐标空间。最终渐变可能会比渐变框更宽或更窄。为 colors 属性中的每个值指定一个对应值。

例如,对于包括蓝和绿两种颜色的线性渐变,以下示例显示了渐变中的颜色基于不同 ratios 数组值的配比:

ratios渐变[0, 127][0, 255][127, 255]

数组中的值必须持续增加;例如,[0, 63, 127, 190, 255]

interpolationMethod InterpolationMethod 类中用于指定要使用的值的值。String InterpolationMethod 类中用于指定要使用的值的值。有效值为:InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB

例如,下例显示了两种颜色之间的简单线性渐变(spreadMethod 参数设置为 SpreadMethod.REFLECT)。不同的插值方法会更改外观,如下所示:

InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB
flash.display.InterpolationMethod
spreadMethod SpreadMethod 类中用于指定要使用的扩展方法的值。String SpreadMethod 类中用于指定要使用的扩展方法的值。有效值为:SpreadMethod.PADSpreadMethod.REFLECTSpreadMethod.REPEAT

例如,下例显示了两种颜色之间的简单线性渐变:

import flash.geom.* import flash.display.* var fillType:String = GradientType.LINEAR; var colors:Array = [0xFF0000, 0x0000FF]; var alphas:Array = [1, 1]; var ratios:Array = [0x00, 0xFF]; var matr:Matrix = new Matrix(); matr.createGradientBox(20, 20, 0, 0, 0); var spreadMethod:String = SpreadMethod.PAD; this.graphics.beginGradientFill(fillType, colors, alphas, ratios, matr, spreadMethod); this.graphics.drawRect(0,0,100,100);

此示例将 SpreadMethod.PAD 用于 spread 方法,并且渐变填充看起来将类似于下图:

如果将 SpreadMethod.REFLECT 用于 spread 方法,则渐变填充看起来将类似于下图:

如果将 SpreadMethod.REPEAT 用于 spread 方法,则渐变填充看起来将类似于下图:

flash.display.SpreadMethod
type GradientType 类中用于指定要使用的渐变类型的值。String GradientType 类中用于指定要使用的渐变类型的值。值为 GradientType.LINEARGradientType.RADIALflash.display.GradientType
Sprite Sprite 类是基本显示列表构造块:一个可显示图形并且也可包含子项的显示列表节点。ActionScript 的基本显示对象创建了对象。 flash.display:DisplayObjectContainer Sprite 类是基本显示列表构造块:一个可显示图形并且也可包含子项的显示列表节点。

Sprite 对象与影片剪辑类似,但没有时间轴。Sprite 是不需要时间轴的对象的相应基类。例如,Sprite 将是通常不使用时间轴的用户界面 (UI) 组件的逻辑基类。

Sprite 类是 ActionScript 3.0 中新引入的类。它提供了 MovieClip 类功能的替代功能,此替代功能保留了 ActionScript 以前版本的所有功能以提供向后兼容性。

下例使用 SpriteExample 类在舞台上绘制一个橙色正方形,然后在用户单击或拖动该正方形时调度事件。执行下列步骤可完成该任务:
  1. 声明 size 属性(100 x 100 像素)和背景颜色(橙色)供以后绘制正方形时使用。
  2. 然后,构造函数创建一个新的 child Sprite 对象,并用它来添加两个事件侦听器和与之相关联的方法:mouseDownHandler()mouseUpHandler()
  3. 然后,将 child Sprite 对象传递给 draw() 方法,该方法将绘制橙色正方形。
  4. 然后,将子项放置在显示列表上,方法是调用 addChild() 方法。
  5. 事件侦听器的工作方式如下:
    • mouseDownHandler():当用户单击 Sprite 对象时,此方法将添加一个 mouseMove 事件侦听器,即可以处理鼠标移动的 mouseMoveHandler() 方法。然后调用 startDrag() 方法,此方法允许拖动 Sprite 对象。
    • mouseUpHandler():当释放鼠标按键时,将删除 mouseMove 事件侦听器,并调用 stopDrag() 方法,该方法可使橙色正方形的位置保持不变。
    • mouseMoveHandler:只要按住鼠标左键不放,此方法就会指示播放器不断重绘橙色正方形。

注意:每个事件侦听器方法都声明一个局部 sprite 变量,已为该变量赋予了事件的 target 属性。

package { import flash.display.Sprite; import flash.events.*; public class SpriteExample extends Sprite { private var size:uint = 100; private var bgColor:uint = 0xFFCC00; public function SpriteExample() { var child:Sprite = new Sprite(); child.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler); child.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler); draw(child); addChild(child); } private function mouseDownHandler(event:MouseEvent):void { trace("mouseDownHandler"); var sprite:Sprite = Sprite(event.target); sprite.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler); sprite.startDrag(); } private function mouseUpHandler(event:MouseEvent):void { trace("mouseUpHandler"); var sprite:Sprite = Sprite(event.target); sprite.removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler); sprite.stopDrag(); } private function mouseMoveHandler(event:MouseEvent):void { trace("mouseMoveHandler"); event.updateAfterEvent(); } private function draw(sprite:Sprite):void { sprite.graphics.beginFill(bgColor); sprite.graphics.drawRect(0, 0, size, size); sprite.graphics.endFill(); } } }
Sprite 创建一个新的 Sprite 实例。 创建一个新的 Sprite 实例。创建 Sprite 实例后,调用 DisplayObjectContainer.addChild()DisplayObjectContainer.addChildAt() 方法,以便将 Sprite 添加到父级 DisplayObjectContainer。 startDrag 允许用户拖动指定的 Sprite。lockCenterBooleanfalse指定将可拖动的 sprite 锁定到指针位置中心 (true),还是锁定到用户第一次单击该 sprite 的位置 (false)。 boundsflash.geom:Rectanglenull相对于 Sprite 父级的坐标的值,用于指定 Sprite 约束矩形。 允许用户拖动指定的 Sprite。Sprite 将一直保持可拖动,直到通过调用 Sprite.stopDrag() 方法来明确停止,或直到将另一个 Sprite 变为可拖动为止。在同一时间只有一个 Sprite 是可拖动的。

三维显示对象跟随指针,Sprite.startDrag() 将在由显示对象定义的三维平面中移动对象。或者,如果显示对象为二维对象和三维对象的子对象,则二维对象将在由三维父对象定义的三维平面中移动。

下例创建一个 circle Sprite 和两个 target Sprite。当用户将光标放在 Sprite 上并按下鼠标按键时,将对 circle Sprite 调用 startDrag() 方法;当用户释放鼠标按键时,将调用 stopDrag() 方法。这样,用户就可以拖动 sprite。松开鼠标按键时,将调用 mouseRelease() 方法,此方法又会跟踪 dropTarget 对象(用户将 circle Sprite 拖动到的对象)的 name import flash.display.Sprite; import flash.events.MouseEvent; var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xFFCC00); circle.graphics.drawCircle(0, 0, 40); var target1:Sprite = new Sprite(); target1.graphics.beginFill(0xCCFF00); target1.graphics.drawRect(0, 0, 100, 100); target1.name = "target1"; var target2:Sprite = new Sprite(); target2.graphics.beginFill(0xCCFF00); target2.graphics.drawRect(0, 200, 100, 100); target2.name = "target2"; addChild(target1); addChild(target2); addChild(circle); circle.addEventListener(MouseEvent.MOUSE_DOWN, mouseDown) function mouseDown(event:MouseEvent):void { circle.startDrag(); } circle.addEventListener(MouseEvent.MOUSE_UP, mouseReleased); function mouseReleased(event:MouseEvent):void { circle.stopDrag(); trace(circle.dropTarget.name); }
dropTargetstopDrag()
startTouchDrag 使用户可以在启用触摸的设备上拖动指定的 Sprite。touchPointIDint分配给触摸点的整数。 lockCenterBooleanfalse指定将可拖动的 sprite 锁定到指针位置中心 (true),还是锁定到用户第一次单击该 sprite 的位置 (false)。 boundsflash.geom:Rectanglenull相对于 Sprite 父级的坐标的值,用于指定 Sprite 约束矩形。 使用户可以在启用触摸的设备上拖动指定的 Sprite。Sprite 将一直保持可拖动,直到通过调用 Sprite.stopTouchDrag() 方法来明确停止,或直到将另一个 Sprite 变为可拖动为止。在同一时间只有一个 Sprite 是可拖动的。

三维显示对象跟随指针,Sprite.startTouchDrag() 在由显示对象定义的三维平面中移动对象。或者,如果显示对象为二维对象和三维对象的子对象,则二维对象将在由三维父对象定义的三维平面中移动。

以下示例显示了使用 startTouchDrag 和 stopTouchDrag 处理 touchBegin 和 touchEnd 事件的函数。touchPointID 值是分配给事件对象的值。bounds 参数是定义父显示对象(bg 是包含 MySprite 的显示对象)的边界的矩形。 MySprite.addEventListener(TouchEvent.TOUCH_BEGIN, onTouchBegin); MySprite.addEventListener(TouchEvent.TOUCH_END, onTouchEnd); function onTouchBegin(e:TouchEvent) { e.target.startTouchDrag(e.touchPointID, false, bg.getRect(this)); trace("touch begin"); } function onTouchEnd(e:TouchEvent) { e.target.stopTouchDrag(e.touchPointID); trace("touch end"); }
dropTargetstopTouchDrag()flash.ui.Multitouchflash.events.TouchEvent
stopDrag 结束 startDrag() 方法。 结束 startDrag() 方法。通过 startDrag() 方法变为可拖动的 Sprite 将一直保持可拖动状态,直到添加 stopDrag() 方法或另一个 Sprite 变为可拖动状态为止。在同一时间只有一个 Sprite 是可拖动的。 下例创建一个 circle Sprite 和两个 target Sprite。当用户将光标放在 Sprite 上并按下鼠标按键时,将对 circle Sprite 调用 startDrag() 方法;当用户释放鼠标按键时,将调用 stopDrag() 方法。这样,用户就可以拖动 sprite。松开鼠标按键时,将调用 mouseRelease() 方法,此方法又会跟踪 dropTarget 对象(用户将 circle Sprite 拖动到的对象)的 name import flash.display.Sprite; import flash.events.MouseEvent; var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xFFCC00); circle.graphics.drawCircle(0, 0, 40); var target1:Sprite = new Sprite(); target1.graphics.beginFill(0xCCFF00); target1.graphics.drawRect(0, 0, 100, 100); target1.name = "target1"; var target2:Sprite = new Sprite(); target2.graphics.beginFill(0xCCFF00); target2.graphics.drawRect(0, 200, 100, 100); target2.name = "target2"; addChild(target1); addChild(target2); addChild(circle); circle.addEventListener(MouseEvent.MOUSE_DOWN, mouseDown) function mouseDown(event:MouseEvent):void { circle.startDrag(); } circle.addEventListener(MouseEvent.MOUSE_UP, mouseReleased); function mouseReleased(event:MouseEvent):void { circle.stopDrag(); trace(circle.dropTarget.name); } dropTargetstartDrag()stopTouchDrag 结束 startTouchDrag() 方法,用于启用触摸的设备。touchPointIDint分配给 startTouchDrag 方法中的触摸点的整数。 结束 startTouchDrag() 方法,用于启用触摸的设备。通过 startTouchDrag() 方法变为可拖动的 Sprite 将一直保持可拖动状态,直到添加 stopTouchDrag() 方法或另一个 Sprite 变为可拖动为止。在同一时间只有一个 Sprite 是可拖动的。 以下示例显示了使用 startTouchDrag 和 stopTouchDrag 处理 touchBegin 和 touchEnd 事件的函数。touchPointID 值是分配给事件对象的值。bounds 参数是定义父显示对象(bg 是包含 MySprite 的显示对象)的边界的矩形。 MySprite.addEventListener(TouchEvent.TOUCH_BEGIN, onTouchBegin); MySprite.addEventListener(TouchEvent.TOUCH_END, onTouchEnd); function onTouchBegin(e:TouchEvent) { e.target.startTouchDrag(e.touchPointID, false, bg.getRect(this)); trace("touch begin"); } function onTouchEnd(e:TouchEvent) { e.target.stopTouchDrag(e.touchPointID); trace("touch end"); } dropTargetstartTouchDrag()flash.ui.Multitouchflash.events.TouchEventbuttonMode 指定此 sprite 的按钮模式。Boolean指定此 sprite 的按钮模式。 指定此 sprite 的按钮模式。如果为 true,此 sprite 的行为方式就像按钮,这表示它可在指针经过 sprite 时触发显示手形光标,并可在 sprite 具有焦点时按下 Enter 键或空格键来接收 click 事件。通过将 useHandCursor 属性设置为 false 可以禁止显示手形光标,在此情况下将显示指针。

虽然使用 SimpleButton 类创建按钮是一种比较好的方法,但是可以使用 buttonMode 属性为 Sprite 提供某种类似按钮的功能。要在 Tab 键顺序中包括 Sprite,请将 tabEnabled 属性(继承自 InteractiveObject 类,默认情况下为 false)设置为 true。此外,考虑是否希望 sprite 的子级支持用户输入。大多数按钮不启用其子对象的用户输入交互性,因为这样会混淆事件流。要对所有子对象禁用用户输入交互性,则必须将 mouseChildren 属性(继承自 DisplayObjectContainer 类)设置为 false

如果将 buttonMode 属性与 MovieClip 类(该类是 Sprite 类的子类)一起使用,则按钮可能会具有一些增加的功能。如果包括具有 _up、_over 和 _down 标签的帧,则 Flash Player 将提供自动状态更改功能(类似于 ActionScript 的以前版本中为用作按钮的影片剪辑提供的功能)。没有时间轴的 Sprite 不可以使用这些自动状态更改,因此没有要加标签的帧。

下例创建两个 Sprite 并将其中一个的 buttonMode 属性设置为 true,将另一个的此属性设置为 false。当您编译和运行应用程序时,这两个 Sprite 都响应鼠标事件,但只有将 buttonMode 设置为 true 的那个 Sprite 才使用手形光标并包括在 Tab 键顺序中: import flash.display.Sprite; import flash.events.MouseEvent; var circle1:Sprite = new Sprite(); circle1.graphics.beginFill(0xFFCC00); circle1.graphics.drawCircle(40, 40, 40); circle1.buttonMode = true; circle1.addEventListener(MouseEvent.CLICK, clicked); var circle2:Sprite = new Sprite(); circle2.graphics.beginFill(0xFFCC00); circle2.graphics.drawCircle(120, 40, 40); circle2.buttonMode = false; circle2.addEventListener(MouseEvent.CLICK, clicked); function clicked(event:MouseEvent):void { trace ("Click!"); } addChild(circle1); addChild(circle2);
SimpleButtonSprite.useHandCursorInteractiveObject.tabEnabledDisplayObjectContainer.mouseChildren
dropTarget 指定拖动 sprite 时经过的显示对象,或放置 sprite 的显示对象。flash.display:DisplayObject指定要在其上拖动或放置 Sprite 的 DisplayObject。 指定拖动 sprite 时经过的显示对象,或放置 sprite 的显示对象。 下例创建一个 circle Sprite 和两个 target Sprite。当用户将光标放在 Sprite 上并按下鼠标按键时,将对 circle Sprite 调用 startDrag() 方法;当用户释放鼠标按键时,将调用 stopDrag() 方法。这样,用户就可以拖动 sprite。松开鼠标按键时,将调用 mouseRelease() 方法,此方法又会跟踪 dropTarget 对象(用户将 circle Sprite 拖动到的对象)的 name import flash.display.Sprite; import flash.events.MouseEvent; var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xFFCC00); circle.graphics.drawCircle(0, 0, 40); var target1:Sprite = new Sprite(); target1.graphics.beginFill(0xCCFF00); target1.graphics.drawRect(0, 0, 100, 100); target1.name = "target1"; var target2:Sprite = new Sprite(); target2.graphics.beginFill(0xCCFF00); target2.graphics.drawRect(0, 200, 100, 100); target2.name = "target2"; addChild(target1); addChild(target2); addChild(circle); circle.addEventListener(MouseEvent.MOUSE_DOWN, mouseDown) function mouseDown(event:MouseEvent):void { circle.startDrag(); } circle.addEventListener(MouseEvent.MOUSE_UP, mouseReleased); function mouseReleased(event:MouseEvent):void { circle.stopDrag(); trace(circle.dropTarget.name); } startDrag()stopDrag()graphics 指定属于此 sprite 的 Graphics 对象,在此 sprite 中可执行矢量绘图命令。flash.display:Graphics指定 Graphics 对象。 指定属于此 sprite 的 Graphics 对象,在此 sprite 中可执行矢量绘图命令。 下例创建一个 circle Sprite,并使用其 graphics 属性以黄色 (0xFFCC00) 填充色绘制一个圆形: import flash.display.Sprite; var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xFFCC00); circle.graphics.drawCircle(40, 40, 40); addChild(circle); hitArea 指定一个 sprite 用作另一个 sprite 的点击区域。flash.display:Sprite 指定一个 sprite 用作另一个 sprite 的点击区域。如果 hitArea 属性不存在或者其值为 nullundefined,则 Sprite 本身将用作点击区域。hitArea 属性的值可以是对 Sprite 对象的引用。

可以随时更改 hitArea 属性;修改后的 Sprite 会立即使用新的点击区域行为。指定为点击区域的 Sprite 不必是可见的;虽然不可见,但其图形形状仍会作为点击区域被检测。

注意:必须将指定为点击区域的 Sprite 的 mouseEnabled 属性设置为 false。否则,sprite 按钮可能会不起作用,因为被指定为点击区域的 sprite 会接收用户输入事件而不是您的 sprite 按钮。

下例创建一个 circle Sprite 和一个 square Sprite。square Sprite 是 circle Sprite 的 hitArea。因此,当用户单击 square Sprite 时,circle Sprite 将调度 click 事件: import flash.display.Sprite; import flash.events.MouseEvent; var circle:Sprite = new Sprite(); circle.graphics.beginFill(0xFFCC00); circle.graphics.drawCircle(0, 0, 40); var square:Sprite = new Sprite(); square.graphics.beginFill(0xCCFF00); square.graphics.drawRect(200, 0, 100, 100); circle.hitArea = square; square.mouseEnabled = false; circle.addEventListener(MouseEvent.CLICK, clicked); function clicked(event:MouseEvent):void{ trace(event.target == circle); // true trace(event.target == square); // false } addChild(circle); addChild(square);
soundTransform 控制此 sprite 中的声音。flash.media:SoundTransform 控制此 sprite 中的声音。

注意:此属性不影响 HTMLControl 对象(位于 Adobe AIR 中)中的 HTML 内容。

下例创建一个名为 container 的 Sprite,并将 Loader 对象添加到其子级列表。Loader 对象将加载 SWF 文件。当用户单击 tf 文本字段中的链接时,mute() 方法将 container Sprite soundTransform 属性的 volume 属性设置为 true import flash.display.Sprite; import flash.display.Loader; import flash.events.IOErrorEvent; import flash.events.MouseEvent; import flash.net.URLRequest; import flash.text.TextField; import flash.media.SoundTransform; var container:Sprite = new Sprite(); addChild(container); var ldr:Loader = new Loader; var urlReq:URLRequest = new URLRequest("SoundPlayer.swf"); ldr.load(urlReq); container.addChild(ldr); ldr.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, urlNotFound); var tf:TextField = new TextField(); tf.htmlText = "<a href = 'event:Mute'>Mute / Unmute</a>"; addChild(tf); var mySoundTransform:SoundTransform = new SoundTransform(); mySoundTransform.volume = 1; tf.addEventListener(MouseEvent.CLICK, mute); function mute(event:MouseEvent):void { if (mySoundTransform.volume == 0) { mySoundTransform.volume = 1; } else { mySoundTransform.volume = 0; } container.soundTransform = mySoundTransform; } function urlNotFound(event:IOErrorEvent):void { trace("The URL was not found."); }
flash.media.SoundTransform
useHandCursor 布尔值,表示当指针滑过 buttonMode 属性设置为 true 的 sprite 时是否显示指针手形(手形光标)。Boolean布尔值,表示当指针滑过 buttonMode 属性设置为 true 的 sprite 时是否显示指针手形(手形光标)。 布尔值,表示当指针滑过 buttonMode 属性设置为 true 的 sprite 时是否显示指针手形(手形光标)。useHandCursor 属性的默认值是 true。如果 useHandCursor 设置为 true,则当指针滑过按钮 sprite 时将显示用于按钮的指针手形。如果 useHandCursorfalse,则将改用箭头指针。

可以随时更改 useHandCursor 属性;修改后的 Sprite 会立即具有新的光标外观。

注意:在 Flex 或 Flash Builder 中,如果您的 Sprite 拥有子 Sprite,您可能要将 mouseChildren 属性设置为 false。例如,如果您希望在 Flex <mx:Label> 控件上出现手形光标,请将 useHandCursorbuttonMode 属性设置为 true,并将 mouseChildren 属性设置为 false

下例创建两个 Sprite 并将二者的 buttonMode 属性设置为 true,但将其中一个的 useHandCursor 属性设置为 true,将另一个的此属性设置为 false。当您编译和运行应用程序时,这两个 Sprite 都作为按钮进行响应(并且都包括在 Tab 键顺序中),但只有将 useHandCursor 设置为 true 的那个 Sprite 才使用手形光标: import flash.display.Sprite; import flash.events.MouseEvent; var circle1:Sprite = new Sprite(); circle1.graphics.beginFill(0xFFCC00); circle1.graphics.drawCircle(40, 40, 40); circle1.buttonMode = true; circle1.useHandCursor = true; circle1.addEventListener(MouseEvent.CLICK, clicked); var circle2:Sprite = new Sprite(); circle2.graphics.beginFill(0xFFCC00); circle2.graphics.drawCircle(120, 40, 40); circle2.buttonMode = true; circle2.useHandCursor = false; circle2.addEventListener(MouseEvent.CLICK, clicked); function clicked(event:MouseEvent):void { trace ("Click!"); } addChild(circle1); addChild(circle2);
buttonModeDisplayObjectContainer.mouseChildren
GraphicsBitmapFill 定义位图填充。flash.display:IGraphicsFillflash.display:IGraphicsDataObject 定义位图填充。可对位图进行平滑处理、重复位图或平铺位图以填充区域,或使用转换矩阵处理位图。

将 GraphicsBitmapFill 对象与 Graphics.drawGraphicsData() 方法一起使用。绘制 GraphicsBitmapFill 对象与调用 Graphics.beginBitmapFill() 方法是等效的。

flash.display.Graphics.drawGraphicsData()flash.display.Graphics.beginBitmapFill()GraphicsBitmapFill 创建新的 GraphicsBitmapFill 对象。bitmapDataflash.display:BitmapDatanull包含要显示的位数的透明或不透明位图图像。 matrixflash.geom:Matrixnull一个 Matrix 对象(属于 flash.geom.Matrix 类),您可以使用它在位图上定义转换。 repeatBooleantrue如果为 true,则位图图像按平铺模式重复。如果为 false,位图图像不会重复,并且位图边缘将用于所有扩展出位图的填充区域。 smoothBooleanfalse如果为 false,则使用最近邻点算法来呈现放大的位图图像(带有像素化效果)。如果为 true,则使用双线性算法来呈现放大的位图图像。使用最近邻点算法呈现通常较快。 创建新的 GraphicsBitmapFill 对象。 flash.display.Graphics.beginBitmapFill()bitmapData 透明的或不透明的位图图像。flash.display:BitmapData 透明的或不透明的位图图像。 flash.display.BitmapDatamatrix 一个用于定义位图上的转换的 Matrix 对象(属于 flash.geom.Matrix 类)。flash.geom:Matrix 一个用于定义位图上的转换的 Matrix 对象(属于 flash.geom.Matrix 类)。例如,以下矩阵可将位图旋转 45 度(pi/4 弧度): matrix = new flash.geom.Matrix(); matrix.rotate(Math.PI / 4); flash.geom.Matrixrepeat 指定是否以平铺模式重复位图图像。Boolean 指定是否以平铺模式重复位图图像。

如果为 true,则位图图像按平铺模式重复。如果为 false,则位图图像不会重复,并且位图边缘最外部的像素将用于所有延伸出位图边界的填充区域。

例如,请考虑下列位图(20 x 20 像素的棋盘图案):

repeat 设置为 true 时(如下例所示),位图填充将重复位图:

repeat 设置为 false 时,位图填充将对位图外部的填充区域使用边缘像素:

smooth 指定是否将平滑处理算法应用于位图图像。Boolean 指定是否将平滑处理算法应用于位图图像。

如果为 false,则使用最近邻点算法来呈现放大的位图图像,而且该图像看起来是像素化的。如果为 true,则使用双线性算法来呈示放大的位图图像。使用最近邻点算法呈现通常较快。

GraphicsStroke 定义线条样式或笔触。flash.display:IGraphicsStrokeflash.display:IGraphicsDataObject 定义线条样式或笔触。

将 GraphicsStroke 对象与 Graphics.drawGraphicsData() 方法一起使用。绘制 GraphicsStroke 对象与调用设置线条样式的 Graphics 类的方法之一(例如 Graphics.lineStyle() 方法、Graphics.lineBitmapStyle() 方法或 Graphics.lineGradientStyle() 方法)是等效的。

flash.display.Graphics.lineStyle()flash.display.Graphics.lineBitmapStyle()flash.display.Graphics.lineGradientStyle()flash.display.Graphics.drawGraphicsData()GraphicsStroke 创建新的 GraphicsStroke 对象。thicknessNumberunknown一个整数,以点为单位表示线条的粗细;有效值为 0 到 255。如果未指定数字,或者未定义该参数,则不绘制线条。如果传递的值小于 0,则默认值为 0。值 0 表示极细的粗细;最大粗细为 255。如果传递的值大于 255,则默认值为 255。 pixelHintingBooleanfalse用于指定是否提示笔触采用完整像素的布尔值。它同时影响曲线锚点的位置以及线条笔触大小本身。在 pixelHinting 设置为 true 的情况下,Flash Player 将提示线条宽度采用完整像素宽度。在 pixelHinting 设置为 false 的情况下,对于曲线和直线可能会出现脱节。例如,下图显示了 Flash Player 如何呈现两个相同的圆角矩形,不同之处是用于 lineStyle() 方法的 pixelHinting 参数设置不同(将图像放大 200% 以强调差异):

如果未提供值,则线条不使用像素提示。

scaleModeStringnormal用于指定要使用哪种缩放模式的 LineScaleMode 类的值:
  • LineScaleMode.NORMAL -- 在缩放对象时总是缩放线条的粗细(默认值)。
  • LineScaleMode.NONE -- 从不缩放线条粗细。
  • LineScaleMode.VERTICAL -- 如果 垂直缩放对象,则不缩放线条粗细。例如,考虑下面的圆形,它们是用一个像素的线条绘制的,每个圆的 scaleMode 参数都被设置为 LineScaleMode.VERTICAL。左边的圆仅在垂直方向上缩放,而右边的圆则同时在垂直和水平方向上缩放:

  • LineScaleMode.HORIZONTAL -- 如果 水平缩放对象,则不缩放线条粗细。例如,考虑下面的圆形,它们是用一个像素的线条绘制的,每个圆的 scaleMode 参数都被设置为 LineScaleMode.HORIZONTAL。左边的圆仅在水平方向上缩放,而右边的圆则同时在垂直和水平方向上缩放:

capsStringnone用于指定线条末端处端点类型的 CapsStyle 类的值。有效值为:CapsStyle.NONECapsStyle.ROUNDCapsStyle.SQUARE。如果未表示值,则 Flash 使用圆头端点。

例如,以下图示显示了不同的 capsStyle 设置。对于每种设置,插图显示了一条粗细为 30 的蓝色线条(应用 capsStyle 的线条),以及重叠于其上的粗细为 1 的黑色线条(未应用 capsStyle 的线条):

jointsStringroundJointStyle 类的值,指定用于拐角的连接外观的类型。有效值为:JointStyle.BEVELJointStyle.MITERJointStyle.ROUND。如果未表示值,则 Flash 使用圆角连接。

例如,以下图示显示了不同的 joints 设置。对于每种设置,插图显示了一条粗细为 30 的带拐角的蓝色线条(应用 jointStyle 的线条),以及重叠于其上的粗细为 1 的带拐角的黑色线条(未应用 jointStyle 的线条):

注意:对于设置为 JointStyle.MITERjoints,您可以使用 miterLimit 参数限制尖角的长度。

miterLimitNumber3.0一个表示将在哪个限制位置切断尖角的数字。有效值的范围是 1 到 255(超出该范围的值将舍入为 1 或 255)。此值只可用于 jointStyle 设置为 "miter" 的情况下。miterLimit 值表示向外延伸的尖角可以超出角边相交所形成的结合点的长度。此值表示为线条 thickness 的因子。例如,miterLimit 因子为 2.5 且 thickness 为 10 像素时,尖角将在 25 像素处切断。

例如,请考虑下列带拐角的线条,每个线条都以 thickness 20 进行绘制,但它们的 miterLimit 分别设置为 1、2 和 4。重叠在其上的黑色参考线条显示了结合处的联结点:

请注意,对于给定的 miterLimit 值,会有一个被切断的尖角的特定最大角度。下表列出了部分示例:

miterLimit 值:小于此角度将被切断:1.41490 度260 度430 度815 度
fillflash.display:IGraphicsFillnull一个包含用于填充笔触的数据的 IGraphicsFill 实例。IGraphicsFill 实例可表示一系列填充命令。
创建新的 GraphicsStroke 对象。
flash.display.LineScaleModeflash.display.CapsStyleflash.display.JointStyleflash.display.IGraphicsFill
fill 指定包含用于填充笔触的数据的实例。flash.display:IGraphicsFill 指定包含用于填充笔触的数据的实例。IGraphicsFill 实例可表示一系列填充命令。 flash.display.IGraphicsFillmiterLimit 表示将在哪个限制位置切断尖角。Number 表示将在哪个限制位置切断尖角。有效值的范围是 1 到 255(超出该范围的值将舍入为 1 或 255)。此值只可用于 jointStyle 设置为 "miter" 的情况下。miterLimit 值表示向外延伸的尖角可以超出角边相交所形成的结合点的长度。此值表示为线条 thickness 的因子。例如,miterLimit 因子为 2.5 且 thickness 为 10 像素时,尖角将在 25 像素处切断。

例如,请考虑下列带拐角的线条,每个线条都以 thickness 20 进行绘制,但它们的 miterLimit 分别设置为 1、2 和 4。重叠在其上的黑色参考线条显示了结合处的联结点:

请注意,对于给定的 miterLimit 值,会有一个被切断的尖角的特定最大角度。下表列出了部分示例:

miterLimit 值:小于此角度将被切断:1.41490 度260 度430 度815 度
pixelHinting 指定是否提示笔触采用完整像素。Boolean 指定是否提示笔触采用完整像素。它同时影响曲线锚点的位置以及线条笔触大小本身。在 pixelHinting 设置为 true 的情况下,Flash Player 将提示线条宽度采用完整像素宽度。在 pixelHinting 设置为 false 的情况下,对于曲线和直线可能会出现脱节。例如,下图显示了 Flash Player 如何呈现两个相同的圆角矩形,不同之处是用于 lineStyle() 方法的 pixelHinting 参数设置不同(将图像放大 200% 以强调差异):

thickness 表示以点为单位的线条粗细;有效值为 0 到 255。Number 表示以点为单位的线条粗细;有效值为 0 到 255。如果未指定数字,或者未定义该参数,则不绘制线条。如果传递的值小于 0,则默认值为 0。值 0 表示极细的粗细;最大粗细为 255。如果传递的值大于 255,则默认值为 255。 caps 指定线条结尾处的端点的类型。String 指定线条结尾处的端点的类型。有效值为:CapsStyle.NONECapsStyle.ROUNDCapsStyle.SQUARE。如果未表示值,则 Flash 使用圆头端点。

例如,以下图示显示了不同的 capsStyle 设置。对于每种设置,插图显示了一条粗细为 30 的蓝色线条(应用 capsStyle 的线条),以及重叠于其上的粗细为 1 的黑色线条(未应用 capsStyle 的线条):

flash.display.CapsStyle
joints 指定拐角处使用的连接外观的类型。String 指定拐角处使用的连接外观的类型。有效值为:JointStyle.BEVELJointStyle.MITERJointStyle.ROUND。如果未表示值,则 Flash 使用圆角连接。

例如,以下图示显示了不同的 joints 设置。对于每种设置,插图显示了一条粗细为 30 的带拐角的蓝色线条(应用 jointStyle 的线条),以及重叠于其上的粗细为 1 的带拐角的黑色线条(未应用 jointStyle 的线条):

注意:对于设置为 JointStyle.MITERjoints,您可以使用 miterLimit 参数限制尖角的长度。

flash.display.JointStyle
scaleMode 指定笔触粗细缩放。String 指定笔触粗细缩放。有效值为:
  • LineScaleMode.NORMAL -- 在缩放对象时总是缩放线条的粗细(默认值)。
  • LineScaleMode.NONE -- 从不缩放线条粗细。
  • LineScaleMode.VERTICAL -- 如果 垂直缩放对象,则不缩放线条粗细。例如,考虑下面的圆形,它们是用一个像素的线条绘制的,每个圆的 scaleMode 参数都被设置为 LineScaleMode.VERTICAL。左边的圆仅在垂直方向上缩放,而右边的圆则同时在垂直和水平方向上缩放:

  • LineScaleMode.HORIZONTAL -- 如果 水平缩放对象,则不缩放线条粗细。例如,考虑下面的圆形,它们是用一个像素的线条绘制的,每个圆的 scaleMode 参数都被设置为 LineScaleMode.HORIZONTAL。左边的圆仅在水平方向上缩放,而右边的圆则同时在垂直和水平方向上缩放:

flash.display.LineScaleMode
GraphicsEndFill 表示图形填充的结束。flash.display:IGraphicsFillflash.display:IGraphicsDataObject 表示图形填充的结束。将 GraphicsEndFill 对象与 Graphics.drawGraphicsData() 方法一起使用。

绘制 GraphicsEndFill 对象与调用 Graphics.endFill() 方法是等效的。

flash.display.Graphics.drawGraphicsData()flash.display.Graphics.endFill()GraphicsEndFill 创建与 Graphics.drawGraphicsData() 方法一起使用的对象,以显式结束填充。 创建与 Graphics.drawGraphicsData() 方法一起使用的对象,以显式结束填充。 flash.display.Graphics.drawGraphicsData()flash.display.Graphics.endFill()
ShaderPrecision 该类定义一些常量,它们表示 Shader 类的 precisionHint 属性的可能值。Object 该类定义一些常量,它们表示 Shader 类的 precisionHint 属性的可能值。每个常量都表示用于执行着色器操作的精度模式之一。

精度模式选择将影响以下着色器操作。在包含 SSE 指令集的 Intel 处理器上,这些操作的执行速度较快:

  • sin(x)
  • cos(x)
  • tan(x)
  • asin(x)
  • acos(x)
  • atan(x)
  • atan(x, y)
  • exp(x)
  • exp2(x)
  • log(x)
  • log2(x)
  • pow(x, y)
  • reciprocal(x)
  • sqrt(x)
flash.display.Shader.precisionHintFAST 表示 fast 精度模式。fastString 表示 fast 精度模式。

fast 精度模式旨在获得最高性能,但在不同平台上和各种 CPU 配置下工作不一致。多数情况下,这种精度级别足以创建无可见失真的图形效果。

通常,使用 fast 精度模式比使用查找表更快。

flash.display.Shader.precisionHint
FULL 表示 full 精度模式。fullString 表示 full 精度模式。

在 full 精度模式下,着色器将按照 IEEE 32 位浮点标准的全宽计算所有数学运算。此模式可在所有平台上提供一致的行为。在此模式下,某些数学运算(比如三角函数和指数函数)可能速度较慢。

flash.display.Shader.precisionHint
BlendMode 提供混合模式可视效果的常量值的类。Object 提供混合模式可视效果的常量值的类。这些常量在以下项目中使用:
  • flash.display.DisplayObject 类的 blendMode 属性。
  • flash.display.BitmapData 类的 draw() 方法的 blendMode 参数
flash.display.DisplayObject.blendModeflash.display.BitmapData.draw()ADD 将显示对象的原色值添加到它的背景颜色中,上限值为 0xFF。addString 将显示对象的原色值添加到它的背景颜色中,上限值为 0xFF。此设置通常用于使两个对象间的加亮溶解产生动画效果。

例如,如果显示对象的某个像素的 RGB 值为 0xAAA633,背景像素的 RGB 值为 0xDD2200,则显示像素的结果 RGB 值为 0xFFC833(因为 0xAA + 0xDD > 0xFF,0xA6 + 0x22 = 0xC8,且 0x33 + 0x00 = 0x33)。

ALPHA 将显示对象的每个像素的 Alpha 值应用于背景。alphaString 将显示对象的每个像素的 Alpha 值应用于背景。这要求将父显示对象的 blendMode 属性设置为 flash.display.BlendMode.LAYER

在 GPU 呈现下不支持。

DARKEN 在显示对象原色和背景颜色中选择相对较暗的颜色(具有较小值的颜色)。darkenString 在显示对象原色和背景颜色中选择相对较暗的颜色(具有较小值的颜色)。此设置通常用于叠加类型。

例如,如果显示对象的某个像素的 RGB 值为 0xFFCC33,背景像素的 RGB 值为 0xDDF800,则显示像素的结果 RGB 值为 0xDDCC00(因为 0xFF > 0xDD,0xCC < 0xF8,且 0x33 > 0x00 = 33)。

在 GPU 呈现下不支持。

DIFFERENCE 将显示对象的原色与背景颜色进行比较,然后从较亮的原色值中减去较暗的原色值。differenceString 将显示对象的原色与背景颜色进行比较,然后从较亮的原色值中减去较暗的原色值。此设置通常用于得到更明亮的颜色。

例如,如果显示对象的某个像素的 RGB 值为 0xFFCC33,背景像素的 RGB 值为 0xDDF800,则显示像素的结果 RGB 值为 0x222C33(因为 0xFF - 0xDD = 0x22,0xF8 - 0xCC = 0x2C,且 0x33 - 0x00 = 0x33)。

ERASE 根据显示对象的 Alpha 值擦除背景。eraseString 根据显示对象的 Alpha 值擦除背景。此过程要求将父显示对象的 blendMode 属性设置为 flash.display.BlendMode.LAYER

在 GPU 呈现下不支持。

HARDLIGHT 根据显示对象的暗度调整每个像素的颜色。hardlightString 根据显示对象的暗度调整每个像素的颜色。如果显示对象灰度值高于 50%,则显示对象和背景颜色进行叠加,从而产生较亮的颜色。如果显示对象灰度值低于 50%,则颜色相乘,从而产生较暗的颜色。此设置通常用于获得阴影效果。

在 GPU 呈现下不支持。

INVERT 反转背景。invertString 反转背景。 LAYER 强制为该显示对象创建一个透明度组。layerString 强制为该显示对象创建一个透明度组。这意味着在对显示对象进行进一步处理之前,该对象已在临时缓冲区中预先构成。在以下情况下将会自动完成预先构成操作:显示对象通过位图缓存进行预缓存,或者显示对象是一个显示对象容器,该容器至少具有一个带有 blendMode 设置(而不是 "normal")的子对象。

在 GPU 呈现下不支持。

LIGHTEN 在显示对象原色和背景颜色中选择相对较亮的颜色(具有较大值的颜色)。lightenString 在显示对象原色和背景颜色中选择相对较亮的颜色(具有较大值的颜色)。此设置通常用于叠加类型。

例如,如果显示对象的某个像素的 RGB 值为 0xFFCC33,背景像素的 RGB 值为 0xDDF800,则显示像素的结果 RGB 值为 0xFFF833(因为 0xFF > 0xDD,0xCC < 0xF8,且 0x33 > 0x00 = 33)。

在 GPU 呈现下不支持。

MULTIPLY 将显示对象的原色值与背景颜色的原色值相乘,然后除以 0xFF 进行标准化,从而得到较暗的颜色。multiplyString 将显示对象的原色值与背景颜色的原色值相乘,然后除以 0xFF 进行标准化,从而得到较暗的颜色。此设置通常用于阴影和深度效果。

例如,如果显示对象中一个像素的某个原色(例如红色)与背景中对应的像素颜色的值均为 0x88,则相乘结果为 0x4840。除以 0xFF 将得到该原色的值 0x48,这是比显示对象或背景颜色暗的阴影。

NORMAL 该显示对象出现在背景前面。normalString 该显示对象出现在背景前面。显示对象的像素值会覆盖背景的像素值。在显示对象为透明的区域,背景是可见的。 OVERLAY 根据背景的暗度调整每个像素的颜色。overlayString 根据背景的暗度调整每个像素的颜色。如果背景灰度值高于 50%,则显示对象和背景颜色进行叠加,从而产生较亮的颜色。如果背景灰度值低于 50%,则颜色相乘,从而产生较暗的颜色。此设置通常用于获得阴影效果。

在 GPU 呈现下不支持。

SCREEN 将显示对象颜色的补色(反色)与背景颜色的补色相乘,会产生漂白效果。screenString 将显示对象颜色的补色(反色)与背景颜色的补色相乘,会产生漂白效果。此设置通常用于产生加亮效果或用来删除显示对象的黑色区域。 SHADER 使用着色器来定义对象之间的混合。shaderString 使用着色器来定义对象之间的混合。

blendShader 属性设置为 Shader 实例时,会自动将显示对象的 blendMode 属性设置为 BlendMode.SHADER。如果在未首先设置 blendShader 属性的情况下将 blendMode 属性设置为 BlendMode.SHADER,则会改为将 blendMode 属性设置为 BlendMode.NORMAL。如果设置了 blendShader 属性(这会将 blendMode 属性设置为 BlendMode.SHADER),则随后 blendMode 属性的值发生更改,只需将 blendMode 属性设置为 BlendMode.SHADER 即可将混合模式重置为使用混合着色器。除非要更改用于定义混合模式的着色器,否则无需再次设置 blendShader 属性。

在 GPU 呈现下不支持。

flash.display.DisplayObject.blendModeflash.display.DisplayObject.blendShaderflash.display.Shader
SUBTRACT 从背景颜色的值中减去显示对象原色的值,下限值为 0。subtractString 从背景颜色的值中减去显示对象原色的值,下限值为 0。此设置通常用于使两个对象间的变暗溶解产生动画效果。

例如,如果显示对象的某个像素的 RGB 值为 0xAA2233,背景像素的 RGB 值为 0xDDA600,则显示像素的结果 RGB 值为 0x338400(因为 0xDD - 0xAA = 0x33,0xA6 - 0x22 = 0x84 且 0x00 - 0x33 < 0x00)。

Graphics Graphics 类包含一组可用来创建矢量形状的方法。Object Graphics 类包含一组可用来创建矢量形状的方法。支持绘制的显示对象包括 Sprite 和 Shape 对象。这些类中的每一个类都包括 graphics 属性,该属性是一个 Graphics 对象。以下是为便于使用而提供的一些辅助函数:drawRect()drawRoundRect()drawCircle()drawEllipse()

无法通过 ActionScript 代码直接创建 Graphics 对象。如果调用 new Graphics(),则会引发异常。

Graphics 类是最终类;无法从其派生子类。

下例使用 GraphicsExample 类绘制圆形、圆角矩形和正方形。执行下列步骤可完成该任务:
  1. 声明 size 属性以备日后在确定每个形状的大小时使用。
  2. 声明以下属性:将背景色设置为橙色、将边框颜色设置为深灰色、将边框大小设置为 0 个像素、将角半径设置为 9 个像素并将舞台边缘与其他对象之间的间距设置为 5 个像素。
  3. 使用在前面步骤中声明的属性以及使用 Graphics 类的内置方法,可在坐标 x = 0, y = 0 处绘制圆形、圆角矩形和正方形。
  4. 沿舞台顶部重新绘制每个形状,起点为 x = 5,y = 5,各形状之间的间隔为 5 个像素。
package { import flash.display.DisplayObject; import flash.display.Graphics; import flash.display.Shape; import flash.display.Sprite; public class GraphicsExample extends Sprite { private var size:uint = 80; private var bgColor:uint = 0xFFCC00; private var borderColor:uint = 0x666666; private var borderSize:uint = 0; private var cornerRadius:uint = 9; private var gutter:uint = 5; public function GraphicsExample() { doDrawCircle(); doDrawRoundRect(); doDrawRect(); refreshLayout(); } private function refreshLayout():void { var ln:uint = numChildren; var child:DisplayObject; var lastChild:DisplayObject = getChildAt(0); lastChild.x = gutter; lastChild.y = gutter; for (var i:uint = 1; i < ln; i++) { child = getChildAt(i); child.x = gutter + lastChild.x + lastChild.width; child.y = gutter; lastChild = child; } } private function doDrawCircle():void { var child:Shape = new Shape(); var halfSize:uint = Math.round(size / 2); child.graphics.beginFill(bgColor); child.graphics.lineStyle(borderSize, borderColor); child.graphics.drawCircle(halfSize, halfSize, halfSize); child.graphics.endFill(); addChild(child); } private function doDrawRoundRect():void { var child:Shape = new Shape(); child.graphics.beginFill(bgColor); child.graphics.lineStyle(borderSize, borderColor); child.graphics.drawRoundRect(0, 0, size, size, cornerRadius); child.graphics.endFill(); addChild(child); } private function doDrawRect():void { var child:Shape = new Shape(); child.graphics.beginFill(bgColor); child.graphics.lineStyle(borderSize, borderColor); child.graphics.drawRect(0, 0, size, size); child.graphics.endFill(); addChild(child); } } }
beginBitmapFill 用位图图像填充绘图区。bitmapflash.display:BitmapData包含要显示的位的透明或不透明位图图像。 matrixflash.geom:Matrixnull一个 matrix 对象(属于 flash.geom.Matrix 类),您可以使用它在位图上定义转换。例如,可以使用以下矩阵将位图旋转 45 度(pi/4 弧度): matrix = new flash.geom.Matrix(); matrix.rotate(Math.PI / 4); repeatBooleantrue如果为 true,则位图图像按平铺模式重复。如果为 false,位图图像不会重复,并且位图边缘将用于所有扩展出位图的填充区域。

例如,请考虑下列位图(20 x 20 像素的棋盘图案):

repeat 设置为 true 时(如下例所示),位图填充将重复位图:

repeat 设置为 false 时,位图填充将对位图外部的填充区域使用边缘像素:

smoothBooleanfalse如果为 false,则使用最近邻点算法来呈现放大的位图图像,而且该图像看起来是像素化的。如果为 true,则使用双线性算法来呈示放大的位图图像。使用最近邻点算法呈现较快。 开始绘制位图填充的形状。
用位图图像填充绘图区。可以重复或平铺位图以填充该区域。该填充将保持有效,直到您调用 beginFill()beginBitmapFill()beginGradientFill()beginShaderFill() 方法。调用 clear() 方法会清除填充。

只要绘制 3 个或更多个点,或者调用 endFill() 方法时,应用程序就会呈现填充。

下面的示例使用一个图像 (image1.jpg),它不断旋转并反复填充一个矩形。
  1. 使用 LoaderURLRequest 对象加载此图像文件 (image1.jpg)。此处,该文件位于与 SWF 文件相同的目录中。需要编译 SWF 文件,并将“本地播放安全性”设置为“只访问本地文件”。
  2. 在加载图像后(Event 为 complete),将调用 drawImage() 方法。如果未正确加载图像,ioErrorHandler() 方法将写入跟踪注释。
  3. drawImage() 方法中,将实例化 BitmapData 对象,并将其宽度和高度设置为图像 (image1.jpg) 的宽度和高度。然后,将源图像绘制到 BitmapData 对象中。接下来,在 mySprite Sprite 对象中绘制一个矩形,并使用 BitmapData 对象对其进行填充。通过使用 Matrix 对象,beginBitmapFill() 方法将图像旋转 45 度,然后开始使用图像填充矩形,直至完成时为止。
package { import flash.display.Sprite; import flash.display.BitmapData; import flash.display.Loader; import flash.net.URLRequest; import flash.events.Event; import flash.events.IOErrorEvent; import flash.geom.Matrix; public class Graphics_beginBitmapFillExample extends Sprite { private var url:String = "image1.jpg"; private var loader:Loader = new Loader(); public function Graphics_beginBitmapFillExample() { var request:URLRequest = new URLRequest(url); loader.load(request); loader.contentLoaderInfo.addEventListener(Event.COMPLETE, drawImage); loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); } private function drawImage(event:Event):void { var mySprite:Sprite = new Sprite(); var myBitmap:BitmapData = new BitmapData(loader.width, loader.height, false); myBitmap.draw(loader, new Matrix()); var matrix:Matrix = new Matrix(); matrix.rotate(Math.PI/4); mySprite.graphics.beginBitmapFill(myBitmap, matrix, true); mySprite.graphics.drawRect(100, 50, 200, 90); mySprite.graphics.endFill(); addChild(mySprite); } private function ioErrorHandler(event:IOErrorEvent):void { trace("Unable to load image: " + url); } } }
endFill()beginFill()beginGradientFill()
beginFill 指定一种简单的单一颜色填充,在绘制时该填充将在随后对其他 Graphics 方法(如 lineTo() 或 drawCircle())的调用中使用。coloruint填充的颜色 (0xRRGGBB)。 alphaNumber1.0填充的 Alpha 值(从 0.0 到 1.0)。 指定单色填充。 指定一种简单的单一颜色填充,在绘制时该填充将在随后对其他 Graphics 方法(如 lineTo()drawCircle())的调用中使用。该填充将保持有效,直到您调用 beginFill()beginBitmapFill()beginGradientFill()beginShaderFill() 方法。调用 clear() 方法会清除填充。

只要绘制 3 个或更多个点,或者调用 endFill() 方法时,应用程序就会呈现填充。

有关如何使用此方法的说明,请参阅此类末尾的示例
endFill()beginBitmapFill()beginGradientFill()
beginGradientFill 指定一种渐变填充,用于随后调用对象的其他 Graphics 方法(如 lineTo() 或 drawCircle())。如果 type 参数无效。 ArgumentErrorArgumentErrortypeString用于指定要使用哪种渐变类型的 GradientType 类的值:GradientType.LINEARGradientType.RADIALcolorsArray渐变中使用的 RGB 十六进制颜色值的数组(例如,红色为 0xFF0000,蓝色为 0x0000FF,等等)。可以至多指定 15 种颜色。对于每种颜色,请在 alphas 和 ratios 参数中指定对应值。 alphasArraycolors 数组中对应颜色的 alpha 值数组;有效值为 0 到 1。如果值小于 0,则默认值为 0。如果值大于 1,则默认值为 1。 ratiosArray颜色分布比率的数组;有效值为 0 到 255。该值定义 100% 采样的颜色所在位置的宽度百分比。值 0 表示渐变框中的左侧位置,255 表示渐变框中的右侧位置。

注意:此值表示渐变框中的位置,而不是最终渐变的坐标空间,最终渐变可能会比渐变框更宽或更窄。为 colors 参数中的每个值指定一个值。

例如,对于包括蓝和绿两种颜色的线性渐变,下例显示了基于不同 ratios 数组值的渐变中的颜色配比:

ratios渐变[0, 127][0, 255][127, 255]

数组中的值必须持续增加;例如,[0, 63, 127, 190, 255]

matrixflash.geom:Matrixnull一个由 flash.geom.Matrix 类定义的转换矩阵。flash.geom.Matrix 类包括 createGradientBox() 方法,通过该方法可以方便地设置矩阵,以便与 beginGradientFill() 方法一起使用。 spreadMethodStringpad用于指定要使用哪种 spread 方法的 SpreadMethod 类的值:SpreadMethod.PADSpreadMethod.REFLECTSpreadMethod.REPEAT

例如,请考虑两种颜色之间的简单线性渐变:

import flash.geom.* import flash.display.* var fillType:String = GradientType.LINEAR; var colors:Array = [0xFF0000, 0x0000FF]; var alphas:Array = [1, 1]; var ratios:Array = [0x00, 0xFF]; var matr:Matrix = new Matrix(); matr.createGradientBox(20, 20, 0, 0, 0); var spreadMethod:String = SpreadMethod.PAD; this.graphics.beginGradientFill(fillType, colors, alphas, ratios, matr, spreadMethod); this.graphics.drawRect(0,0,100,100);

此示例将 SpreadMethod.PAD 用于 spread 方法,并且渐变填充看起来将类似于下图:

如果将 SpreadMethod.REFLECT 用于 spread 方法,则渐变填充看起来将类似于下图:

如果将 SpreadMethod.REPEAT 用于 spread 方法,则渐变填充看起来将类似于下图:

interpolationMethodStringrgb用于指定要使用哪个值的 InterpolationMethod 类的值:InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB

例如,假设有两种颜色之间的简单线性渐变(spreadMethod 参数设置为 SpreadMethod.REFLECT)。不同的插值方法对外观的影响如下所示:

InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB
focalPointRatioNumber0一个控制渐变的焦点位置的数字。0 表示焦点位于中心。1 表示焦点位于渐变圆的一条边界上。-1 表示焦点位于渐变圆的另一条边界上。小于 -1 或大于 1 的值将舍入为 -1 或 1。例如,下例显示 focalPointRatio 设置为 0.75:

指定渐变填充。
指定一种渐变填充,用于随后调用对象的其他 Graphics 方法(如 lineTo()drawCircle())。该填充将保持有效,直到您调用 beginFill()beginBitmapFill()beginGradientFill()beginShaderFill() 方法。调用 clear() 方法会清除填充。

只要绘制 3 个或更多个点,或者调用 endFill() 方法时,应用程序就会呈现填充。

endFill()beginFill()beginBitmapFill()flash.geom.Matrix.createGradientBox()flash.display.GradientTypeflash.display.SpreadMethod
beginShaderFill 为对象指定着色器填充,供随后调用其他 Graphics 方法(如 lineTo() 或 drawCircle())时使用。当着色器输出类型与此操作不兼容时(着色器必须指定 pixel3pixel4 输出)。 ArgumentErrorArgumentError当着色器指定了未提供的图像输入时。 ArgumentErrorArgumentError当使用 ByteArray 或 Vector.<Number> 实例作为输入,并且没有为 ShaderInput 指定 widthheight 属性或指定的值与输入对象中的数据量不匹配时。有关详细信息,请参阅 ShaderInput.input 属性。 ArgumentErrorArgumentErrorshaderflash.display:Shader要用于填充的着色器。此 Shader 实例无需指定图像输入。但是,如果在着色器中指定图像输入,则必须手动提供输入。要指定输入,请设置 Shader.data 属性的对应 ShaderInput 属性的 input 属性。

传递 Shader 实例作为参数时,会在内部复制着色器。绘图填充操作将使用该内部副本,而不是对原始着色器的引用。对着色器进行的任何更改(比如更改参数值、输入或字节代码)不会应用于所复制的用于填充的着色器。

matrixflash.geom:Matrixnull一个 matrix 对象(属于 flash.geom.Matrix 类),可用于对着色器定义转换。例如,可以使用以下矩阵将着色器旋转 45 度(pi/4 弧度): matrix = new flash.geom.Matrix(); matrix.rotate(Math.PI / 4);

着色器中收到的坐标基于为 matrix 参数指定的矩阵。对于默认 (null) 矩阵,着色器中的坐标是可用于对输入采样的局部像素坐标。

指定着色器填充。
为对象指定着色器填充,供随后调用其他 Graphics 方法(如 lineTo()drawCircle())时使用。该填充将保持有效,直到您调用 beginFill()beginBitmapFill()beginGradientFill()beginShaderFill() 方法。调用 clear() 方法会清除填充。

只要绘制 3 个或更多个点,或者调用 endFill() 方法时,应用程序就会呈现填充。

在 GPU 呈现下不支持着色器填充;填充的区域将以蓝绿色着色。

endFill()beginFill()beginBitmapFill()beginGradientFill()flash.display.ShaderInput
clear 清除绘制到此 Graphics 对象的图形,并重置填充和线条样式设置。 清除绘制到此 Graphics 对象的图形,并重置填充和线条样式设置。 copyFrom 将源 Graphics 对象中的所有绘图命令复制到执行调用的 Graphics 对象中。sourceGraphicsflash.display:Graphics从中复制绘图命令的 Graphics 对象。 将源 Graphics 对象中的所有绘图命令复制到执行调用的 Graphics 对象中。 curveTo 使用当前线条样式和由 (controlX, controlY) 指定的控制点绘制一条从当前绘画位置开始到 (anchorX, anchorY) 结束的曲线。controlXNumber一个数字,指定控制点相对于父显示对象注册点的水平位置。 controlYNumber一个数字,指定控制点相对于父显示对象注册点的垂直位置。 anchorXNumber一个数字,指定下一个锚点相对于父显示对象注册点的水平位置。 anchorYNumber一个数字,指定下一个锚点相对于父显示对象注册点的垂直位置。 使用由 (controlX, controlY) 指定的控制点绘制一条从当前绘图位置开始到 (anchorX, anchorY) 结束的曲线。 通过由 (controlX, controlY) 指定的控制点,使用当前线条样式绘制一条从当前绘图位置开始到 (anchorX, anchorY) 结束的曲线。当前绘图位置随后设置为 (anchorX, anchorY)。如果正在其中绘制的影片剪辑包含用 Flash 绘图工具创建的内容,则调用 curveTo() 方法将在该内容下面进行绘制。如果在调用 moveTo() 方法之前调用了 curveTo() 方法,则当前绘图位置的默认值为 (0, 0)。如果缺少任何一个参数,则此方法将失败,并且当前绘图位置不改变。

绘制的曲线是二次贝塞尔曲线。二次贝塞尔曲线包含两个锚点和一个控制点。该曲线内插这两个锚点,并向控制点弯曲。

下面的示例在 Sprite 显示对象注册点 (0, 0) 右侧 250 个像素的位置绘制一个绿色圆形对象,宽度和高度为 100 个像素。

绘制 4 条曲线以生成一个圆,并将其填充为绿色。

请注意,由于二次贝塞尔方程式所具有的特性,此对象并不是完美的圆。绘制圆的最佳方法是使用 Graphics 类的 drawCircle() 方法。

package { import flash.display.Sprite; import flash.display.Shape; public class Graphics_curveToExample1 extends Sprite { public function Graphics_curveToExample1():void { var roundObject:Shape = new Shape(); roundObject.graphics.beginFill(0x00FF00); roundObject.graphics.moveTo(250, 0); roundObject.graphics.curveTo(300, 0, 300, 50); roundObject.graphics.curveTo(300, 100, 250, 100); roundObject.graphics.curveTo(200, 100, 200, 50); roundObject.graphics.curveTo(200, 0, 250, 0); roundObject.graphics.endFill(); this.addChild(roundObject); } } }
下面的示例使用 curveTo() 方法绘制一个新月。

绘制两条 1 个像素粗的曲线,并将两条曲线之间的区域填充为白色。moveTo() 方法用于将当前绘制位置放在坐标 (100, 100) 上。第一条曲线将绘制位置移到 (100, 200),这是其目标点。第二条曲线将该位置恢复为开始位置 (100, 100),这是其目标点。水平控制点决定了不同的曲线大小。

package { import flash.display.Sprite; import flash.display.Shape; public class Graphics_curveToExample2 extends Sprite { public function Graphics_curveToExample2() { var newMoon:Shape = new Shape(); newMoon.graphics.lineStyle(1, 0); newMoon.graphics.beginFill(0xFFFFFF); newMoon.graphics.moveTo(100, 100); newMoon.graphics.curveTo(30, 150, 100, 200); newMoon.graphics.curveTo(50, 150, 100, 100); graphics.endFill(); this.addChild(newMoon); } } }
drawCircle 绘制一个圆。xNumber圆心相对于父显示对象注册点的 x 位置(以像素为单位)。 yNumber相对于父显示对象注册点的圆心的 y 位置(以像素为单位)。 radiusNumber圆的半径(以像素为单位)。 绘制一个圆。 绘制一个圆。在调用 drawCircle() 方法之前,通过调用 linestyle()lineGradientStyle()beginFill()beginGradientFill()beginBitmapFill() 方法来设置线条样式或/和填充。 有关如何使用此方法的说明,请参阅此类末尾的示例drawEllipse()lineStyle()lineGradientStyle()beginFill()beginGradientFill()beginBitmapFill()drawEllipse 绘制一个椭圆。xNumber椭圆边框左上角相对于父显示对象注册点的 x 位置(以像素为单位)。 yNumber椭圆边框左上角相对于父显示对象注册点的 y 位置(以像素为单位)。 widthNumber椭圆的宽度(以像素为单位)。 heightNumber椭圆的高度(以像素为单位)。 绘制一个椭圆。 绘制一个椭圆。在调用 drawEllipse() 方法之前,通过调用 linestyle()lineGradientStyle()beginFill()beginGradientFill()beginBitmapFill() 方法来设置线条样式或/和填充。 下面的示例使用 drawEgg() 函数绘制三个不同大小的鸡蛋(三种尺寸的椭圆),具体取决于 eggSize 参数。
  1. 构造函数调用 drawEgg() 函数,并为应该绘制鸡蛋的位置传递水平和垂直参数以及鸡蛋类型 (eggSize)。(可使用鸡蛋(椭圆形)高度和宽度来确定其显示位置。)
  2. drawEgg() 函数绘制不同大小的椭圆,并使用 beginFill() 方法将其填充为白色。没有事先为此函数编写错误处理代码。
package { import flash.display.Sprite; import flash.display.Shape; public class Graphics_drawEllipseExample extends Sprite { public static const SMALL:uint = 0; public static const MEDIUM:uint = 1; public static const LARGE:uint = 2; public function Graphics_drawEllipseExample() { drawEgg(SMALL, 0, 100); drawEgg(MEDIUM, 100, 60); drawEgg(LARGE, 250, 35); } public function drawEgg(eggSize:uint, x:Number, y:Number):void { var myEgg:Shape = new Shape(); myEgg.graphics.beginFill(0xFFFFFF); myEgg.graphics.lineStyle(1); switch(eggSize) { case SMALL: myEgg.graphics.drawEllipse(x, y, 60, 70); break; case MEDIUM: myEgg.graphics.drawEllipse(x, y, 120, 150); break; case LARGE: myEgg.graphics.drawEllipse(x, y, 150, 200); break; default: trace ("Wrong size! There is no egg."); break; } myEgg.graphics.endFill(); this.addChild(myEgg); } } }
drawCircle()lineStyle()lineGradientStyle()beginFill()beginGradientFill()beginBitmapFill()
drawGraphicsData 提交一系列 IGraphicsData 实例来进行绘图。graphicsData一个包含图形对象的矢量,其中的每个对象都必须实现 IGraphicsData 接口。 提交一系列 IGraphicsData 实例来进行绘图。此方法接受一个包含对象(包括路径、填充和笔触)的矢量,这些对象实现 IGraphicsData 接口。包含 IGraphicsData 实例的矢量可以引用形状的一部分,或引用一组完整定义的复杂数据以呈现完整的形状。

图形路径可以包含其他图形路径。如果 graphicsData 矢量包括路径,则在此操作期间将呈现该路径及其所有子路径。

以下示例创建了一个 GraphicsGradientFill 对象,用于建立正方形的填充属性。然后,该示例创建了一个 GraphicsStroke 对象(表示线宽)类和 GraphicsSolidFill 对象(表示线色),用于设置正方形边框线的属性。接下来,创建了一个 GraphicsPath 对象,用于包含绘制形状所用的值。所有这些对象都存储在 IGraphicsData 对象中,并传递给 drawGraphicsData() 命令来呈现形状。 package{ import flash.display.*; import flash.geom.*; public class DrawGraphicsDataExample extends Sprite { public function DrawGraphicsDataExample(){ // establish the fill properties var myFill:GraphicsGradientFill = new GraphicsGradientFill(); myFill.colors = [0xEEFFEE, 0x0000FF]; myFill.matrix = new Matrix(); myFill.matrix.createGradientBox(100, 100, 0); // establish the stroke properties var myStroke:GraphicsStroke = new GraphicsStroke(2); myStroke.fill = new GraphicsSolidFill(0x000000); // establish the path properties var myPath:GraphicsPath = new GraphicsPath(new Vector.<int>(), new Vector.<Number>()); myPath.commands.push(1,2,2,2,2); myPath.data.push(10,10, 10,100, 100,100, 100,10, 10,10); // populate the IGraphicsData Vector array var myDrawing:Vector.<IGraphicsData> = new Vector.<IGraphicsData>(); myDrawing.push(myFill, myStroke, myPath); // render the drawing graphics.drawGraphicsData(myDrawing); } } }
flash.display.IGraphicsDataflash.display.GraphicsBitmapFillflash.display.GraphicsEndFillflash.display.GraphicsGradientFillflash.display.GraphicsPathflash.display.GraphicsShaderFillflash.display.GraphicsSolidFillflash.display.GraphicsStrokeflash.display.GraphicsTrianglePath
drawPath 提交一系列绘制命令。commands一个由整数构成的矢量,表示由 GraphicsPathCommand 类定义的命令。GraphicsPathCommand 类将命令映射到此矢量数组的数字标识符。 data由数字构成的矢量,其中的每一对数字将被视为一个坐标位置(一个 x, y 对)。x 和 y 坐标值对不是 Point 对象;data 矢量是一系列数字,其中的每个由两个数字构成的组表示一个坐标位置。 windingStringevenOdd使用 GraphicsPathWinding 类中定义的值指定缠绕规则。 提交一系列绘制命令。drawPath() 方法使用矢量数组来将各个 moveTo()lineTo()curveTo() 绘图命令并入到一个调用中。drawPath() 方法参数将绘图命令与 x 和 y 坐标值对以及绘图方向合并起来。绘图命令为 GraphicsPathCommand 类中的值。x 和 y 坐标值对是数组中的数字,其中的每对数字定义一个坐标位置。绘图方向为 GraphicsPathWinding 类中的值。

通常,与使用一系列单个 lineTo()curveTo() 方法相比,使用 drawPath() 呈现绘图的速度会更快。

drawPath() 方法使用浮动计算,因此形状的旋转和缩放更准确,可以获得更好的结果。但是,通过使用 drawPath() 方法提交的曲线在与 lineTo()curveTo() 方法结合使用时,可能会存在小的子像素对齐误差。

drawPath() 方法还使用稍有不同的规则进行填充和绘制线条。这些规则是:

  • 在应用填充以呈现路径时:
    • 不呈现少于 3 个点的子路径。(但请注意,笔触呈现仍将发生,并与下面的笔触规则相一致。)
    • 隐式闭合未闭合的子路径(结束点不等于开始点)。
  • 在应用笔触以呈现路径时:
    • 子路径可以由任何数量的点组成。
    • 从不隐式闭合子路径。
下面的示例填充两个 Vector 对象,然后将其传递给 drawPath() 方法以呈现一个蓝星。第一个 Vector 对象 star_commands 包含一系列表示 flash.display.GraphicsPathCommand 类中的绘图命令的整数,其中的值 1 表示 MoveTo() 命令,值 2 表示 LineTo() 命令。第二个 Vector 对象 star_coord 包含 5 组 x 和 y 坐标对。drawPath() 方法将命令与位置进行匹配以绘制一个星形。 package{ import flash.display.*; public class DrawPathExample extends Sprite { public function DrawPathExample(){ var star_commands:Vector.<int> = new Vector.<int>(5, true); star_commands[0] = 1; star_commands[1] = 2; star_commands[2] = 2; star_commands[3] = 2; star_commands[4] = 2; var star_coord:Vector.<Number> = new Vector.<Number>(10, true); star_coord[0] = 66; //x star_coord[1] = 10; //y star_coord[2] = 23; star_coord[3] = 127; star_coord[4] = 122; star_coord[5] = 50; star_coord[6] = 10; star_coord[7] = 49; star_coord[8] = 109; star_coord[9] = 127; graphics.beginFill(0x003366); graphics.drawPath(star_commands, star_coord); } } } 在以上示例中,每个命令和坐标对是分别赋值的,以显示其在数组中的位置,但是可以在一条语句中同时对其进行赋值。以下示例通过在一条 push() 语句中同时为各个数组赋值来绘制这个星形: package{ import flash.display.*; public class DrawPathExample extends Sprite { public function DrawPathExample(){ var star_commands:Vector.<int> = new Vector.<int>(); star_commands.push(1, 2, 2, 2, 2); var star_coord:Vector.<Number> = new Vector.<Number>(); star_coord.push(66,10, 23,127, 122,50, 10,49, 109,127); graphics.beginFill(0x003366); graphics.drawPath(star_commands, star_coord); } } } 注意:默认情况下,drawPath() 方法使用奇偶缠绕类型。因此,不会填充星形的中心。为第三个参数指定非零的缠绕类型,该类型将填充星形的中心: graphics.drawPath(star_commands, star_coord, GraphicsPathWinding.NON_ZERO);
flash.display.GraphicsPathCommandflash.display.GraphicsPathWinding
drawRect 绘制一个矩形。如果 widthheight 参数不是数值 (Number.NaN)。 ArgumentErrorArgumentErrorxNumber一个表示相对于父显示对象注册点的水平位置的数字(以像素为单位)。 yNumber一个表示相对于父显示对象注册点的垂直位置的数字(以像素为单位)。 widthNumber矩形的宽度(以像素为单位)。 heightNumber矩形的高度(以像素为单位)。 绘制一个圆角矩形。 绘制一个矩形。在调用 drawRect() 方法之前,通过调用 linestyle()lineGradientStyle()beginFill()beginGradientFill()beginBitmapFill() 方法来设置线条样式或/和填充。 以下示例显示如何在 ActionScript 3.0 中绘制形状。ActionScriptExamples.com 提供的示例。 var movieClip:MovieClip = new MovieClip(); movieClip.graphics.beginFill(0xFF0000); movieClip.graphics.drawRect(0, 0, 100, 80); movieClip.graphics.endFill(); movieClip.x = 10; movieClip.y = 10; addChild(movieClip); lineStyle()lineGradientStyle()beginFill()beginGradientFill()beginBitmapFill()drawRoundRect()drawRoundRect 绘制一个圆角矩形。如果 widthheightellipseWidthellipseHeight 参数不是数值 (Number.NaN)。 ArgumentErrorArgumentErrorxNumber一个表示相对于父显示对象注册点的水平位置的数字(以像素为单位)。 yNumber一个表示相对于父显示对象注册点的垂直位置的数字(以像素为单位)。 widthNumber圆角矩形的宽度(以像素为单位)。 heightNumber圆角矩形的高度(以像素为单位)。 ellipseWidthNumber用于绘制圆角的椭圆的宽度(以像素为单位)。 ellipseHeightNumberunknown用于绘制圆角的椭圆的高度(以像素为单位)。(可选)如果未指定值,则默认值与为 ellipseWidth 参数提供的值相匹配。 绘制一个圆角矩形。 绘制一个圆角矩形。在调用 drawRoundRect() 方法之前,通过调用 linestyle()lineGradientStyle()beginFill()beginGradientFill()beginBitmapFill() 方法来设置线条样式或/和填充。 有关如何使用此方法的说明,请参阅此类末尾的示例lineStyle()lineGradientStyle()beginFill()beginGradientFill()beginBitmapFill()drawRect()drawTriangles 呈现一组三角形(通常用于扭曲位图),并为其指定三维外观。vertices由数字构成的矢量,其中的每一对数字将被视为一个坐标位置(一个 x, y 对)。vertices 参数是必需的。 indicesnull一个由整数或索引构成的矢量,其中每三个索引定义一个三角形。如果 indexes 参数为 null,则每三个顶点(vertices 矢量中的 6 对 x,y)定义一个三角形。否则,每个索引将引用一个顶点,即 vertices 矢量中的一对数字。例如,indexes[1] 引用 (vertices[2], vertices[3])。indexes 参数是可选的,但 indexes 通常会减少提交的数据量和计算的数据量。 uvtDatanull由用于应用纹理映射的标准坐标构成的矢量。每个坐标引用用于填充的位图上的一个点。每个顶点必须具有一个 UV 或一个 UVT 坐标。对于 UV 坐标,(0,0) 是位图的左上角,(1,1) 是位图的右下角。

如果此矢量的长度是 vertices 矢量长度的两倍,则使用标准坐标而不进行透视校正。

如果此矢量的长度是 vertices 矢量长度的三倍,则将第三个坐标解释为“t”(即在视角空间中从视点到纹理的距离)。这有助于呈现引擎在三维中映射纹理时正确应用透视。

如果 uvtData 参数为 null,则将应用普通填充规则(和任何填充类型)。

cullingStringnone指定是否呈现面向指定方向的三角形。此参数可防止呈现在当前视图中看不见的三角形。此参数可设置为由 TriangleCulling 类定义的任何值。
呈现一组三角形(通常用于扭曲位图),并为其指定三维外观。drawTriangles() 方法使用一组 (u,v) 坐标将当前填充或位图填充映射到三角形面。

可以使用任何类型的填充,但如果填充有转换矩阵,则将忽略该转换矩阵。

在使用位图填充时,uvtData 参数可改善纹理映射。

flash.display.TriangleCullingflash.display.GraphicsTrianglePath
endFill 对从上一次调用 beginFill()、beginGradientFill() 或 beginBitmapFill() 方法之后添加的直线和曲线应用填充。对直线和曲线应用填充。 对从上一次调用 beginFill()beginGradientFill()beginBitmapFill() 方法之后添加的直线和曲线应用填充。Flash 使用的是对 beginFill()beginGradientFill()beginBitmapFill() 方法的先前调用中指定的填充。如果当前绘图位置不等于 moveTo() 方法中指定的上一个位置,而且定义了填充,则用线条闭合该路径,然后进行填充。 beginFill()beginBitmapFill()beginGradientFill()lineBitmapStyle 指定一个位图,用于绘制线条时的线条笔触。bitmapflash.display:BitmapData用于线条笔触的位图。 matrixflash.geom:Matrixnull一个由 flash.geom.Matrix 类定义的可选转换矩阵。该矩阵可用于在将位图应用于线条样式之前缩放位图或以其他方式处理位图。 repeatBooleantrue是否以平铺方式重复位图。 smoothBooleanfalse是否应对位图应用平滑处理。 指定一个位图,用于绘制线条时的线条笔触。

位图线条样式将用于随后对 lineTo()drawCircle() 等 Graphics 方法的调用。线条样式仍然有效,直到您使用不同的参数调用 lineStyle()lineGradientStyle() 方法或再次调用 lineBitmapStyle() 方法。

可以在绘制路径的中间调用 lineBitmapStyle() 方法以为路径中的不同线段指定不同的样式。

请在调用 lineBitmapStyle() 方法之前调用 lineStyle() 方法以启用笔触,否则线条样式的值将为 undefined

调用 clear() 方法会将线条样式设置回 undefined

lineStyle()lineGradientStyle()flash.geom.Matrix
lineGradientStyle 指定一种渐变,用于绘制线条时的笔触。typeString用于指定要使用哪种渐变类型的 GradientType 类的值:GradientType.LINEAR 或 GradientType.RADIAL。 colorsArray要在渐变中使用的 RGB 十六进制颜色值数组(例如,红色为 0xFF0000,蓝色为 0x0000FF 等等)。 alphasArraycolors 数组中对应颜色的 alpha 值数组;有效值为 0 到 1。如果值小于 0,则默认值为 0。如果值大于 1,则默认值为 1。 ratiosArray颜色分布比率的数组;有效值为 0 到 255。该值定义 100% 采样的颜色所在位置的宽度百分比。值 0 表示渐变框中的左侧位置,255 表示渐变框中的右侧位置。此值表示渐变框中的位置,而不是最终渐变的坐标空间,最终渐变可能会比渐变框更宽或更窄。为 colors 参数中的每个值指定一个值。

例如,对于包含蓝和绿两种颜色的线性渐变,下图显示了基于不同 ratios 数组值的颜色配比:

ratios渐变[0, 127][0, 255][127, 255]

数组中的值必须持续增加;例如,[0, 63, 127, 190, 255]

matrixflash.geom:Matrixnull一个由 flash.geom.Matrix 类定义的转换矩阵。flash.geom.Matrix 类包括 createGradientBox() 方法,通过该方法可以方便地设置矩阵,以便与 lineGradientStyle() 方法一起使用。 spreadMethodStringpad用于指定要使用哪种 spread 方法的 SpreadMethod 类的值:

SpreadMethod.PADSpreadMethod.REFLECTSpreadMethod.REPEAT

interpolationMethodStringrgbInterpolationMethod 类中用于指定所用值的值。例如,假设有两种颜色之间的简单线性渐变(spreadMethod 参数设置为 SpreadMethod.REFLECT)。不同的插值方法对外观的影响如下所示:

InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB

focalPointRatioNumber0一个控制渐变的焦点位置的数字。值 0 表示焦点位于中心。值 1 表示焦点位于渐变圆的一条边界上。值 -1 表示焦点位于渐变圆的另一条边界上。小于 -1 或大于 1 的值将舍入为 -1 或 1。下列图像显示 focalPointRatio 为 -0.75 的渐变:

指定一种渐变,用于绘制线条时的笔触。

渐变线条样式将用于随后对 lineTo()drawCircle() 等 Graphics 方法的调用。线条样式仍然有效,直到您使用不同的参数调用 lineStyle()lineBitmapStyle() 方法或再次调用 lineGradientStyle() 方法。

可以在绘制路径的中间调用 lineGradientStyle() 方法以为路径中的不同线段指定不同的样式。

请在调用 lineGradientStyle() 方法之前调用 lineStyle() 方法以启用笔触,否则线条样式的值将为 undefined

调用 clear() 方法会将线条样式设置回 undefined

下面的示例绘制一个矩形和一个圆,它们使用从红色到绿色、再到蓝色的渐变笔触。

Matrix 类中的方法 createGradientBox() 用于将渐变框定义为 200 个像素宽、40 个像素高。线条粗细设置为 5 个像素。必须为 lineGradientStyle() 方法定义笔触粗细。渐变设置为线性。渐变颜色设置为红色、绿色和蓝色。颜色透明度(Alpha 值)设置为 1(不透明)。渐变的分布是均匀的,其中在 0(渐变框中的左侧位置)、128(渐变框的中间位置)和 255(渐变框中的右侧位置)处的颜色采样率为 100%。矩形宽度范围内包含渐变的所有色谱;而圆包含色谱中间的 50%。

package { import flash.display.Sprite; import flash.display.Shape; import flash.geom.Matrix; import flash.display.GradientType; public class Graphics_lineGradientStyleExample extends Sprite { public function Graphics_lineGradientStyleExample() { var myShape:Shape = new Shape(); var gradientBoxMatrix:Matrix = new Matrix(); gradientBoxMatrix.createGradientBox(200, 40, 0, 0, 0); myShape.graphics.lineStyle(5); myShape.graphics.lineGradientStyle(GradientType.LINEAR, [0xFF0000, 0x00FF00, 0x0000FF], [1, 1, 1], [0, 128, 255], gradientBoxMatrix); myShape.graphics.drawRect(0, 0, 200, 40); myShape.graphics.drawCircle(100, 120, 50); this.addChild(myShape); } } }
lineStyle()lineBitmapStyle()flash.geom.Matrix.createGradientBox()flash.display.GradientTypeflash.display.SpreadMethod
lineShaderStyle 指定一个着色器以用于绘制线条时的线条笔触。shaderflash.display:Shader用于线条笔触的着色器。 matrixflash.geom:Matrixnull一个由 flash.geom.Matrix 类定义的可选转换矩阵。该矩阵可用于在将位图应用于线条样式之前缩放位图或以其他方式处理位图。 指定一个着色器以用于绘制线条时的线条笔触。

着色器线条样式将用于随后对 lineTo()drawCircle() 等 Graphics 方法的调用。线条样式仍然有效,直到您使用不同的参数调用 lineStyle()lineGradientStyle() 方法或再次调用 lineBitmapStyle() 方法。

可以在绘制路径的中间调用 lineShaderStyle() 方法,以便为路径中的不同线段指定不同的样式。

请在调用 lineShaderStyle() 方法之前调用 lineStyle() 方法以启用笔触,否则线条样式的值将为 undefined

调用 clear() 方法会将线条样式设置回 undefined

lineStyle()lineBitmapStyle()flash.geom.Matrix
lineStyle 指定一种线条样式以用于随后对 lineTo() 或 drawCircle() 等 Graphics 方法的调用。thicknessNumberunknown一个整数,以点为单位表示线条的粗细;有效值为 0 到 255。如果未指定数字,或者未定义该参数,则不绘制线条。如果传递的值小于 0,则默认值为 0。值 0 表示极细的粗细;最大粗细为 255。如果传递的值大于 255,则默认值为 255。 coloruint0线条的十六进制颜色值(例如,红色为 0xFF0000,蓝色为 0x0000FF 等)。如果未指明值,则默认值为 0x000000(黑色)。可选。 alphaNumber1.0表示线条颜色的 Alpha 值的数字;有效值为 0 到 1。如果未指明值,则默认值为 1(纯色)。如果值小于 0,则默认值为 0。如果值大于 1,则默认值为 1。 pixelHintingBooleanfalse(在 Flash Lite 4 中不受支持)布尔型值,指定是否提示笔触采用完整像素。它同时影响曲线锚点的位置以及线条笔触大小本身。在 pixelHinting 设置为 true 的情况下,线条宽度会调整到完整像素宽度。在 pixelHinting 设置为 false 的情况下,对于曲线和直线可能会出现脱节。例如,下面的插图显示了 Flash Player 或 Adobe AIR 如何呈现两个相同的圆角矩形,不同之处是 lineStyle() 方法中使用的 pixelHinting 参数的设置不同(图像已放大 200% 以强调差异):

如果未提供值,则线条不使用像素提示。

scaleModeStringnormal(在 Flash Lite 4 中不支持)LineScaleMode 类的值,用于指定要使用的比例模式:
  • LineScaleMode.NORMAL -- 在缩放对象时总是缩放线条的粗细(默认值)。
  • LineScaleMode.NONE -- 从不缩放线条粗细。
  • LineScaleMode.VERTICAL -- 如果 垂直缩放对象,则不缩放线条粗细。例如,考虑下面的圆形,它们是用一个像素的线条绘制的,每个圆的 scaleMode 参数都被设置为 LineScaleMode.VERTICAL。左边的圆仅在垂直方向上缩放,而右边的圆则同时在垂直和水平方向上缩放:

  • LineScaleMode.HORIZONTAL -- 如果 水平缩放对象,则不缩放线条粗细。例如,考虑下面的圆形,它们是用一个像素的线条绘制的,每个圆的 scaleMode 参数都被设置为 LineScaleMode.HORIZONTAL。左边的圆仅在水平方向上缩放,而右边的圆则同时在垂直和水平方向上缩放:

capsStringnull(在 Flash Lite 4 中不支持)用于指定线条末端处端点类型的 CapsStyle 类的值。有效值为:CapsStyle.NONECapsStyle.ROUNDCapsStyle.SQUARE。如果未表示值,则 Flash 使用圆头端点。

例如,以下图示显示了不同的 capsStyle 设置。对于每种设置,插图显示了一条粗细为 30 的蓝色线条(应用 capsStyle 的线条),以及重叠于其上的粗细为 1 的黑色线条(未应用 capsStyle 的线条):

jointsStringnull(在 Flash Lite 4 中不支持)JointStyle 类的值,指定用于拐角的连接外观的类型。有效值为:JointStyle.BEVELJointStyle.MITERJointStyle.ROUND。如果未表示值,则 Flash 使用圆角连接。

例如,以下图示显示了不同的 joints 设置。对于每种设置,插图显示了一条粗细为 30 的带拐角的蓝色线条(应用 jointStyle 的线条),以及重叠于其上的粗细为 1 的带拐角的黑色线条(未应用 jointStyle 的线条):

注意:对于设置为 JointStyle.MITERjoints,您可以使用 miterLimit 参数限制尖角的长度。

miterLimitNumber3(在 Flash Lite 4 中不支持)用于表示剪切斜接的极限值的数字。有效值的范围是 1 到 255(超出该范围的值将舍入为 1 或 255)。此值只可用于 jointStyle 设置为 "miter" 的情况下。miterLimit 值表示向外延伸的尖角可以超出角边相交所形成的结合点的长度。此值表示为线条 thickness 的因子。例如,miterLimit 因子为 2.5 且 thickness 为 10 像素时,尖角将在 25 像素处切断。

例如,请考虑下列带拐角的线条,每个线条都以 thickness 20 进行绘制,但它们的 miterLimit 分别设置为 1、2 和 4。重叠在其上的黑色参考线条显示了结合处的联结点:

请注意,对于给定的 miterLimit 值,会有一个被切断的尖角的特定最大角度。下表列出了部分示例:

miterLimit 值:小于此角度将被切断:1.41490 度260 度430 度815 度
指定 Flash 用于绘制线条的线条样式。
指定一种线条样式以用于随后对 lineTo()drawCircle() 等 Graphics 方法的调用。线条样式仍然有效,直到您使用不同的参数调用 lineGradientStyle() 方法、lineBitmapStyle() 方法或 lineStyle() 方法。

可以在绘制路径的中间调用 lineStyle() 方法以为路径中的不同线段指定不同的样式。

注意:调用 clear() 方法会将线条样式设置回 undefined

注意:Flash Lite 4 仅支持前 3 个参数(thicknesscoloralpha)。

有关如何使用 getStyle() 方法的说明,请参阅 lineTo()moveTo() 方法的示例。
lineBitmapStyle()lineGradientStyle()LineScaleModeCapsStyleJointStyle
lineTo 使用当前线条样式绘制一条从当前绘图位置开始到 (x, y) 结束的直线;当前绘图位置随后会设置为 (x, y)。xNumber一个表示相对于父显示对象注册点的水平位置的数字(以像素为单位)。 yNumber一个表示相对于父显示对象注册点的垂直位置的数字(以像素为单位)。 绘制一条从当前绘图位置开始到 (x, y) 结束的直线。 使用当前线条样式绘制一条从当前绘图位置开始到 (x, y) 结束的直线;当前绘图位置随后会设置为 (x, y)。如果正在其中绘制的显示对象包含用 Flash 绘图工具创建的内容,则调用 lineTo() 方法将在该内容下面进行绘制。如果在对 moveTo() 方法进行任何调用之前调用了 lineTo(),则当前绘图的默认位置为 (0, 0)。如果缺少任何一个参数,则此方法将失败,并且当前绘图位置不改变。 下面的示例使用 lineTo() 方法绘制一个梯形,从像素 (100, 100) 开始。

线条粗细设置为 10 个像素,颜色为金色且不透明,线条终点设置为 none(因为联接了所有线条),两条线之间的联接点设置为 MITER 并将尖角限制设置为 10 以绘制尖锐的边角。

package { import flash.display.Sprite; import flash.display.LineScaleMode; import flash.display.CapsStyle; import flash.display.JointStyle; import flash.display.Shape; public class Graphics_lineToExample extends Sprite { public function Graphics_lineToExample() { var trapezoid:Shape = new Shape(); trapezoid.graphics.lineStyle(10, 0xFFD700, 1, false, LineScaleMode.VERTICAL, CapsStyle.NONE, JointStyle.MITER, 10); trapezoid.graphics.moveTo(100, 100); trapezoid.graphics.lineTo(120, 50); trapezoid.graphics.lineTo(200, 50); trapezoid.graphics.lineTo(220, 100); trapezoid.graphics.lineTo(100, 100); this.addChild(trapezoid); } } }
moveTo 将当前绘图位置移动到 (x, y)。xNumber一个表示相对于父显示对象注册点的水平位置的数字(以像素为单位)。 yNumber一个表示相对于父显示对象注册点的垂直位置的数字(以像素为单位)。 将当前绘图位置移动到 (x, y)。 将当前绘图位置移动到 (x, y)。如果缺少任何一个参数,则此方法将失败,并且当前绘图位置不改变。 下面的示例使用 moveTo()lineTo() 方法绘制一条 3 个像素粗的虚线。

通过使用 lineStyle() 方法,将线条粗细设置为 3 个像素。还将其设置为不进行缩放。颜色设置为红色,并且不透明度为 25%。CapsStyle 属性设置为 square(默认值为 round)。

由于 Graphics_moveToExampleSprite 类实例,因此,它具有所有 Graphics 类方法的访问权限。可以使用 Graphics 类方法直接在 Graphic_moveToExample Sprite 对象上进行绘制。但是,如果未将矢量绘画对象放在 Shape 中,则会限制它们的管理、移动或更改方式。

package { import flash.display.Sprite; import flash.display.CapsStyle; import flash.display.LineScaleMode; public class Graphics_moveToExample extends Sprite { public function Graphics_moveToExample() { graphics.lineStyle(3, 0x990000, 0.25, false, LineScaleMode.NONE, CapsStyle.SQUARE); graphics.moveTo(10, 20); graphics.lineTo(20, 20); graphics.moveTo(30, 20); graphics.lineTo(50, 20); graphics.moveTo(60, 20); graphics.lineTo(80, 20); graphics.moveTo(90, 20); graphics.lineTo(110, 20); graphics.moveTo(120, 20); graphics.lineTo(130, 20); } } }
NativeWindowType NativeWindowType 类定义一些常量,它们用作创建本机窗口的 NativeWindowInitOptions 对象的 type 属性。定义支持的窗口类型使用的常量。 Object NativeWindowType 类定义一些常量,它们用作创建本机窗口的 NativeWindowInitOptions 对象的 type 属性。

注意:type 值是在创建窗口时指定的,无法更改。

flash.display.NativeWindowflash.display.NativeWindowInitOptionsLIGHTWEIGHT 最小窗口。lightweightString 最小窗口。 NORMAL 典型窗口。normalString 典型窗口。 UTILITY 实用程序窗口。utilityString 实用程序窗口。
StageAspectRatio StageAspectRatio 类提供 Stage.setAspectRatio() 方法的值。Object StageAspectRatio 类提供 Stage.setAspectRatio() 方法的值。 flash.display.Stage.setAspectRatio()LANDSCAPE 指定提供横向 UI 的设备方向 landscapeString 指定提供横向 UI 的设备方向 PORTRAIT 指定提供纵向 UI 的设备方向 portraitString 指定提供纵向 UI 的设备方向 Screen Screen 类提供此应用程序的可用显示屏幕的相关信息。flash.events:EventDispatcher Screen 类提供此应用程序的可用显示屏幕的相关信息。

屏幕是位于可能更大的“虚拟桌面”内的独立桌面区域。虚拟桌面的原点是操作系统指定的主屏幕的左上角。因此,个别显示屏幕范围的坐标可能是负数。虚拟桌面也可能有一些不在任何显示屏幕内的区域。

Screen 类包括用于访问可用屏幕对象的静态类成员和用于访问个别屏幕属性的实例成员。屏幕信息不应进行缓存,因为这些信息可能会由用户随时更改。

请注意,屏幕和连接到计算机的物理监视器之间不一定有一对一的对应关系。例如,两台监视器可以显示同一个屏幕。

无法直接实例化 Screen 类。调用 new Screen() 构造函数将引发 ArgumentError 异常。

下面的示例通过定义 DockingWindow 类来创建一个停靠在屏幕某一侧的窗口。执行下列步骤可完成该任务:
  1. 响应键盘事件以确定停靠在屏幕的哪一侧。
  2. 访问静态 Screen 类方法 getScreensForRectangle() 可以获取当前显示该窗口的屏幕的 Screen 对象。
  3. 根据屏幕尺寸重新设置窗口范围。
  4. 根据新窗口尺寸重新绘制窗口内容。

请注意,此类旨在用作具有 SystemChrome="none"transparent="true" 设置的 AIR 应用程序的根类。要在具有系统镶边的窗口中使用此类,在计算窗口位置和大小时,必须将镶边的粗细和窗口的最小宽度考虑在内。

package { import flash.display.Screen; import flash.display.Sprite; import flash.display.StageAlign; import flash.display.StageScaleMode; import flash.events.KeyboardEvent; import flash.geom.Rectangle; import flash.ui.Keyboard; public class DockingWindow extends Sprite { private const dockedWidth:uint = 80; private const dockedHeight:uint = 80; public function DockingWindow():void{ stage.align = StageAlign.TOP_LEFT; stage.scaleMode = StageScaleMode.NO_SCALE; stage.addEventListener(KeyboardEvent.KEY_DOWN,onKey); dockLeft(); } private function onKey(event:KeyboardEvent):void{ switch(event.keyCode){ case Keyboard.LEFT : dockLeft(); break; case Keyboard.RIGHT : dockRight(); break; case Keyboard.UP : dockTop(); break; case Keyboard.DOWN : dockBottom(); break; case Keyboard.SPACE : stage.nativeWindow.close(); } } public function dockLeft():void{ var screen:Screen = getCurrentScreen(); stage.nativeWindow.x = screen.visibleBounds.left; stage.nativeWindow.y = screen.visibleBounds.top; stage.nativeWindow.height = screen.visibleBounds.height; stage.stageWidth = dockedWidth; drawContent(); } public function dockRight():void{ var screen:Screen = getCurrentScreen(); stage.nativeWindow.x = screen.visibleBounds.width - dockedWidth; stage.nativeWindow.y = screen.visibleBounds.top; stage.stageWidth = dockedWidth; stage.nativeWindow.height = screen.visibleBounds.height; drawContent(); } public function dockTop():void{ var screen:Screen = getCurrentScreen(); stage.nativeWindow.x = screen.visibleBounds.left; stage.nativeWindow.y = screen.visibleBounds.top; stage.nativeWindow.width = screen.visibleBounds.width; stage.stageHeight = dockedHeight; drawContent(); } public function dockBottom():void{ var screen:Screen = getCurrentScreen(); stage.nativeWindow.x = screen.visibleBounds.left; stage.nativeWindow.y = screen.visibleBounds.height - dockedHeight; stage.nativeWindow.width = screen.visibleBounds.width; stage.stageHeight = dockedHeight; drawContent(); } private function getCurrentScreen():Screen{ return Screen.getScreensForRectangle(stage.nativeWindow.bounds)[0]; } private function drawContent():void{ const size:int = 60; const pad:int = 10; var numHSquares:int = Math.floor(stage.stageWidth/(size + pad)); var numVSquares:int = Math.floor(stage.stageHeight/(size + pad)); with (graphics){ clear(); lineStyle(1); beginFill(0x3462d5,.7); for(var i:int = 0; i < numHSquares; i++){ for(var j:int = 0; j < numVSquares; j++){ drawRect((i * (size + pad)) + pad, (j * (size + pad)) + pad, size, size); } } endFill(); } } } }
getScreensForRectangle 返回一组与提供的矩形相交的屏幕(可能为空)。包含屏幕的 Screen 对象的数组,这些屏幕包含由 rect 参数定义的区域的任何部分。 Arrayrectflash.geom:Rectangle一个具有相对于虚拟桌面原点(主屏幕的左上角)的坐标的矩形。 返回一组与提供的矩形相交的屏幕(可能为空)。 下面的示例显示如何获取至少包含给定矩形一部分的屏幕的数组: import flash.display.Screen; import flash.geom.Rectangle; var rect:Rectangle = new Rectangle(-200, 100, 1000, 600); var intersectedScreens:Array = Screen.getScreensForRectangle(rect); bounds 此屏幕的范围。flash.geom:Rectangle 此屏幕的范围。

屏幕位置相对于虚拟桌面。

在使用某些窗口管理器的 Linux 系统中,此属性返回桌面边界,而不是屏幕的可视边界。

下面的示例显示如何获取屏幕(在本例中为主显示屏幕)的范围: import flash.display.Screen; import flash.geom.Rectangle; var mainScreen:Screen = Screen.mainScreen; var screenBounds:Rectangle = mainScreen.bounds;
colorDepth 此屏幕的颜色深度(以位数为单位)。int 此屏幕的颜色深度(以位数为单位)。 下面的示例显示如何获取屏幕(在本例中为主显示屏幕)的颜色深度: var mainScreen:Screen = Screen.mainScreen; var colors:uint = mainScreen.colorDepth; mainScreen 主显示器。flash.display:Screen 主显示器。 下面的示例显示如何获取表示此计算机的“主”屏幕的 Screen 对象。 var primaryScreen:Screen = Screen.mainScreen; screens 当前可用的屏幕的数组。Array 当前可用的屏幕的数组。

修改返回的数组对可用的屏幕没有任何效果。

下面的示例显示如何获取包含可用屏幕的数组: var screenArray:Array = Screen.screens;
visibleBounds 此屏幕上可以看见窗口的区域范围。flash.geom:Rectangle 此屏幕上可以看见窗口的区域范围。

屏幕的 visibleBounds 在 Windows 中不包括任务栏(和其他停靠的桌面栏),而在 Mac OS X 中则不包括菜单栏和停靠栏(具体取决于系统设置)。在某些 Linux 配置中无法确定可见边界。在这些情况下,visibleBounds 属性返回与 screenBounds 属性相同的值。

下面的示例显示如何获取屏幕(在本例中为主显示屏幕)的可用范围: import flash.display.Screen; import flash.geom.Rectangle; var mainScreen:Screen = Screen.mainScreen; var screenBounds:Rectangle = mainScreen.visibleBounds;
NativeWindowDisplayState NativeWindowDisplayState 类定义表示窗口显示状态名称的常量。Object NativeWindowDisplayState 类定义表示窗口显示状态名称的常量。

注意:全屏模式是使用 Stage 对象的 displayState 属性,而不是窗口的 displaySate 设置的。

flash.display.Stage.displayStateflash.display.StageDisplayStateMAXIMIZED 最大化显示状态。maximizedString 最大化显示状态。 MINIMIZED 最小化显示状态。minimizedString 最小化显示状态。 NORMAL 正常显示状态。normalString 正常显示状态。
Bitmap Bitmap 类表示用于表示位图图像的显示对象。表示从图像派生的显示对象。 flash.display:DisplayObject Bitmap 类表示用于表示位图图像的显示对象。这些图像可以是使用 flash.display.Loader 类加载的图像,也可以是使用 Bitmap() 构造函数创建的图像。

利用 Bitmap() 构造函数,可以创建包含对 BitmapData 对象的引用的 Bitmap 对象。创建了 Bitmap 对象后,使用父 DisplayObjectContainer 实例的 addChild()addChildAt() 方法将位图放在显示列表中。

一个 Bitmap 对象可在若干 Bitmap 对象之中共享其 BitmapData 引用,与转换属性或旋转属性无关。由于能够创建引用相同 BitmapData 对象的多个 Bitmap 对象,因此,多个显示对象可以使用相同的复杂 BitmapData 对象,而不会因为每个显示对象实例使用一个 BitmapData 对象而产生内存开销。

Bitmap 对象可通过以下两种方式之一将 BitmapData 对象绘制到屏幕上:使用矢量渲染器作为填充位图形状,或使用更快的像素复制例程。像素复制例程的速度比矢量渲染器要快很多,但 Bitmap 对象必须满足某些条件才能使用该例程:

  • 不能将拉伸、旋转或倾斜效果应用于 Bitmap 对象。
  • 不能将颜色转换应用于 Bitmap 对象。
  • 不能将混合模式应用于 Bitmap 对象。
  • 不能通过蒙版或 setMask() 方法进行剪裁。
  • 图像本身不能是遮罩。
  • 目标坐标必须位于一个整像素边界上。

如果从中加载 Bitmap 对象的域不同于用于加载图像的 Loader 对象的域,并且没有用于允许访问 Loader 对象的域的 URL 策略文件,则该域中的脚本无法访问 Bitmap 对象或其属性及方法。有关详细信息,请参阅 Flash Player 开发人员中心主题:安全性

注意:Bitmap 类不是 InteractiveObject 类的子类,因此它无法调度鼠标事件。但是,可以使用包含 Bitmap 对象的显示对象容器的 addEventListener() 方法。

下例将使用 BitmapExample 类将“Image.gif”图像加载到位于默认位置(x = 0, y = 0)的 DisplayObject 中。然后,将 Image.gif 的副本放在原图像的右边,它使用 threshold() 方法。此任务是使用以下步骤完成的:
  1. 创建一个 url 属性,它是图像文件的位置和名称
  2. 类构造函数调用 configureAssets() 方法,而后者又调用 completeHandler() 方法。
  3. configureAssets() 创建 Loader 对象,该对象随后实例化一个事件侦听器,而该事件侦听器在 completeHandler() 完成图像操作时调度。
  4. 下一步,buildChild() 方法创建一个 URLRequest 对象的新实例 request,该实例带有传递的 url,这样,就可以知道文件的名称和位置。
  5. request 对象被传递给 loader.load() 方法,该方法通过显示对象将图像加载到内存中。
  6. 图像随后将被放在显示列表中,后者将图像立即显示在屏幕的坐标 x = 0, y = 0 处。
  7. 然后,completeHandler() 方法将执行下列任务:
    1. 创建另一个 Loader 对象,以及使用 Loader 对象初始化的 Bitmap 对象。
    2. 创建第二个 Bitmap 对象 duplicate,该对象再调用 duplicateImage() 方法,该方法创建原始图像的副本。
    3. 创建一个 BitmapData 对象,该对象将被分配给 duplicate 对象的 BitmapData 对象。
    4. 创建一个与原始图像具有相同的坐标、宽度和高度的新的 Rectangle 对象。
    5. 创建一个新的 Point 对象,其默认为 x = 0, y = 0
    6. 创建以下变量:
      • operation:在阈值大于等于原始值时应用新颜色。
      • threshold:依据其对每个像素进行比较的值设置为浅灰色(Alpha 值为 0xCC)。
      • color:通过阈值测试的像素将被设置的颜色,在本例中为纯黄色。
      • mask:设置为与颜色正好相反的颜色(透明的蓝色)。
      • copySource:设置为 false,指示在阈值未通过测试的情况下不复制像素值。该值没有意义,因为图像是重复的,并且只更改通过了阈值测试的像素。
    7. 使用前面的变量调用 threshold() 方法。得到的阈值计算式如下所示:if (current pixel Value & 0x000000FF) >= (0xCCCCCCCC & 0x000000FF) then set pixel to 0xFFFFFF00

注意:

  • 您需要编译 SWF 文件,将“本地播放安全性”设置为“只访问本地文件”。
  • 此示例要求将名为 Image.gif 的文件与您的 SWF 文件放在同一目录中。
  • 建议使用宽度最大为 80 像素的图像。

package { import flash.display.Bitmap; import flash.display.BitmapData; import flash.display.Loader; import flash.display.Sprite; import flash.events.*; import flash.geom.Point; import flash.geom.Rectangle; import flash.net.URLRequest; public class BitmapExample extends Sprite { private var url:String = "Image.gif"; private var size:uint = 80; public function BitmapExample() { configureAssets(); } private function configureAssets():void { var loader:Loader = new Loader(); loader.contentLoaderInfo.addEventListener(Event.COMPLETE, completeHandler); loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); var request:URLRequest = new URLRequest(url); loader.x = size * numChildren; loader.load(request); addChild(loader); } private function duplicateImage(original:Bitmap):Bitmap { var image:Bitmap = new Bitmap(original.bitmapData.clone()); image.x = size * numChildren; addChild(image); return image; } private function completeHandler(event:Event):void { var loader:Loader = Loader(event.target.loader); var image:Bitmap = Bitmap(loader.content); var duplicate:Bitmap = duplicateImage(image); var bitmapData:BitmapData = duplicate.bitmapData; var sourceRect:Rectangle = new Rectangle(0, 0, bitmapData.width, bitmapData.height); var destPoint:Point = new Point(); var operation:String = ">="; var threshold:uint = 0xCCCCCCCC; var color:uint = 0xFFFFFF00; var mask:uint = 0x000000FF; var copySource:Boolean = true; bitmapData.threshold(bitmapData, sourceRect, destPoint, operation, threshold, color, mask, copySource); } private function ioErrorHandler(event:IOErrorEvent):void { trace("Unable to load image: " + url); } } }
flash.display.Loaderflash.display.BitmapDataBitmap 初始化 Bitmap 对象以引用指定的 BitmapData 对象。bitmapDataflash.display:BitmapDatanull被引用的 BitmapData 对象。 pixelSnappingStringautoBitmap 对象是否贴紧至最近的像素。 smoothingBooleanfalse在缩放时是否对位图进行平滑处理。例如,下例显示使用系数 3 缩放的同一位图,smoothing 设置为 false(左侧)和 true(右侧):

初始化 Bitmap 对象以引用指定的 BitmapData 对象。 以下示例显示如何使用 ActionScript 3.0 Loader 类在运行时动态加载图像,然后使用 Loader 实例的 content 属性和 bitmapData 属性将图像的像素复制到四个单独的 Bitmap 对象实例中。ActionScriptExamples.com 提供的示例。 const IMAGE_URL:String = "http://www.helpexamples.com/flash/images/logo.png"; var ldr:Loader = new Loader(); ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, ldr_complete); ldr.load(new URLRequest(IMAGE_URL)); var bitmap1:Bitmap; var bitmap2:Bitmap; var bitmap3:Bitmap; var bitmap4:Bitmap; function ldr_complete(evt:Event):void { var bmp:Bitmap = ldr.content as Bitmap; bitmap1 = new Bitmap(bmp.bitmapData); bitmap1.x = 100; bitmap1.y = 100; bitmap1.rotation = 0; addChild(bitmap1); bitmap2 = new Bitmap(bmp.bitmapData); bitmap2.x = 200; bitmap2.y = 100; bitmap2.rotation = 90; addChild(bitmap2); bitmap3 = new Bitmap(bmp.bitmapData); bitmap3.x = 300; bitmap3.y = 100; bitmap3.rotation = 180; addChild(bitmap3); bitmap4 = new Bitmap(bmp.bitmapData); bitmap4.x = 400; bitmap4.y = 100; bitmap4.rotation = 270; addChild(bitmap4); }
bitmapData 被引用的 BitmapData 对象。flash.display:BitmapData 被引用的 BitmapData 对象。 pixelSnapping 控制 Bitmap 对象是否贴紧至最近的像素。String 控制 Bitmap 对象是否贴紧至最近的像素。PixelSnapping 类包括以下可能值:
  • PixelSnapping.NEVER -- 不进行像素贴紧。
  • PixelSnapping.ALWAYS -- 图像始终与最近的像素贴紧,与变形无关。
  • PixelSnapping.AUTO -- 如果绘制图像时未应用旋转或倾斜效果,并且图像是以 99.9% 到 100.1% 的缩放系数绘制的,则图像将与最近的像素贴紧。如果这些条件得到满足,则以 100% 的缩放比例绘制位图图像,与最近的像素贴紧。在内部,此值允许用矢量渲染器以尽可能快的速度绘制图像。
smoothing 控制在缩放时是否对位图进行平滑处理。Boolean 控制在缩放时是否对位图进行平滑处理。如果为 true,则会在缩放时对位图进行平滑处理。如果为 false,则不会在缩放时对位图进行平滑处理。
Scene Scene 类包括用于标识场景中帧的名称、标签和数量的属性。Object Scene 类包括用于标识场景中帧的名称、标签和数量的属性。在 Flash Professional 中创建 Scene 对象实例,而不是通过编写 ActionScript 代码创建。MovieClip 类包括 currentScene 属性,它是可以标识以下场景的 Scene 对象:播放头位于 MovieClip 实例的时间轴中。MovieClip 类的 scenes 属性是 Scene 对象的数组。而且,MovieClip 类的 gotoAndPlay()gotoAndStop() 方法使用 Scene 对象作为参数。 MovieClip.currentSceneMovieClip.scenesMovieClip.gotoAndPlay()MovieClip.gotoAndStop()labels 一个由场景的 FrameLabel 对象组成的数组。Array 一个由场景的 FrameLabel 对象组成的数组。每个 FrameLabel 对象都包含一个 frame 属性,该属性指定与标签对应的帧编号以及 name 属性。 FrameLabelname 场景的名称。String 场景的名称。 numFrames 场景中的帧数。int 场景中的帧数。 StageDisplayState StageDisplayState 类为 Stage.displayState 属性提供值。Object StageDisplayState 类为 Stage.displayState 属性提供值。 flash.display.Stage.displayStateFULL_SCREEN_INTERACTIVE 指定舞台处于启用键盘交互性操作的全屏模式。fullScreenInteractiveString 指定舞台处于启用键盘交互性操作的全屏模式。只有 AIR 应用程序支持此功能。 FULL_SCREEN 指定舞台处于全屏模式。fullScreenString 指定舞台处于全屏模式。在此模式下禁用键盘交互性操作。 NORMAL 指定舞台处于标准模式。normalString 指定舞台处于标准模式。 ShaderData ShaderData 对象包含以下属性:表示着色器内核的任何参数和输入的属性,以及包含为着色器指定的任何元数据的属性。Object ShaderData 对象包含以下属性:表示着色器内核的任何参数和输入的属性,以及包含为着色器指定的任何元数据的属性。

创建 ShaderData 对象时会将这些属性添加到该对象中。这些属性的名称与着色器源代码中指定的名称相匹配。每个属性的数据类型因属性所表示的着色器方面而异。表示着色器参数的属性是 ShaderParameter 实例,表示输入图像的属性是 ShaderInput 实例,而表示着色器元数据的属性是与其数据类型相对应的 ActionScript 类的实例(例如,文本元数据的 String 实例和 uint 元数据的 uint)。

例如,假设有以下着色器,其中定义有一个输入图像 (src)、两个参数(sizeradius)以及三个元数据值(nameSpaceversiondescription):

<languageVersion : 1.0;> kernel DoNothing < namespace: "Adobe::Example"; vendor: "Adobe examples"; version: 1; description: "A shader that does nothing, but does it well."; > { input image4 src; output pixel4 dst; parameter float2 size < description: "The size of the image to which the kernel is applied"; minValue: float2(0.0, 0.0); maxValue: float2(100.0, 100.0); defaultValue: float2(50.0, 50.0); >; parameter float radius < description: "The radius of the effect"; minValue: 0.0; maxValue: 50.0; defaultValue: 25.0; >; void evaluatePixel() { float2 one = (radius / radius) ∗ (size / size); dst = sampleNearest(src, outCoord()); } }

如果通过为此着色器加载字节代码来创建 Shader 实例,则其 data 属性中的 ShaderData 实例包含以下属性:

属性数据类型name字符串"DoNothing"nameSpace字符串"Adobe::Example"version字符串"1"description字符串"A shader that does nothing, but does it well."srcShaderInput[一个 ShaderInput 实例]sizeShaderParameter[一个 ShaderParameter 实例,包含参数元数据的属性]radiusShaderParameter[一个 ShaderParameter 实例,包含参数元数据的属性]

请注意,将着色器编译为字节代码时,会删除着色器源代码中已定义但未在着色器的 evaluatePixel() 函数中使用的任何输入图像或参数。这种情况下,不会添加对应的 ShaderInput 或 ShaderParameter 实例作为 ShaderData 实例的属性。

通常,开发人员代码不创建 ShaderData 实例。包含着色器数据、参数和输入的 ShaderData 实例可用作 Shader 实例的 data 属性。

下面的示例加载着色器并枚举着色器的 data 属性中的 ShaderData 实例,以显示着色器的输入、参数和元数据属性。

请注意,此示例假设应用程序输出目录所在的同一目录中有一个名为“donothing.pbj”的着色器字节码文件。

// // Source code for the shader: // <languageVersion : 1.0;> kernel DoNothing < namespace: "Adobe::Example"; vendor: "Adobe examples"; version: 1; description: "A shader that does nothing, but does it well."; > { input image4 src; output pixel4 dst; parameter float2 size < description: "The size of the image to which the shader is applied"; minValue: float2(0.0, 0.0); maxValue: float2(100.0, 100.0); defaultValue: float2(50.0, 50.0); >; parameter float radius < description: "The radius of the effect"; minValue: float(0.0); maxValue: float(50.0); defaultValue: float(25.0); >; void evaluatePixel() { float2 one = (radius / radius) * (size / size); dst = sampleNearest(src, outCoord()); } } // // ActionScript source code: // package { import flash.display.Shader; import flash.display.Sprite; import flash.events.Event; import flash.net.URLLoader; import flash.net.URLLoaderDataFormat; import flash.net.URLRequest; public class ShaderDataExample extends Sprite { private var loader:URLLoader; public function ShaderDataExample() { loader = new URLLoader(); loader.dataFormat = URLLoaderDataFormat.BINARY; loader.addEventListener(Event.COMPLETE, loadCompleteHandler); loader.load(new URLRequest("donothing.pbj")); } private function loadCompleteHandler(event:Event):void { var shader:Shader = new Shader(); shader.byteCode = loader.data; for (var p:String in shader.data) { trace(p, ":", shader.data[p]); for (var d:String in shader.data[p]) { trace("\t", d, ":", shader.data[p][d]); } } } } }
flash.display.Shader.dataflash.display.ShaderInputflash.display.ShaderParameterShaderData 创建 ShaderData 实例。byteCodeflash.utils:ByteArray着色器的字节代码。 创建 ShaderData 实例。通常,开发人员代码不直接调用 ShaderData 构造函数。使用 Shader 实例的 data 属性来访问包含该实例数据、参数和输入的 ShaderData 实例。 flash.display.Shader.data
ShaderJob ShaderJob 实例用于在独立模式中执行着色器操作。flash.events:EventDispatcher ShaderJob 实例用于在独立模式中执行着色器操作。着色器操作执行并返回其结果数据。由开发人员确定如何使用结果。

在独立模式中使用着色器有两个主要原因:

  • 处理非图像数据:使用 ShaderJob 实例可以控制输入值和着色器结果的使用方式。着色器可以作为二进制数据或数字数据(而非图像数据)返回结果。
  • 后台处理:某些着色器很复杂,并且需要执行很长时间。在应用程序的主要执行操作中执行复杂着色器可能会减慢其他应用程序部件(比如用户交互或更新屏幕操作)的运行速度。使用 ShaderJob 实例,您可以在后台执行着色器。以此方法执行着色器时,着色器操作将独立于应用程序的主执行过程运行。

shader 属性(或构造函数参数)指定 Shader 实例(表示用于操作的着色器)。您使用关联的 ShaderParameter 或 ShaderInput 实例提供着色器所需的任何参数或输入。

在执行 ShaderJob 操作之前,您提供一个向其写入结果的对象,方法是将其设置为 target 属性的值。当着色器操作完成时,结果将写入 target 对象。

要开始后台着色器操作,请调用 start() 方法。当该操作完成时,结果将写入 target 对象。此时 ShaderJob 实例将调度 complete 事件,通知侦听器结果已可用。

要同步执行着色器操作(即不在后台运行),请调用 start() 方法并作为参数传递 true。着色器在主要执行线程中运行,并且您的代码在操作完成之前将暂停。完成时,结果将写入 target 对象。这时,应用程序将继续运行下一行代码。

ShaderShaderInputShaderParameterShaderEventcomplete 当异步执行的 ShaderJob 使用着色器处理完数据时调度。flash.events.ShaderEvent.COMPLETEflash.events.ShaderEvent 当异步执行的 ShaderJob 使用着色器处理完数据时调度。当使用 waitForCompletion 参数的 false 值调用 start() 方法时,将异步执行 ShaderJob 实例。 ShaderJob shaderflash.display:Shadernull要用于操作的着色器。 targetObjectnull在其中写入着色器操作结果的对象。此参数必须为 BitmapData、ByteArray 或 Vector.<Number> 实例时。 widthint0target 中结果数据的宽度(如果为 ByteArray 或 Vector.<Number> 实例)。如有必要,会增大 ByteArray 或 Vector.<Number> 实例的大小,并会覆盖现有数据。 heightint0target 中结果数据的高度(如果为 ByteArray 或 Vector.<Number> 实例)。如有必要,会增大 ByteArray 或 Vector.<Number> 实例的大小,并会覆盖现有数据。 cancel 取消当前运行的着色器操作。 取消当前运行的着色器操作。放弃任何已计算出的结果数据。未调度 complete 事件。

调用 cancel() 多次不会产生额外效果。

start 根据 waitForCompletion 参数的值,以同步模式或异步模式启动着色器操作。target 属性为 null,或者不是 BitmapData、ByteArray 或 Vector.<Number> 实例时。 ArgumentErrorArgumentError当着色器指定了未提供的图像输入时。 ArgumentErrorArgumentError当使用 ByteArray 或 Vector.<Number> 实例作为输入,并且没有为 ShaderInput 指定 widthheight 属性或指定的值与输入对象中的数据量不匹配时。有关详细信息,请参阅 ShaderInput.input 属性。 ArgumentErrorArgumentErrorwaitForCompletionBooleanfalse指定是在后台(默认值为 false)还是在主要程序执行 (true) 中执行着色器。 根据 waitForCompletion 参数的值,以同步模式或异步模式启动着色器操作。

在异步模式(当 waitForCompletionfalse 时,即默认模式)中,ShaderJob 执行在后台运行。着色器操作不影响显示或其他操作的响应能力。在异步模式中,start() 调用将立即返回,并且该程序继续执行下一行代码。当异步着色器操作完成时,结果将可用并调度 complete 事件。

一次只有一个后台 ShaderJob 操作执行。Shader 操作在执行之前将保留在队列中。如果在着色器操作正在执行的过程中调用 start() 方法,则会将附加操作添加到队列的末尾。以后,在轮到它时将会执行。

要以同步模式执行着色器操作,请使用 waitForCompletion 参数(唯一参数)的 true 值调用 start()。您的代码将在调用 start() 时暂停,直到着色器操作完成。这时,结果将可用并将继续执行下一行代码。

调用 start() 方法时,将在内部复制 shader 属性中的 Shader 实例。着色器操作将使用该内部副本,而不是对原始着色器的引用。对着色器进行的任何更改(比如更改参数值、输入或字节代码)不会应用于所复制的用于着色器处理的着色器。要将着色器更改结合到着色器处理中,请调用 cancel() 方法(如有必要),并再次调用 start() 方法以重新开始着色器处理。

当着色器操作正在执行时,target 对象的值不会变化。操作完成(并以异步模式调度了 complete 事件)后,整个结果将一次性写入 target 对象。如果 target 对象是 BitmapData 实例,并且在操作完成之前调用了其 dispose() 方法,则仍然会以异步模式调度 complete 事件。但是,结果数据不会写入 BitmapData 对象,因为该对象处于已处理状态。

completeflash.events:ShaderEvent如果使用值为 truewaitForCompletion 参数调用 start() 方法,则在操作完成时调度。 如果使用值为 true 的 waitForCompletion 参数调用 start() 方法,则在操作完成时调度。
height target 中结果数据的高度(如果为 ByteArray 或 Vector.&lt;Number&gt; 实例。int target 中结果数据的高度(如果为 ByteArray 或 Vector.<Number> 实例)。如有必要,会增大 ByteArray 或 Vector.<Number> 实例的大小,并会覆盖现有数据。 progress 正在运行的着色器的进度。Number 正在运行的着色器的进度。此属性是从 0 到 1 的一个值。0 为初始值(0% 完成)。1 表示着色器已完成其操作。

如果调用了 cancel() 方法,此属性将变为 undefined,并且,在着色器操作再次开始之前,将无法可靠地使用此属性的值。

shader 用于操作的着色器。flash.display:Shader 用于操作的着色器。必须使用 Shader 实例的 data 属性的 ShaderInput 或 ShaderParameter 属性提供着色器所需的任何输入或参数。必须使用与输入对应的 ShaderInput 来提供输入,即使它与 target 对象相同。

要处理包含线性数据数组(而不是图像数据)的 ByteArray,请在 ByteArray 中将对应 ShaderInput 实例的 height 设置为 1,并将 width 设置为 32 位浮点值数字。在这种情况下,必须将着色器中的输入定义为具有 image1 数据类型。

flash.display.ShaderDataflash.display.ShaderInputflash.display.ShaderParameter
target 在其中写入着色器操作结果的对象。Object 在其中写入着色器操作结果的对象。此对象必须为 BitmapData、ByteArray 或 Vector.<Number> 实例时。 width target 中结果数据的宽度(如果为 ByteArray 或 Vector.&lt;Number&gt; 实例。int target 中结果数据的宽度(如果为 ByteArray 或 Vector.<Number> 实例)。如有必要,会增大 ByteArray 或 Vector.<Number> 实例的大小,并会覆盖现有数据。
NativeWindowSystemChrome NativeWindowSystemChrome 类定义一些常量,它们用作用于创建本机窗口的 NativeWindowInitOptions 对象的 systemChrome 属性。定义表示支持的窗口镶边类型的常量。 Object NativeWindowSystemChrome 类定义一些常量,它们用作用于创建本机窗口的 NativeWindowInitOptions 对象的 systemChrome 属性。

系统镶边是指窗口特定于操作系统的元素,比如标题栏、最小化按钮、最大化按钮和关闭按钮。

注意:所使用的系统镶边的类型是在创建窗口时指定的,无法更改。

flash.display.NativeWindowflash.display.NativeWindowInitOptionsALTERNATE 保留供以后使用。alternateString 保留供以后使用。

不使用。

NONE 无系统镶边。noneString 无系统镶边。 STANDARD 主机操作系统的标准镶边。standardString 主机操作系统的标准镶边。

使用此设置可模拟本机操作系统的外观。

IGraphicsStroke 此接口用于定义可用作 flash.display.Graphics 方法和绘图类中的笔触参数的对象。 此接口用于定义可用作 flash.display.Graphics 方法和绘图类中的笔触参数的对象。使用此接口的实现器类来创建和管理笔触属性数据,并将相同的数据重新用于不同的实例。 flash.display.Graphics.drawGraphicsData()SimpleButton 使用 SimpleButton 类,您可以控制 SWF 文件中按钮元件的所有实例。使用 SimpleButton 类,您可以控制 SWF 文件中按钮元件的所有实例。 flash.display:InteractiveObject 使用 SimpleButton 类,您可以控制 SWF 文件中按钮元件的所有实例。

在 Flash Professional 中,您可以在属性检查器中赋予按钮一个实例名称。SimpleButton 实例名称显示在影片浏览器中和“动作”面板的“插入目标路径”对话框中。在 Flash Professional 中创建了按钮的一个实例后,您可以使用 SimpleButton 类的方法和属性,通过 ActionScript 来操作按钮。

在 ActionScript 3.0 中,您使用 new SimpleButton() 构造函数来创建 SimpleButton 实例。

SimpleButton 类继承自 InteractiveObject 类。

下例使用 SimpleButtonExample 类,该类又使用 CustomSimpleButton 类,后者又实例化四个 ButtonDisplayState 对象。最终会创建一个正方形的按钮,通过覆盖 SimpleButton 类的实例属性,其背景色会根据鼠标状态而发生变化。执行下列步骤可完成此操作:
  1. SimpleButtonExample() 构造函数中,创建一个名为 button 的 SimpleButton 类型的新 CustomSimpleButton 对象,该对象调用 CustomSimpleButton 构造函数方法。button 对象将添加到显示列表中。按钮的颜色和大小在以下步骤中确定。
  2. 在 CustomSimpleButton 类中,声明一些实例属性,以后将使用这些属性控制 button 处于不同状态时的大小和背景色(正常状态为黄色,鼠标滑过时为深黄色,鼠标按下时为浅蓝色)。在 button 的所有状态下,可使用 size 属性将正方形的大小设置为 80 像素。
  3. CustomSimpleButton 类的构造函数使用 ButtonDisplayState 类的四个实例设置 downStateoverStateupStatehitTestStateuseHandCursor 属性。
  4. 在 ButtonDisplayState 类中,构造函数设置正方形的大小和背景色的值,并调用 draw() 方法。
  5. draw() 方法使用构造函数中设置的大小和背景色根据按钮的状态重绘正方形。
package { import flash.display.Sprite; public class SimpleButtonExample extends Sprite { public function SimpleButtonExample() { var button:CustomSimpleButton = new CustomSimpleButton(); addChild(button); } } } import flash.display.DisplayObject; import flash.display.Shape; import flash.display.SimpleButton; class CustomSimpleButton extends SimpleButton { private var upColor:uint = 0xFFCC00; private var overColor:uint = 0xCCFF00; private var downColor:uint = 0x00CCFF; private var size:uint = 80; public function CustomSimpleButton() { downState = new ButtonDisplayState(downColor, size); overState = new ButtonDisplayState(overColor, size); upState = new ButtonDisplayState(upColor, size); hitTestState = new ButtonDisplayState(upColor, size * 2); hitTestState.x = -(size / 4); hitTestState.y = hitTestState.x; useHandCursor = true; } } class ButtonDisplayState extends Shape { private var bgColor:uint; private var size:uint; public function ButtonDisplayState(bgColor:uint, size:uint) { this.bgColor = bgColor; this.size = size; draw(); } private function draw():void { graphics.beginFill(bgColor); graphics.drawRect(0, 0, size, size); graphics.endFill(); } }
InteractiveObject 类SimpleButton 创建一个新的 SimpleButton 实例。upStateflash.display:DisplayObjectnullSimpleButton 弹起状态的初始值。 overStateflash.display:DisplayObjectnullSimpleButton 经过状态的初始值。 downStateflash.display:DisplayObjectnullSimpleButton 按下状态的初始值。 hitTestStateflash.display:DisplayObjectnullSimpleButton hitTest 状态的初始值。 创建一个新的 SimpleButton 实例。 创建一个新的 SimpleButton 实例。可以将表示各种按钮状态的任意或全部显示对象都设置为构造函数中的参数。 downState 指定一个用作按钮“按下”状态&#8212;(当用户选择 hitTestState 对象时,按钮所处的状态)的可视对象的显示对象。flash.display:DisplayObject指定用于按钮“按下”状态的 DisplayObject 值。 指定一个用作按钮“按下”状态(当用户选择 hitTestState 对象时,按钮所处的状态)的可视对象的显示对象。 hitTestStateoverStateupStateenabled 布尔值,指定按钮是否处于启用状态。Boolean指定是启用 (true) 还是禁用 (false) 按钮。 布尔值,指定按钮是否处于启用状态。按钮被禁用时(enabled 属性设置为 false),该按钮虽然可见,但不能被单击。默认值为 true。如果想要禁用部分导航按钮,则此属性非常有用;例如,您可能希望禁用当前显示的页面上的某个按钮,以便禁止单击该按钮并禁止重新加载该页面。

注意:要防止按钮上的 mouseClicks 行为,请将 enabledmouseEnabled 属性设置为 false

hitTestState 指定一个用作按钮的点击测试对象的显示对象。flash.display:DisplayObject 指定一个用作按钮的点击测试对象的显示对象。对于基本按钮,将 hitTestState 属性设置为与 overState 属性相同的显示对象。如果未设置 hitTestState 属性,则 SimpleButton 将处于非活动状态 — 不响应用户输入事件。 downStateoverStateupStateoverState 指定一个用作按钮经过状态(当指针位于按钮上方时,按钮所处的状态)的可视对象的显示对象。flash.display:DisplayObject指定用于按钮“经过”状态的 DisplayObject 值。 指定一个用作按钮经过状态(当指针位于按钮上方时,按钮所处的状态)的可视对象的显示对象。 downStatehitTestStateupStatesoundTransform 分配给此按钮的 SoundTransform 对象。flash.media:SoundTransform 分配给此按钮的 SoundTransform 对象。SoundTransform 对象包含用于设置音量、平移、左扬声器指定和右扬声器指定的属性。SoundTransform 对象适用于按钮的所有状态。SoundTransform 对象仅影响嵌入的声音。 flash.media.SoundTransformtrackAsMenu 表示属于 SimpleButton 或 MovieClip 对象的其他显示对象是否可以接收用户输入释放事件。Boolean 表示属于 SimpleButton 或 MovieClip 对象的其他显示对象是否可以接收用户输入释放事件。trackAsMenu 属性允许您创建菜单。可以对任何 SimpleButton 或 MovieClip 对象设置 trackAsMenu 属性。如果不存在 trackAsMenu 属性,则默认行为是 false

您可以随时更改 trackAsMenu 属性;修改后的按钮会立即具有新的行为。

upState 指定一个用作按钮弹起状态(当指针没有位于按钮上方时,按钮所处的状态)的可视对象的显示对象。flash.display:DisplayObject指定用于按钮“弹起”状态的 DisplayObject 值。 指定一个用作按钮弹起状态(当指针没有位于按钮上方时,按钮所处的状态)的可视对象的显示对象。 downStatehitTestStateoverStateuseHandCursor 布尔值,当设置为 true 时,表示指针滑过按钮上方时是否显示手形光标。Boolean设置为 true 时显示手形光标。 布尔值,当设置为 true 时,表示指针滑过按钮上方时是否显示手形光标。如果此属性设置为 false,则将改用箭头指针。默认值为 true

可以随时更改 useHandCursor 属性;修改后的按钮会立即使用新的光标行为。

TriangleCulling 定义剔除算法的代码,这些算法确定在绘制三角形路径时不呈示哪些三角形。Object 定义剔除算法的代码,这些算法确定在绘制三角形路径时不呈示哪些三角形。

术语 POSITIVENEGATIVE 指三角形的法线在 z 轴两侧的符号。法线是一个 3D 矢量,与三角形的表面垂直。

顶点 0、1 和 2 按顺时针顺序排列的三角形的法线值为正。也就是说,其法线指向正 z 轴方向,远离当前视图点。如果使用了 TriangleCulling.POSITIVE 算法,则不呈现法线为正的三角形。这里的另一个术语是背面剔除。

顶点按逆时针顺序排列的三角形的法线值为负。也就是说,其法线指向负 z 轴方向,朝向当前视图点。如果使用了 TriangleCulling.NEGATIVE 算法,则不呈现法线为负的三角形。

flash.display.Graphics.drawTriangles()flash.display.GraphicsTrianglePath3D 矢量简介3D 背面剔除NEGATIVE 指定剔除朝向当前视图点的所有三角形。negativeString 指定剔除朝向当前视图点的所有三角形。 NONE 指定不进行剔除。noneString 指定不进行剔除。将呈现路径中的所有三角形。 POSITIVE 指定剔除背向当前视图点的所有三角形。positiveString 指定剔除背向当前视图点的所有三角形。这也称为背面剔除。
NativeWindow NativeWindow 类提供一个接口,用于创建和控制本机桌面窗口。flash.events:EventDispatcher NativeWindow 类提供一个接口,用于创建和控制本机桌面窗口。

AIR 配置文件支持:所有桌面操作系统均支持此功能,但移动设备或用于电视的 AIR 设备不支持此功能。您可以使用 NativeWindow.isSupported 属性测试桌面设备上是否支持运行时。有关在多个配置文件之间支持 API 的详细信息,请参阅 AIR 配置文件支持

对 NativeWindow 实例的引用由 window 构造函数返回。也可以使用该窗口的舞台上的任何显示对象的 stage.nativeWindow 属性来访问对 NativeWindow 实例的引用。

var window:NativeWindow = displayObject.stage.nativeWindow;

NativeWindow 实例的属性只能由应用程序内容访问。如果非应用程序内容尝试访问 NativeWindow 对象,则将引发安全错误。

可以使用 Stage 对象的 DisplayObjectContainer 方法(如 addChild())将内容添加到窗口中。

不能将 Flex 组件直接添加到 NativeWindow 实例的显示列表中。而应使用 Flex mx:WindowedApplication 和 mx:Window 组件创建窗口并将其他 Flex 组件添加为上述对象的子项。可以将基于 Flex 的 SWF 内容直接添加到 NativeWindow 窗口,只要该 SWF 文件已加载到自己的应用程序域中并且是应用程序内容。

要创建根 HTML 窗口以显示 HTML 内容,使用 HTMLLoader.createRootWindow() 创建该窗口通常更容易些。以此方式创建的窗口将会自动添加 HTMLLoader 对象。(也可以从 JavaScript 中使用 JavaScript window.open() 函数。不过,此方法对窗口外观和行为的控制能力较差。)

下面对 NativeWindow 对象的操作是异步执行的:close()maximize()minimize()restore()bounds 更改。应用程序可以通过侦听相应的事件来检测这些操作何时完成。

如果 NativeApplication.autoExit 属性为默认值 true,则当应用程序的最后一个窗口关闭时,应用程序也将关闭(并且所有 close 事件处理函数均已返回)。如果 autoExitfalse,则必须调用 NativeApplication.nativeApplication.exit() 才能终止应用程序。

在调用 window 构造函数之后和调用 close() 之前,不会对 NativeWindow 对象进行垃圾回收。应用程序负责关闭其自己的窗口。

flash.display.Stage.nativeWindowflash.display.NativeWindowInitOptionsflash.desktop.NativeApplicationflash.system.ApplicationDomainflash.html.HTMLLoader.createRootWindow()deactivate 在取消激活窗口后由此 NativeWindow 对象调度。flash.events.Event.DEACTIVATEflash.events.Event 在取消激活窗口后由此 NativeWindow 对象调度。 activate 在激活窗口后由此 NativeWindow 对象调度。flash.events.Event.ACTIVATEflash.events.Event 在激活窗口后由此 NativeWindow 对象调度。 close 在关闭窗口后由此 NativeWindow 对象调度。flash.events.Event.CLOSEflash.events.Event 在关闭窗口后由此 NativeWindow 对象调度。 closing 在关闭窗口的前一刻由此 NativeWindow 对象调度。flash.events.Event.CLOSINGflash.events.Event 在关闭窗口的前一刻由此 NativeWindow 对象调度。可以取消此事件以避免关闭窗口。 displayStateChange 在窗口的 displayState 属性更改后由此 NativeWindow 对象调度。flash.events.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGEflash.events.NativeWindowDisplayStateEvent 在窗口的 displayState 属性更改后由此 NativeWindow 对象调度。

不要调整窗口大小或更改其在 displayStateChange 事件处理程序中的显示状态。

displayStateChanging 在窗口更改其显示状态的前一刻由此 NativeWindow 对象调度。flash.events.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGINGflash.events.NativeWindowDisplayStateEvent 在窗口更改其显示状态的前一刻由此 NativeWindow 对象调度。可以取消此事件以避免更改。 下面的示例演示如何取消 displayStateChanging 事件。 function displayStateChanging_handler(displayStateEvent:NativeWindowDisplayStateEvent):void { //shouldStopStateChange is an application-defined Boolean indicating //that display state changes should be canceled if (displayStateEvent.type == NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING && shouldStopStateChange) { displayStateEvent.preventDefault(); } } resize 在调整窗口大小后由此 NativeWindow 对象调度。flash.events.NativeWindowBoundsEvent.RESIZEflash.events.NativeWindowBoundsEvent 在调整窗口大小后由此 NativeWindow 对象调度。每当窗口大小(widthheight 属性)更改时调度 resize 事件,窗口大小的更改可能是系统控制的窗口大小调整操作的结果:最小化、最大化或还原窗口、或通过设置 widthheightbounds 属性更改窗口大小。NativeWindow 的 resize 事件是在系统控制的调整大小循环中调度的。相反,Stage 对象的 resize 事件是在舞台准备好绘图时调度的。 舞台调整大小事件resizing 在桌面上调整窗口大小的前一刻由此 NativeWindow 对象调度。flash.events.NativeWindowBoundsEvent.RESIZINGflash.events.NativeWindowBoundsEvent 在桌面上调整窗口大小的前一刻由此 NativeWindow 对象调度。可以取消此事件以避免或修改调整大小。 下面的示例演示如何取消 resizing 事件。 function boundsChanging_handler(boundsEvent:NativeWindowBoundsEvent):void { //shouldStopResize is an application-defined Boolean indicating //that resize operations should be canceled if (boundsEvent.type == NativeWindowBoundsEvent.RESIZING && shouldStopResize) { boundsEvent.preventDefault(); } } move 在桌面上移动窗口后由此 NativeWindow 对象调度。flash.events.NativeWindowBoundsEvent.MOVEflash.events.NativeWindowBoundsEvent 在桌面上移动窗口后由此 NativeWindow 对象调度。

每当窗口原点(xy 属性)更改时调度 move 事件,窗口原点的更改可能是系统控制的窗口移动操作的结果:最小化、最大化或还原窗口、或通过设置 xybounds 属性更改窗口位置。

注意:在 NativeWindow 对象的 movingmove 事件的处理函数中,避免可能会同时打开操作系统对话框的动作。例如,如果两个处理函数都引发错误,则可能发生这种情况。如果真的发生这种情况,则打开的第二个对话框将不会注册鼠标单击,必须使用键盘才能取消。

moving 在桌面上移动窗口的前一刻由此 NativeWindow 对象调度。flash.events.NativeWindowBoundsEvent.MOVINGflash.events.NativeWindowBoundsEvent 在桌面上移动窗口的前一刻由此 NativeWindow 对象调度。可以取消此事件以避免或修改移动。

注意:在 NativeWindow 对象的 movingmove 事件的处理函数中,避免可能会同时打开操作系统对话框的动作。例如,如果两个处理函数都引发错误,则可能发生这种情况。如果真的发生这种情况,则打开的第二个对话框将不会注册鼠标单击,必须使用键盘才能取消。

NativeWindow 创建新的 NativeWindow 实例和相应的操作系统窗口。如果 initOptions 参数无效。 IllegalOperationErrorflash.errors:IllegalOperationErrorinitOptionsflash.display:NativeWindowInitOptions一个包含此窗口初始化属性的对象。 创建新的 NativeWindow 实例和相应的操作系统窗口。

创建窗口后,不能更改 initOptions 参数中定义的设置。无效的 initOptions 设置将导致引发非法操作错误。在当前系统中有效但不可用的设置不会引发异常。如果需要,可以使用静态 NativeWindow 成员(比如 systemMaxSize)来检测特定于当前操作系统的窗口功能。

默认窗口大小由操作系统决定,并且窗口是在不可见状态下创建。要防止将窗口更改为可见,请不要将窗口的 visible 属性更改为 true 或者在窗口更改完成前调用 activate()

下面的示例将创建并激活一个新的 NativeWindow 实例: import flash.display.NativeWindowInitOptions; import flash.display.NativeWindowSystemChrome; import flash.display.NativeWindowType; import flash.display.NativeWindow; import flash.display.StageAlign; import flash.display.StageScaleMode; import flash.geom.Rectangle; var windowOptions:NativeWindowInitOptions = new NativeWindowInitOptions(); windowOptions.systemChrome = NativeWindowSystemChrome.STANDARD; windowOptions.type = NativeWindowType.NORMAL; var newWindow:NativeWindow = new NativeWindow(windowOptions); newWindow.stage.scaleMode = StageScaleMode.NO_SCALE; newWindow.stage.align = StageAlign.TOP_LEFT; newWindow.bounds = new Rectangle(100, 100, 800, 800); newWindow.activate();
flash.display.NativeWindowInitOptionsflash.html.HTMLLoader.createRootWindow()
activate 激活此窗口。 激活此窗口。

激活一个窗口将会:

  • 使该窗口可见
  • 将该窗口置于前面
  • 为该窗口提供键盘和鼠标焦点

在 Linux 上,activate() 是一种异步操作。

在所有平台上,NativeWindow 对象都会调度 activate 事件。

下面的示例演示如何激活窗口。

使用对窗口舞台上的显示对象的引用:

displayObject.stage.nativeWindow.activate();
使用对 NativeWindow 类的实例的引用: windowObj.activate(); 从窗口中呈现的 HTML 页中的 JavaScript(此处的 window 是全局 JavaScript window 对象): window.nativeWindow.activate();
visibleorderToFront()
close 关闭此窗口。 关闭此窗口。

关闭操作一旦完成即调度 close 事件。将不调度 closing 事件。如果应该允许取消关闭操作,请调度一个 closing 事件并检查在调用 close() 方法之前是否有任何注册的侦听器取消了默认行为。

关闭一个窗口时,它所拥有的任何窗口也将被关闭。拥有的窗口不调度 closing 事件。

如果未在其他位置引用当前处于此窗口中的显示对象实例,则会将这些实例作为垃圾回收,除非它们位于由 AIR 创建的初始应用程序窗口中。要允许将初始窗口中的显示对象作为垃圾进行回收,请将它们从窗口舞台上删除。

关闭后的 NativeWindow 对象仍然是有效的引用,但访问大多数属性和方法都将引发非法操作错误。

关闭的窗口无法重新打开。如果窗口已经关闭,则不执行任何动作,也不调度任何事件。

注意:要在不关闭窗口的情况下隐藏一个窗口,请将该窗口的 visible 属性设置为 false

下面的示例演示如何关闭窗口:

通过引用 NativeWindow 实例 (windowObj):

windowObj.close();
使用对窗口舞台上的显示对象的引用: displayObj.stage.nativeWindow.close(); 从 HTMLLoader 对象(或 HTML 根窗口)中运行的 JavaScript 例程: window.close(); //overriddable in HTMLHost 或: window.nativeWindow.close(); //not overriddable 下面的示例演示如何允许取消关闭操作(其中 windowObj 是要关闭的 NativeWindow 实例): public function closeCommand():Boolean{ var closeEvent:Event = new Event(Event.CLOSING,true,true); windowObj.dispatchEvent(closeEvent); if(!closeEvent.isDefaultPrevented()){ windowObj.close(); return true; } else { return false; } } 下面的示例演示如何从 HTMLLoader 对象(或 HTML 根窗口)中运行的 JavaScript 例程关闭窗口,同时允许取消该操作: <script src="AIRAliases.js" type="text/javascript"></script> <script type="text/javascript"> var dirtyData = false; function closeWindow(){ var closingEvent = new air.Event(air.Event.CLOSING,true,true); window.nativeWindow.dispatchEvent(closingEvent); if(!closingEvent.isDefaultPrevented()){ window.nativeWindow.close(); //or use: window.close(); return true; } else { return false; } } function onClosing(event){ if(dirtyData){ event.preventDefault(); //Save data... } } window.nativeWindow.addEventListener(air.Event.CLOSING,onClosing); </script>
flash.display.NativeWindow.closedflash.html.HTMLLoaderflash.html.HTMLHost
globalToScreen 将像素坐标中相对于窗口舞台原点(就显示列表而言为全局点)转换为虚拟桌面上的点。指定的相对于桌面的全局点。 flash.geom:PointglobalPointflash.geom:Point要转换为屏幕上的点的舞台上的点。 将像素坐标中相对于窗口舞台原点(就显示列表而言为全局点)转换为虚拟桌面上的点。

虚拟桌面坐标相对于主监视器的左上角。

flash.display.Screen
listOwnedWindows 返回此窗口所拥有的 NativeWindow 对象的列表。包含此实例拥有的零个或更多 NativeWindow 对象的 Vector.<NativeWindow> 对象。 返回此窗口所拥有的 NativeWindow 对象的列表。

您不能通过在返回的矢量中添加或删除对象来更改 NativeWindows 的所有权。创建窗口后,不能更改窗口所有权。

flash.display.NativeWindowInitOptions.owner
maximize 使此窗口最大化。如果在此窗口关闭后才调用此方法。 IllegalOperationErrorflash.errors:IllegalOperationError 使此窗口最大化。

调用 maximize() 将调度 displayStateChange 事件,如果适用,还将调度 moveresize 事件。系统镶边将调度 displayStateChanging 事件,当用户启动最大化命令时可取消该事件,如果需要,您的最大化逻辑必须实现此行为。

maximize() 方法异步执行。要检测状态更改是否完成,请侦听 displayStateChange 事件。如果窗口已经最大化,则不执行任何动作,也不调度任何事件。

操作系统行为注意事项:

  • 在某些操作系统(如 Mac OS X)中,将窗口最大化并不会同时阻止调整大小,调用 maximize() 将缩放窗口以填充屏幕,但并不阻止随后的调整窗口大小。调整经过缩放的窗口的大小也会还原显示状态。
  • 在某些操作系统(如 Mac OS X)中以及在某些 Linux 窗口管理器中,将窗口最大化并不会将窗口扩大至超出 maxSize 属性中指定的宽度和高度。在其他操作系统中,即使屏幕大于 maxSize,也将扩大窗口以填充屏幕。
  • 某些 Linux 窗口管理器不允许将实用程序窗口最大化。
下面的示例演示如何允许取消最大化操作: public function maximizeWindow(nativeWin:NativeWindow):Boolean{ if(nativeWin.displayState != NativeWindowDisplayState.MAXIMIZED){ var beforeState:String = nativeWin.displayState; var afterState:String = NativeWindowDisplayState.MAXIMIZED; var displayStateEvent:NativeWindowDisplayStateEvent = new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING, true,true,beforeState,afterState); nativeWin.dispatchEvent(displayStateEvent); if(!displayStateEvent.isDefaultPrevented()){ nativeWin.maximize(); return true; } else { return false; } } return false; } 下面的示例演示如何允许在窗口(或 HTML 窗口)上的 HTMLLoader 对象中运行的 JavaScript 例程中取消最大化操作: function maximizeWindow(nativeWin){ if(nativeWin.displayState != air.NativeWindowDisplayState.MAXIMIZED){ var beforeState = nativeWin.displayState; var afterState = air.NativeWindowDisplayState.MAXIMIZED; var displayStateEvent = new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING, true,true,beforeState,afterState); nativeWin.dispatchEvent(displayStateEvent); if(!displayStateEvent.isDefaultPrevented()){ nativeWin.maximize(); return true; } else { return false; } } return false; }
flash.display.NativeWindowDisplayStateflash.events.NativeWindowDisplayStateEvent
minimize 使此窗口最小化。如果在此窗口关闭后才调用此方法。 IllegalOperationErrorflash.errors:IllegalOperationError 使此窗口最小化。

调用 minimize() 将调度 displayStateChange 事件,如果适用,还将调度 move 和 resize 事件。系统镶边将调度 displayStateChanging 事件,当用户启动最小化命令时可取消该事件,而直接调用 minimize() 不能调度该事件。如果需要,您的最小化逻辑可以实现此行为。

minimize() 方法异步执行。要检测状态更改是否完成,请侦听 displayStateChange 事件,所有平台上都会调度该事件。如果窗口已经最小化,则不执行任何动作,也不调度任何事件。

此窗口拥有的任何窗口在该窗口最小化时隐藏起来。拥有的窗口不调度 displayStateChangingdisplayStateChange 事件。

注意:

  • 在 Windows 中,最小化不可见窗口 (visible == false) 将显示窗口。
  • 某些 Linux 窗口管理器不允许将实用程序窗口最小化。
下面的示例演示如何通过调度 displayStateChanging 事件来允许取消对 minimize() 的调用: public function minimizeWindow(nativeWin:NativeWindow):Boolean{ if(nativeWin.displayState != NativeWindowDisplayState.MINIMIZED){ var beforeState:String = nativeWin.displayState; var afterState:String = NativeWindowDisplayState.MINIMIZED; var displayStateEvent:NativeWindowDisplayStateEvent = new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING, true,true,beforeState,afterState); nativeWin.dispatchEvent(displayStateEvent); if(!displayStateEvent.isDefaultPrevented()){ nativeWin.minimize(); return true; } else { return false; } } return false; } 下面示例演示如何允许在 HTMLLoader 对象(或 HTML 窗口)中运行的 JavaScript 中取消对 minimize() 的调用: function minimizeWindow(){ if(window.nativeWindow.displayState != air.NativeWindowDisplayState.MINIMIZED){ var beforeState = window.nativeWindow.displayState; var afterState = air.NativeWindowDisplayState.MINIMIZED; var displayStateEvent = new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING, true,true,beforeState,afterState); window.nativeWindow.dispatchEvent(displayStateEvent); if(!displayStateEvent.isDefaultPrevented()){ window.nativeWindow.minimize(); return true; } else { return false; } } return false; }
flash.display.NativeWindowDisplayStateflash.events.NativeWindowDisplayStateEvent
notifyUser 通过操作系统触发可视提示:发生了需要关注的事件。typeString一个表示通知紧急程度的字符串。 通过操作系统触发可视提示:发生了需要关注的事件。

NativeWindow.supportsNotificationtrue 时,可视提示将遵循本机系统的操作系统约定。例如在 Windows 中,任务栏图标将闪烁。

type 参数确定提示的强度。用作允许值的常量在 NotificationType 类中定义,这些常量可以是:

  • NotificationType.INFORMATIONAL
  • NotificationType.CRITICAL

为信息性通知提供的提示持续时间很短,而为关键通知提供的提示将持续到用户激活此窗口为止。并非所有 Linux 窗口管理器都支持两种通知级别。对于此类窗口管理器,无论指定哪个选项,notifyUser() 的效果都将相同。

注意:允许在 NativeWindow.supportsNotificationfalse 时调用 notifyUser(),但不执行任何操作。

orderInBackOf 将此窗口放在紧靠指定窗口后面。如果此窗口成功地放到了后面,则为 true;如果此窗口不可见或最小化,则为 falseBooleanwindowflash.display:NativeWindow一个应用程序窗口。 将此窗口放在紧靠指定窗口后面。

不要激活此窗口或应用程序或获取其焦点。最小化或隐藏的 (visiblefalse) 窗口无法重新排序。

拥有的窗口从不会移动到所有者的后面。如果此窗口有所有者,则该所有者及其所拥有的其他窗口也会排在目标后面。如果目标窗口有所有者,则此窗口排在目标的所有者的后面。

某些 Linux 窗口管理器不允许将实用程序窗口排在常规窗口之后。

下面的示例显示如何通过引用 NativeWindow 实例将一个窗口移动到紧靠另一个窗口下面: windowBehind.orderInBackOf(windowFront); 使用对窗口舞台上的显示对象的引用: displayObjBehind.stage.nativeWindow.orderInBackOf(displayObjectFront.stage.nativeWindow); 从使用对两个 JavaScript 窗口对象的引用的 HTMLLoader 对象(或 HTML 根窗口)中运行的 JavaScript 例程中: jsWindowObjBehind.nativeWindow.orderInBackOf(jsWindowObjFront.nativeWindow);
orderInFrontOf 将此窗口放在紧靠指定窗口前面。如果此窗口成功地放到了前面,则为 true;如果此窗口不可见或最小化,则为 falseBooleanwindowflash.display:NativeWindow一个应用程序窗口。 将此窗口放在紧靠指定窗口前面。

不要激活此窗口或应用程序或获取其焦点。最小化或隐藏的 (visiblefalse) 窗口无法重新排序。

窗口从不会移到属于它的窗口的前面。如果此窗口有所有者,则该所有者及其所拥有的其他窗口也会排在目标前面。如果目标窗口有所有者,则此窗口也会排在与目标拥有同一所有者的任何其他窗口的前面。

某些 Linux 窗口管理器不允许将常规窗口排在实用程序窗口之前。

下面的示例显示如何通过引用 NativeWindow 实例将一个窗口移动到紧靠另一个窗口上面: windowFront.orderInFrontOf(windowBehind); 使用对窗口舞台上的显示对象的引用: displayObjFront.stage.nativeWindow.orderInFrontOf(displayObjectBehind.stage.nativeWindow); 从使用对两个 JavaScript 窗口对象的引用的 HTMLLoader 对象(或 HTML 根窗口)中运行的 JavaScript 例程中: jsWindowObjFront.nativeWindow.orderInFrontOf(jsWindowObjBehind.nativeWindow);
orderToBack 将此窗口放在任何其他可见窗口后面。如果此窗口成功地放到了后面,则为 true;如果此窗口不可见或最小化,则为 falseBoolean 将此窗口放在任何其他可见窗口后面。

不要激活此窗口或应用程序或获取其焦点。最小化或隐藏的 (visiblefalse) 窗口无法重新排序。

如果 alwaysInFronttrue,则调用此方法不会将此窗口置于任何 alwaysInFront 设置为 false 的窗口的后面。

拥有的窗口从不会移动到所有者的后面。如果此窗口有所有者,则该所有者及其所拥有的其他窗口也会排在窗口显示列表的底部。此窗口将移到同一窗口拥有的任何其他窗口的后面。如果此窗口拥有其他窗口,则那些窗口也移到后面,保持当前它们相互之间的顺序。

某些 Linux 窗口管理器不允许将实用程序窗口排在常规窗口之后。

下面的示例显示如何将某个窗口放在应用程序中所有其他窗口(使用同样的 alwaysInFront 设置)的后面: windowObj.orderToBack(); 使用对窗口舞台上的显示对象的引用: displayObj.stage.nativeWindow.orderToBack(); 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: window.nativeWindow.orderToBack();
orderToFront 将此窗口放在任何其他可见窗口前面。如果此窗口成功地放到了前面,则为 true;如果此窗口不可见或最小化,则为 falseBoolean 将此窗口放在任何其他可见窗口前面。

不要激活此窗口或应用程序或获取其焦点。最小化或隐藏的 (visiblefalse) 窗口无法重新排序。

如果 alwaysInFrontfalse,则调用此方法不会将此窗口置于任何已将 alwaysInFront 设置为 true 的窗口的前面。

窗口从不会移到属于它的窗口的前面。如果此窗口拥有其他窗口,则那些窗口也移到前面,保持当前它们相互之间的顺序。如果此窗口有所有者,则该所有者及其所拥有的其他窗口也会排在窗口显示列表的前面。此窗口移到具有同一所有者的其他窗口的前面。

某些 Linux 窗口管理器不允许将常规窗口排在实用程序窗口之前。

下面的示例显示如何将某个窗口放在应用程序中所有其他窗口(使用同样的 alwaysInFront 设置)的前面: windowObj.orderToFront(); 使用对窗口舞台上的显示对象的引用: displayObj.stage.nativeWindow.orderToFront(); 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: window.nativeWindow.orderToFront();
restore 从最小化或最大化状态还原此窗口。如果在已关闭此窗口后调用此方法。 IllegalOperationErrorflash.errors:IllegalOperationError 从最小化或最大化状态还原此窗口。

调用 restore() 将调度 displayStateChange 事件,如果适用,还将调度 moveresize 事件。系统镶边将调度 displayStateChanging 事件,当用户启动还原命令时可取消该事件,如果需要,您的还原逻辑必须实现此行为。

如果窗口已经处于 NativeWindowDisplayState.NORMAL 状态,则不执行任何动作,也不调度任何事件。

要检测状态更改是否完成,请侦听 displayStateChange 事件,所有平台上都会调度该事件。

下面的示例演示如何允许取消还原操作: public function restoreWindow(nativeWin:NativeWindow):Boolean{ if(nativeWin.displayState != NativeWindowDisplayState.NORMAL){ var beforeState:String = nativeWin.displayState; var afterState:String = NativeWindowDisplayState.NORMAL; var displayStateChangingEvent:NativeWindowDisplayStateEvent = new NativeWindowDisplayStateEvent(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING, true,true,beforeState,afterState); nativeWin.dispatchEvent(displayStateChangingEvent); if(!displayStateChangingEvent.isDefaultPrevented()){ nativeWin.restore(); return true; } else { return false; } } return false; } 下面的示例演示如何允许在窗口(或 HTML 窗口)上的 HTMLLoader 对象中运行的 JavaScript 例程中取消还原操作: function restoreWindow(nativeWin){ if(window.nativeWindow.displayState != air.NativeWindowDisplayState.NORMAL){ var beforeState = window.nativeWindow.displayState; var afterState = air.NativeWindowDisplayState.NORMAL; var displayStateEvent = new air.NativeWindowDisplayStateEvent(air.NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGING, true,true,beforeState,afterState); window.nativeWindow.dispatchEvent(displayStateEvent); if(!displayStateEvent.isDefaultPrevented()){ window.nativeWindow.restore(); return true; } else { return false; } } return false; }
flash.display.NativeWindowDisplayStateflash.events.NativeWindowDisplayStateEvent
startMove 启动此窗口的系统控制移动。如果在已关闭此窗口后调用此方法。 IllegalOperationErrorflash.errors:IllegalOperationError如果成功启动了移动,则为 true;如果最大化了窗口,则为 falseBoolean 启动此窗口的系统控制移动。

在从 mouseDown 事件调用时,此方法开始一个由鼠标驱动的移动序列,该序列将持续到发生 mouseUp 事件为止。

在从其他代码调用时,此方法开始一个由键盘或鼠标驱动的移动序列,该序列与操作系统的默认序列一致。

在移动序列执行期间,随着窗口原点的移动,将调度一系列事件。对于每次增量移动,首先调度一个 moving 事件,然后,如果未取消该 moving 事件,则将更新窗口位置并调度一个 move 事件。如果取消了 moving 事件,则移动序列将立即终止。

下面的示例演示如何为响应 mouseDown 事件来移动窗口: var initOpts:NativeWindowInitOptions = new NativeWindowInitOptions(); var win:NativeWindow = new NativeWindow(initOpts); win.activate(); win.stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler); function mouseDownHandler(event:MouseEvent):void { win.startMove(); }
startResize 启动此窗口的系统控制调整大小操作。如果在已关闭此窗口后调用此方法。 IllegalOperationErrorflash.errors:IllegalOperationError如果成功启动了调整大小,则为 true;如果最大化了窗口,则为 falseBooleanedgeOrCornerStringBRNativeWindowResize 类中的一个常量,用于指定要调整此窗口的哪个边或角的大小。以下是有效值:

垂直对齐方式水平对齐方式NativeWindowResize.TOP顶对齐居中对齐NativeWindowResize.BOTTOM底对齐居中对齐NativeWindowResize.LEFT居中对齐左对齐NativeWindowResize.RIGHT居中对齐右对齐NativeWindowResize.TOP_LEFT顶对齐左对齐NativeWindowResize.TOP_RIGHT顶对齐右对齐NativeWindowResize.BOTTOM_LEFT底对齐左对齐NativeWindowResize.BOTTOM_RIGHT底对齐右对齐NativeWindowResize.NONE----

启动此窗口的系统控制调整大小操作。

在从 mouseDown 事件处理函数调用时,此方法开始一个由鼠标驱动的调整大小序列,该序列将持续到发生 mouseUp 事件为止。

在从其他代码调用时,此方法开始一个由键盘或鼠标驱动的调整大小序列,该序列与操作系统的默认序列一致。

在调整大小序列执行期间,随着窗口尺寸的更改,将调度一系列事件。对于每次增量更改,首先调度一个 resizing 事件,然后,如果未取消该 resizing 事件,则将更新窗口尺寸并调度一个 resize 事件。如果取消了 resizing 事件,则该序列将立即终止。

下面示例演示如何为响应 mouseDown 事件来调整窗口大小: stage.addEventListener(MouseEvent.MOUSE_DOWN, onResizeCommand); function onResizeCommand(event:MouseEvent):void { var win:NativeWindow = event.target.nativeWindow; var resizeFrom:String = ""; if (event.stageY < win.height * .33) { resizeFrom = NativeWindowResize.TOP; } else if (event.stageY > win.height * .66) { resizeFrom = NativeWindowResize.BOTTOM; } if (event.stageX < win.width * .33) { resizeFrom += NativeWindowResize.LEFT; } else if (event.stageX > win.width * .66) { resizeFrom += NativeWindowResize.RIGHT; } win.startResize(resizeFrom); }
flash.display.NativeWindowResize
active 表示此窗口是否为活动应用程序窗口。Boolean 表示此窗口是否为活动应用程序窗口。

使用 activate() 方法可使窗口处于活动状态。

flash.display.NativeWindow.activate()flash.desktop.NativeApplication.activate()
alwaysInFront 指定此窗口是否始终显示在其他窗口前面(包括其他应用程序的窗口)。Boolean 指定此窗口是否始终显示在其他窗口前面(包括其他应用程序的窗口)。

沿系统深度顺序有两组窗口。位于 alwaysInFront 组中的窗口始终显示在所有其他窗口的前面。同一组内的窗口之间的深度顺序按常规确定。换句话说,激活一个窗口会将该窗口置于其组内的其他窗口前面。

alwaysInFrontfalse 更改为 true 会将该窗口置于所有其他窗口的前面。将该属性从 true 更改为 false 会将该窗口置于“alwaysInFront”窗口的后面,但仍位于其他窗口前面。将该属性设置为其当前值不会更改该窗口的深度顺序。设置具有所有者的窗口的 alwaysInFront 属性没有效果。

应该尽量少将 alwaysInFront 设置为 true,因为使用此设置的窗口将出现在其他应用程序的窗口之前,即使其他应用程序处于活动状态时也是如此。

操作系统行为注意事项:

  • 某些 Linux 窗口管理器不会在全屏窗口的前面显示 alwaysInFront 属性设置为 的窗口。
  • 在 Mac® OS X 中,如果窗口舞台的 displayState 属性为 fullScreenfullScreenInteractive,将 alwaysInFront 设置为 true 将不起作用。
下列示例强制将某个窗口显示在其他所有窗口(这些窗口不受类似的强制)前面: windowObj.alwaysInFront = true; 使用对窗口舞台上的显示对象的引用: displayObject.stage.nativeWindow.alwaysInFront=true; 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: window.nativeWindow.alwaysInFront = true;
bounds 此窗口的大小和位置。flash.geom:Rectangle如果矩形为空或包含无效值。 ArgumentErrorArgumentError如果在关闭此窗口后访问 bounds 属性。 IllegalOperationErrorflash.errors:IllegalOperationError 此窗口的大小和位置。

窗口尺寸包括任何系统镶边。窗口舞台的尺寸等于窗口尺寸减去任何系统镶边的大小。更改窗口的宽度和高度将更改舞台的 stageWidthstageHeight。反之亦然:更改舞台尺寸也将更改窗口大小。

在根 HTML 窗口中,outerWidthouterHeight 属性等同于窗口的 heightwidth 属性。innerWidthinnerHeight 属性等于 stage.stageWidthstage.stageHeight 属性减去该窗口显示的任何滚动条的粗细。

每当此窗口的宽度或高度更改时即调度 resize 事件。同样,每当此窗口的原点 (x,y) 更改时即调度 move 事件。在 Mac OS 和 Windows 上,直接设置 bounds 属性不会调度 movingresizing 事件。但在 Linux 上,设置 bounds 属性时,NativeWindow 会调度 movingresizing 事件。

设置窗口的 bounds 属性等效于设置其 xywidthheight 属性。同样,设置任何单个尺寸等效于设置 bounds 属性。使用 bounds 属性同时设置所有尺寸时,调度的事件会较少。

无法保证设置各个尺寸的顺序。在不允许窗口扩大到桌面区域之外的 Linux 窗口管理器中,即使应用所有属性更改的最终效果会产生合法的窗口,也可能会阻止对单个属性的更改。

如果指定的宽度或高度小于允许的最小值或大于允许的最大值,则会将窗口宽度或高度设置为最接近的合法大小。决定宽度和高度的最小值和最大值的因素包括以下这些:

  • NativeWindow 对象的 minSize 属性和 maxSize 属性
  • 操作系统的最小限值和最大限值,即 NativeWindow.systemMinSizeNativeWindow.systemMaxSize 的值。
  • 在 Adobe AIR 中,窗口的最大宽度和高度均为 4095 像素。(在 AIR 1.5 及早期版本中,窗口宽度和高度的最大值都是 2880 像素。)
  • 任何显示的系统镶边需要的最小宽度和高度。

当窗口的位置或尺寸更改时,像素值将舍入为最近的整数。

下面的示例使用对 NativeWindow 对象的引用设置窗口的范围: windowObj.bounds = new Rectangle(200, 200, 1000, 800); 使用对窗口舞台上的显示对象的引用: displayObject.stage.nativeWindow.bounds = new Rectangle(20, 20, 800, 600); 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: window.nativeWindow.bounds = new air.Rectangle(20, 20, 800, 600);
flash.display.NativeWindowInitOptions.resizable
closed 表示此窗口是否已关闭。Boolean 表示此窗口是否已关闭。

对已关闭的窗口访问以下属性将引发非法操作错误:

  • title
  • bounds
  • xywidthheight
  • displayState
  • visible

同样,对已关闭的窗口调用以下方法也将引发非法操作错误:

  • minimize()
  • maximize()
  • restore()
  • startResize()
  • startMove()
下列示例演示如何访问窗口的 closed 属性: var isWindowClosed:Boolean = windowObj.closed; 使用对窗口舞台上的显示对象的引用: var isWindowClosed:Boolean = displayObject.stage.nativeWindow.closed; 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: var isWindowClosed = window.nativeWindow.closed;
displayState 此窗口的显示状态。String如果在关闭此窗口后访问 displayState 属性。 IllegalOperationErrorflash.errors:IllegalOperationError 此窗口的显示状态。

用作可能值的常量在 NativeWindowDisplayState 类中定义:

  • NativeWindowDisplayState.NORMAL
  • NativeWindowDisplayState.MINIMIZED
  • NativeWindowDisplayState.MAXIMIZED
下面的示例显示如何在给定一个对窗口对象的引用的情况下获取当前窗口的显示状态: var state:String = windowObj.displayState;
flash.display.NativeWindowDisplayState
height 此窗口的高度(以像素为单位)。Number如果设置的值为 null 或无效。 ArgumentErrorArgumentError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 此窗口的高度(以像素为单位)。

窗口的尺寸包括显示的任何系统窗口镶边。可以从 Stage.stageHeight 属性获取窗口内部可用的显示区域高度。

更改窗口的 height 属性等效于通过 bounds 属性更改高度。

如果指定高度小于允许的最小值或大于允许的最大值,则会将窗口高度设置为最接近的合法大小。决定高度的最小值和最大值的因素包括以下这些:

  • NativeWindow 对象的 minSize.x 和属性 maxSize.x 属性
  • 操作系统的最小限值和最大限值,即 NativeWindow.systemMinSize.xNativeWindow.systemMaxSize.x 的值。
  • 在 Adobe AIR 中,窗口高度的最大值是 4095 像素(在 AIR 1.5 及早期版本中是 2880 像素)。

在 Linux 上,设置 height 属性是一种异步操作。

要检测高度更改是否完成,请侦听 resize 事件,所有平台上都会调度该事件。

当窗口的高度更改时,像素值将舍入为最近的整数。

flash.display.NativeWindow.boundsflash.display.Stage.stageHeight
isSupported 表示客户端系统上是否支持本机窗口。Boolean 表示客户端系统上是否支持本机窗口。 maxSize 此窗口的最大大小。flash.geom:Point如果分配的大小不在操作系统的最小和最大窗口大小范围之内。 IllegalOperationErrorflash.errors:IllegalOperationError如果因为内容的当前权限而禁止该大小。 SecurityErrorSecurityError如果该大小为 null 或包含无效值。 ArgumentErrorArgumentError如果在关闭此窗口后访问 maxSize 属性。 IllegalOperationErrorflash.errors:IllegalOperationError 此窗口的最大大小。

大小限制指定为 Point 对象的坐标。点的 x 属性对应于窗口宽度,y 属性对应于窗口高度。

对通过 ActionScript 代码和操作系统调用的窗口大小调整操作强制实施 maxSize 限制。

如果窗口的当前范围大于新的最大大小,则设置 maxSize 将更改窗口的范围。

如果指定的宽度或高度大于允许的最大值,则会将窗口的宽度或高度设置为最接近的合法大小。决定宽度和高度的最小值和最大值的因素包括以下这些:

  • 操作系统的最大限值,即 NativeWindow.systemMaxSize 的值。
  • 在 Adobe AIR 中,窗口的最大宽度和高度均为 4095 像素。(在 AIR 1.5 及早期版本中,窗口宽度和高度的最大值都是 2880 像素。)

注意:在某些操作系统(如 Mac OS X)中,即使最大化后的窗口将小于操作系统屏幕,将窗口最大化也只能使窗口扩大至 maxSize 值。该窗口将仍然处于最大化显示状态。

下面的示例显示如何为窗口设置允许的最大大小。 windowObj.maxSize = new Point(1040,920); 使用对窗口舞台上的显示对象的引用: displayObject.stage.nativeWindow.maxSize = new Point(800,600); 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: window.nativeWindow.maxSize = new air.Point(960,960);
flash.display.NativeWindow.systemMinSizeflash.display.NativeWindow.systemMaxSize
maximizable 报告用于创建此窗口的可最大化设置。Boolean在没有足够权限的情况下尝试设置为 false 时。 SecurityErrorSecurityError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 报告用于创建此窗口的可最大化设置。

创建窗口后,不能更改 maximizable 设置。

注意:即使在 maximizable 属性设置为 false 时,某些 Linux 窗口管理器也允许用户最大化窗口。

flash.display.NativeWindowInitOptions.maximizable
menu 此窗口的本机菜单。flash.display:NativeMenu 此窗口的本机菜单。

在将 NativeMenu 对象分配给窗口的 menu 属性时,如果 NativeWindow.supportsMenutrue,将为窗口显示一个本机菜单,除非该窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE

注意:允许在 NativeWindow.supportsMenufalse 或窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE 时为窗口分配菜单,但不执行任何操作。务必使用 NativeWindow.supportsMenu 属性来确定操作系统是否支持窗口菜单。使用其他方法(如 Capabilities.os)确定支持情况可能导致编程错误(如果没有考虑到某些可行的目标操作系统)。

flash.display.NativeWindow.supportsMenu
minSize 此窗口的最小大小。flash.geom:Point如果分配的大小不在操作系统的最小和最大窗口大小范围之内。 IllegalOperationErrorflash.errors:IllegalOperationError如果因为内容的当前权限而禁止该大小。 SecurityErrorSecurityError如果该大小为 null 或包含无效值。 ArgumentErrorArgumentError如果在关闭此窗口后访问 minSize 属性。 IllegalOperationErrorflash.errors:IllegalOperationError 此窗口的最小大小。

大小限制指定为 Point 对象的坐标。点的 x 属性对应于窗口宽度,y 属性对应于窗口高度。

如果窗口的当前范围小于新的最小大小,则设置 minSize 将更改窗口的范围。

对通过 ActionScript 代码和操作系统调用的窗口大小调整操作强制实施 minSize 限制。

注意:显示的任何系统镶边的宽度和高度可能使得无法将窗口设置得与指定的最小大小一样小。

下面的示例演示如何为窗口设置允许的最小大小: windowObj.minSize = new Point(200,80); 使用对窗口舞台上的显示对象的引用: displayObject.stage.nativeWindow.minSize = new Point(120,60); 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: window.nativeWindow.minSize = new air.Point(80,60);
flash.display.NativeWindow.systemMinSizeflash.display.NativeWindow.systemMaxSize
minimizable 报告用于创建此窗口的可最小化设置。Boolean在没有足够权限的情况下尝试设置为 false 时。 SecurityErrorSecurityError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 报告用于创建此窗口的可最小化设置。

创建窗口后,不能更改 minimizable 设置。

注意:即使在 minimizable 属性设置为 false 时,某些 Linux 窗口管理器也允许用户最小化窗口。

flash.display.NativeWindowInitOptions.minimizable
owner 拥有此窗口的 NativeWindow 对象。flash.display:NativeWindow 拥有此窗口的 NativeWindow 对象。

窗口所有权是在创建窗口时建立的,不能更改。要创建具有所有者的窗口,请将拥有的 NativeWindow 对象设置为用于创建所拥有窗口的 NativeWindowInitOptions 对象的 owner 属性。

注意:在 Linux 上,当所有者处于全屏模式时,有些窗口管理器不在拥有窗口前面显示所拥有的窗口。

flash.display.NativeWindowInitOptions.owner
resizable 报告用于创建此窗口的可调整大小设置。Boolean在没有足够权限的情况下尝试设置为 false 时。 SecurityErrorSecurityError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 报告用于创建此窗口的可调整大小设置。

创建窗口后,不能更改 resizable 设置。

flash.display.NativeWindowInitOptions.resizable
stage 此窗口的 Stage 对象。flash.display:Stage 此窗口的 Stage 对象。Stage 对象是基于 ActionScript 3.0 的 SWF 内容中使用的显示列表体系结构中的根对象。

舞台是窗口显示列表的根。通过将可视显示对象添加到舞台或添加到此舞台的显示列表中已有的另一个对象来将可视显示对象添加到窗口。舞台尺寸是在窗口使用系统镶边时窗口客户端区域的尺寸。如果不使用系统镶边,舞台尺寸等于窗口尺寸。

下面的示例显示如何为 NativeWindow 实例设置舞台属性: import flash.display.StageAlign; windowObj.stage.align = StageAlign.TOP_LEFT;
flash.display.Stage
supportsMenu 表示 AIR 是否在当前计算机系统上支持本机窗口菜单。Boolean 表示 AIR 是否在当前计算机系统上支持本机窗口菜单。

如果 NativeWindow.supportsMenutrue,则在将 NativeMenu 对象分配给窗口的 menu 属性时,将为该窗口显示本机菜单(除非该窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE)。务必使用 NativeWindow.supportsMenu 属性来确定操作系统是否支持本机窗口菜单。使用其他方法(如 Capabilities.os)确定支持情况可能导致编程错误(如果没有考虑到某些可行的目标操作系统)。

注意:允许在 NativeWindow.supportsMenufalse 或窗口的 systemChrome 属性为 NativeWindowSystemChrome.NONE 时为窗口分配菜单,但不执行任何操作。

flash.display.NativeMenuflash.desktop.NativeApplication.supportsMenu
supportsNotification 表示 AIR 是否在当前计算机系统上支持窗口通知提示。Boolean 表示 AIR 是否在当前计算机系统上支持窗口通知提示。

如果 NativeWindow.supportsNotificationtrue,则调用该窗口的 notifyUser() 方法将向用户显示一个可视提示,提示用户发生了需要关注的事件。此可视提示将遵循本机系统的操作系统约定。例如在 Windows®中,任务栏图标将闪烁。

注意:允许在 NativeWindow.supportsNotificationfalse 时调用 notifyUser(),但不执行任何操作。

flash.display.NativeWindow.notifyUser()
supportsTransparency 表示 AIR 是否支持具有透明像素的本机窗口。Boolean 表示 AIR 是否支持具有透明像素的本机窗口。

NativeWindow.supportsTransparencytrue,若窗口 transparent 属性设为 true,将保留本机窗口的像素的透明度。若 NativeWindow.supportsTransparencyfalse,则无论窗口 transparent 属性为何值,所有像素的不透明度都将设为 1。当 NativeWindow.supportsTransparencyfalse 时,完全透明的像素将呈现为黑色。务必使用 NativeWindow.supportsTransparency 属性来确定操作系统是否支持透明度。使用其他方法(如 Capabilities.os)确定支持情况可能导致编程错误(如果没有考虑到某些可行的目标操作系统)。

注意:根据为操作系统设置的用户首选项的不同,在应用程序运行过程中,此属性的值可能会发生变化。

flash.display.NativeWindow.transparent
systemChrome 报告用于创建此窗口的系统镶边设置。String在没有足够权限的情况下尝试设置为 false 时。 SecurityErrorSecurityError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 报告用于创建此窗口的系统镶边设置。

NativeWindow.systemChrome 返回的值将是在 NativeWindowSystemChrome 类中定义的常量之一。

创建窗口后,不能更改系统镶边设置。

以下示例说明了如何获得窗口的系统镶边类型: var sysChromeType:String = windowObj.systemChrome; 使用对窗口舞台上的显示对象的引用: var sysChromeType:String = displayObject.stage.nativeWindow.systemChrome; 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: var sysChromeType = window.nativeWindow.systemChrome; 下面的示例显示如何通过创建一个新窗口并将所有子级显示对象移动到该新窗口来更改系统外观镶边和透明度设置: import flash.display.NativeWindow; import flash.display.NativeWindowSystemChrome; import flash.display.NativeWindowInitOptions; public function deChromeWindow(oldWindow:NativeWindow):NativeWindow{ if(oldWindow.systemChrome != NativeWindowSystemChrome.NONE){ var newOptions:NativeWindowInitOptions = new NativeWindowInitOptions(); newOptions.systemChrome = NativeWindowSystemChrome.NONE; newOptions.transparent = true; var newWindow:NativeWindow = new NativeWindow(newOptions); newWindow.stage.stageWidth = oldWindow.stage.stageWidth; newWindow.stage.stageHeight = oldWindow.stage.stageHeight; newWindow.stage.align = oldWindow.stage.align; newWindow.stage.scaleMode = oldWindow.stage.scaleMode; for(var i:int = 0; i < oldWindow.stage.numChildren; i++){ newWindow.stage.addChild(oldWindow.stage.getChildAt(i)); } newWindow.activate(); oldWindow.close(); return newWindow; } return oldWindow; }
flash.display.NativeWindowSystemChromeflash.display.NativeWindowInitOptions.systemChrome
systemMaxSize 操作系统允许的最大窗口大小。flash.geom:Point 操作系统允许的最大窗口大小。

大小限制指定为 Point 对象的坐标。点的 x 属性对应于窗口宽度,y 属性对应于窗口高度。

除了操作系统大小限制,AIR 将窗口大小的最大值限制为 4095 x 4095 像素(在 AIR 1.5 及早期版本中限制为 2880 x 2880 像素)。此外,应用程序可以使用 NativeWindow 对象的 maxSize 属性来设置限值。

systemMinSize 操作系统允许的最小窗口大小。flash.geom:Point 操作系统允许的最小窗口大小。

大小限制指定为 Point 对象的坐标。点的 x 属性对应于窗口宽度,y 属性对应于窗口高度。

title 窗口标题。String如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 窗口标题。

该标题将出现在该窗口的系统镶边中(如果显示系统镶边),也会出现在与系统相关的其他位置(如任务栏)。

下面的示例设置窗口对象的标题: windowObj.title = "Window Title";
transparent 报告用于创建此窗口的透明度设置。Boolean在没有足够权限的情况下尝试设置为 false 时。 SecurityErrorSecurityError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 报告用于创建此窗口的透明度设置。

创建窗口后,不能更改 transparent 属性。透明度影响窗口的视觉外观和鼠标行为。在 Windows 和 Mac OS X 中,当像素的 Alpha 值低于特定的阈值(大约在 .06 和 .01 之间变化,具体取决于操作系统)时,窗口将无法捕获鼠标事件。在 Linux 中,窗口将捕获完全透明区域上方的鼠标事件,从而阻止用户访问桌面上的其他窗口和项目。

注意:并不总是支持窗口透明度。如果用户的操作系统配置不提供透明度,则创建窗口时将不含透明度。原本要透明的区域将混合为黑色。请使用 NativeWindow.supportsTransparency 属性确定是否支持窗口透明度。

flash.display.NativeWindowInitOptions.transparent
type 报告用于创建此窗口的窗口类型设置。String在没有足够权限的情况下尝试设置为 false 时。 SecurityErrorSecurityError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 报告用于创建此窗口的窗口 type 设置。

NativeWindow.type 返回的值将是在 NativeWindowType 类中定义的常量之一。

创建窗口后,不能更改 type 设置。

flash.display.NativeWindowTypeflash.display.NativeWindowInitOptions.type
visible 指定此窗口是否可见。Boolean在没有足够权限的情况下尝试设置为 false 时。 SecurityErrorSecurityError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 指定此窗口是否可见。

不可见窗口不显示在桌面上,但所有窗口属性和方法都是有效的。

在默认情况下,visible 设置为 false。要显示窗口,请将 visible 设置为 true 或调用 NativeWindow.activate()

如果此窗口有所有者,该所有者窗口的可见状态确定是否显示此窗口。如果不显示所有者窗口,则不显示任何拥有的窗口,即使其 visible 属性为 true

注意:在 Mac OS X 中,对一个最小化的窗口设置 visible=false 不会从停靠处删除该窗口图标。如果用户随后单击该停靠图标,该窗口将返回可见状态并显示在桌面上。

下列示例演示如何访问窗口的 visible 属性: windowObj.visible = true; 使用对窗口舞台上的显示对象的引用: displayObj.stage.nativeWindow.visible = true; 从窗口(或 HTML 根窗口)的 HTMLLoader 对象中运行的 JavaScript 例程: window.nativeWindow.visible = true;
activate()
width 此窗口的宽度(以像素为单位)。Number如果设置的值为 null 或无效。 ArgumentErrorArgumentError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 此窗口的宽度(以像素为单位)。

为本机窗口报告的尺寸包括显示的任何系统窗口镶边。可以从 Stage.stageWidth 属性获取窗口内部可用的显示区域宽度。

更改窗口的 width 属性等效于通过 bounds 属性更改宽度。

如果指定宽度小于允许的最小值或大于允许的最大值,则会将窗口宽度设置为最接近的合法大小。决定宽度的最小值和最大值的因素包括以下这些:

  • NativeWindow 对象的 minSize.y 属性和 maxSize.y 属性
  • 操作系统的最小限值和最大限值,即 NativeWindow.systemMinSize.yNativeWindow.systemMaxSize.y 的值。
  • 在 Adobe AIR 中,窗口宽度的最大值是 4095 像素(在 AIR 1.5 及早期版本中是 2880 像素)。

在 Linux 上,设置 width 属性是一种异步操作。

要检测宽度更改是否完成,请侦听 resize 事件,所有平台上都会调度该事件。

当窗口的宽度更改时,像素值将舍入为最近的整数。

flash.display.NativeWindow.boundsflash.display.Stage.stageWidth
x 此窗口的左上角相对于操作系统桌面原点的水平轴坐标。Number如果设置的值为 null 或无效。 ArgumentErrorArgumentError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 此窗口的左上角相对于操作系统桌面原点的水平轴坐标。

在安装了多个显示器的系统中,x 可能为负。如果保存该值可能是为了将窗口重新定位在上次的位置,则应始终验证在还原位置时是否将窗口放置到可用的位置。更改屏幕分辨率或显示器布置可能会导致窗口被置于屏幕以外。使用 Screen 类可获取有关桌面几何形状的信息。

更改窗口的 x 属性等效于通过 bounds 属性更改位置。

在 Linux 上,设置 x 属性是一种异步操作。

要检测位置更改是否完成,请侦听 move 事件,所有平台上都会调度该事件。

当窗口的 x 坐标更改时,像素值将舍入为最近的整数。

flash.display.NativeWindow.boundsflash.display.Screen
y 此窗口的左上角相对于操作系统桌面左上角的垂直轴坐标。Number如果设置的值为 null 或无效。 ArgumentErrorArgumentError如果在关闭此窗口后访问该属性。 IllegalOperationErrorflash.errors:IllegalOperationError 此窗口的左上角相对于操作系统桌面左上角的垂直轴坐标。

在安装了多个显示器的系统中,y 可能为负。如果保存该值可能是为了将窗口重新定位在上次的位置,则应始终验证在还原位置时是否将窗口放置到可用的位置。更改屏幕分辨率或显示器布置可能会导致窗口被置于屏幕以外。使用 Screen 类可获取有关桌面几何形状的信息。

更改窗口的 y 属性等效于通过 bounds 属性更改位置。

在 Linux 上,设置 y 属性是一种异步操作。

要检测位置更改是否完成,请侦听 move 事件,所有平台上都会调度该事件。

当窗口的 y 坐标更改时,像素值将舍入为最近的整数。

flash.display.NativeWindow.boundsflash.display.Screen
Stage Stage 类代表主绘图区。flash.display:DisplayObjectContainer Stage 类代表主绘图区。

对于在浏览器中(使用 Flash® Player)运行的 SWF 内容,Stage 表示显示 Flash 内容的整个区域。对于在桌面操作系统上的 AIR 中运行的内容,每个 NativeWindow 对象都有一个对应的 Stage 对象。

无法以全局方式访问 Stage 对象。而是需要利用 DisplayObject 实例的 stage 属性进行访问。

Stage 类具有多个始祖类 -- DisplayObjectContainer、InteractiveObject、DisplayObject 和 EventDispatcher,属性和方法便是从这些类继承而来的。从这些继承的许多属性和方法不适用于 Stage 对象,或在调用 Stage 类时需要安全检查。需要安全检查的属性和方法被记录为 Stage 类的一部分。

此外,下面的继承属性不适用于 Stage 对象。如果尝试设置这些属性,便会引发 IllegalOperationError。这些属性通常可以读取,但是由于无法进行设置,所以它们将始终包含默认值。

  • accessibilityProperties
  • alpha
  • blendMode
  • cacheAsBitmap
  • contextMenu
  • filters
  • focusRect
  • loaderInfo
  • mask
  • mouseEnabled
  • name
  • opaqueBackground
  • rotation
  • scale9Grid
  • scaleX
  • scaleY
  • scrollRect
  • tabEnabled
  • tabIndex
  • transform
  • visible
  • x
  • y

一些您可能期望成为 Stage 类的一部分的事件(例如 enterFrameexitFrameframeConstructedrender)不能是 Stage 事件,因为不能保证在使用这些事件的每种情况下对 Stage 对象的引用都会存在。由于这些事件无法由 Stage 对象进行调度,而是由每个 DisplayObject 实例调度,因此这就意味着您可以向任何 DisplayObject 实例添加事件侦听器来侦听这些事件。这些事件(DisplayObject 类的一部分)称为广播事件,以使其与针对特定 DisplayObject 实例的事件区分开。其他两个广播事件 activatedeactivate 属于 DisplayObject 的超类 EventDispatcher。activatedeactivate 事件的行为与 DisplayObject 广播事件类似,不过,这两个事件不仅可由所有 DisplayObject 实例进行调度,还可由所有 EventDispatcher 实例和其他的 EventDispatcher 子类实例进行调度。有关广播事件的详细信息,请参阅 DisplayObject 类。

下例使用 StageExample 类在激活舞台或调整舞台大小时调度事件。执行下列步骤可完成此操作:
  1. 无论 Flash Player 窗口的大小如何,类的构造函数都会首先将 Flash 应用程序设置为固定大小,然后使用 activateHandler()resizeHandler() 方法添加两个事件侦听器。
  2. 用鼠标左键单击后,便可运行 activateHandler() 方法。
  3. 当调整舞台大小时,便可运行 resizeHandler() 方法。
package { import flash.display.Sprite; import flash.display.StageAlign; import flash.display.StageScaleMode; import flash.events.Event; public class StageExample extends Sprite { public function StageExample() { stage.scaleMode = StageScaleMode.NO_SCALE; stage.align = StageAlign.TOP_LEFT; stage.addEventListener(Event.ACTIVATE, activateHandler); stage.addEventListener(Event.RESIZE, resizeHandler); } private function activateHandler(event:Event):void { trace("activateHandler: " + event); } private function resizeHandler(event:Event):void { trace("resizeHandler: " + event); trace("stageWidth: " + stage.stageWidth + " stageHeight: " + stage.stageHeight); } } }
flash.display.DisplayObjectstageVideoAvailability 当 stageVideos 属性更改时,由 Stage 对象调度。flash.events.StageVideoAvailabilityEvent.STAGE_VIDEO_AVAILABILITYflash.events.StageVideoAvailabilityEvent 当 stageVideos 属性更改时,由 Stage 对象调度。 orientationChange 当舞台方向更改时,由 Stage 对象调度。flash.events.StageOrientationEvent.ORIENTATION_CHANGEflash.events.StageOrientationEvent 当舞台方向更改时,由 Stage 对象调度。

当用户旋转设备、打开滑出式键盘或调用 setAspectRatio() 时,可能发生方向更改。

注意:如果 autoOrients 属性为 false,则在设备旋转时舞台方向不会更改。因此,仅在 autoOrientstrue 时,才会为设备方向调度 StageOrientationEvents。

orientationChanging 舞台方向开始变化后,由 Stage 对象调度。flash.events.StageOrientationEvent.ORIENTATION_CHANGINGflash.events.StageOrientationEvent 舞台方向开始变化后,由 Stage 对象调度。

重要:在 Android 设备上不调度 orientationChanging 事件。

注意:如果 autoOrients 属性为 false,则在设备旋转时舞台方向不会更改。因此,仅在 autoOrientstrue 时,才会为设备方向调度 StageOrientationEvents。

fullScreen 当 Stage 对象进入或离开全屏模式时调度。flash.events.FullScreenEvent.FULL_SCREENflash.events.FullScreenEvent 当 Stage 对象进入或离开全屏模式时调度。可以通过 ActionScript、或用户调用键盘快捷键或者当前焦点离开全屏窗口来启动全屏模式的更改。 resize 当 Stage 对象的 scaleMode 属性设置为 StageScaleMode.NO_SCALE 且 SWF 文件大小经过重新调整时进行调度。flash.events.Event.RESIZEflash.events.Event 当 Stage 对象的 scaleMode 属性设置为 StageScaleMode.NO_SCALE 且 SWF 文件大小经过重新调整时进行调度。 mouseLeave 当指针移出舞台区域时由 Stage 对象调度。flash.events.Event.MOUSE_LEAVEflash.events.Event 当指针移出舞台区域时由 Stage 对象调度。如果按下鼠标按钮,则不调度此事件。 addChildAt 将一个 DisplayObject 子实例添加到该 DisplayObjectContainer 实例中。调用 Stage 对象的 addChildAt() 方法会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一个安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityErrorchild 参数中传递的 DisplayObject 实例。 flash.display:DisplayObjectchildflash.display:DisplayObject要作为该 DisplayObjectContainer 实例的子项添加的 DisplayObject 实例。 indexint添加该子项的索引位置。如果指定当前占用的索引位置,则该位置以及所有更高位置上的子对象会在子级列表中上移一个位置。 将一个 DisplayObject 子实例添加到该 DisplayObjectContainer 实例中。该子项将被添加到指定的索引位置。索引为 0 表示该 DisplayObjectContainer 对象的显示列表的后(底)部。

例如,下例在索引位置 0、2、1 处分别显示 a、b、c 三个显示对象:

如果添加一个已将其它显示对象容器作为父项的子对象,则会从其它显示对象容器的子列表中删除该对象。

addChild 将一个 DisplayObject 子实例添加到该 DisplayObjectContainer 实例中。调用 Stage 对象的 addChild() 方法会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一个安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityErrorchild 参数中传递的 DisplayObject 实例。 flash.display:DisplayObjectchildflash.display:DisplayObject要作为该 DisplayObjectContainer 实例的子项添加的 DisplayObject 实例。 将一个 DisplayObject 子实例添加到该 DisplayObjectContainer 实例中。子项将被添加到该 DisplayObjectContainer 实例中其他所有子项的前(上)面。(要将某子项添加到特定索引位置,请使用 addChildAt() 方法。)

如果添加一个已将其它显示对象容器作为父项的子对象,则会从其它显示对象容器的子列表中删除该对象。

注意:stage.addChild() 命令可导致与发布的 SWF 文件有关的问题,包括安全性问题和与其他加载的 SWF 文件的冲突。无论将多少 SWF 文件加载到运行时中,Flash 运行时实例中都只有一个 Stage。因此,通常无论如何也不应将对象直接添加到 Stage。Stage 应该包含的唯一对象是根对象。创建 DisplayObjectContainer 以包含显示列表上的所有项目。如果需要,随后将 DisplayObjectContainer 实例添加到 Stage。

addEventListener 使用 EventDispatcher 对象注册事件侦听器对象,以使侦听器能够接收事件通知。调用 Stage 对象的 addEventListener 方法会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一个安全沙箱而引发异常。为避免出现这种情况,Stage 所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityErrortypeString事件的类型。 listenerFunction处理事件的侦听器函数。此函数必须接受 Event 对象作为其唯一的参数,并且不能返回任何结果,如下面的示例所示: function(evt:Event):void

函数可以有任何名称。

useCaptureBooleanfalse 确定侦听器是运行于捕获阶段还是运行于目标和冒泡阶段。如果将 useCapture 设置为 true,则侦听器只在捕获阶段处理事件,而不在目标或冒泡阶段处理事件。如果 useCapturefalse,则侦听器只在目标或冒泡阶段处理事件。要在所有三个阶段都侦听事件,请调用 addEventListener 两次:一次将 useCapture 设置为 true,一次将 useCapture 设置为 false priorityint0事件侦听器的优先级。优先级由一个带符号的 32 位整数指定。数字越大,优先级越高。优先级为 n 的所有侦听器会在优先级为 n -1 的侦听器之前得到处理。如果两个或更多个侦听器共享相同的优先级,则按照它们的添加顺序进行处理。默认优先级为 0。 useWeakReferenceBooleanfalse确定对侦听器的引用是强引用,还是弱引用。强引用(默认值)可防止您的侦听器被当作垃圾回收。弱引用则没有此作用。

类级别成员函数不属于垃圾回收的对象,因此可以对类级别成员函数将 useWeakReference 设置为 true 而不会使它们受垃圾回收的影响。如果对作为嵌套内部函数的侦听器将 useWeakReference 设置为 true,则该函数将作为垃圾回收并且不再是永久函数。如果创建对该内部函数的引用(将该函数保存到另一个变量中),则该函数将不作为垃圾回收并仍将保持永久。

使用 EventDispatcher 对象注册事件侦听器对象,以使侦听器能够接收事件通知。可以为特定类型的事件、阶段和优先级在显示列表中的所有节点上注册事件侦听器。

成功注册一个事件侦听器后,无法通过额外调用 addEventListener() 来更改其优先级。要更改侦听器的优先级,必须首先调用 removeListener()。然后,可以使用新的优先级再次注册该侦听器。

请记住,注册该侦听器后,如果继续调用具有不同 typeuseCapture 值的 addEventListener(),则会创建单独的侦听器注册。例如,如果首先注册 useCapture 设置为 true 的侦听器,则该侦听器只在捕获阶段进行侦听。如果使用同一个侦听器对象再次调用 addEventListener(),并将 useCapture 设置为 false,那么便会拥有两个单独的侦听器:一个在捕获阶段进行侦听,另一个在目标和冒泡阶段进行侦听。

不能只为目标阶段或冒泡阶段注册事件侦听器。这些阶段在注册期间是成对出现的,因为冒泡阶段只适用于目标节点的始祖。

如果不再需要某个事件侦听器,可调用 removeEventListener() 删除它,否则会产生内存问题。事件侦听器不会自动从内存中删除,因为只要调度对象存在,垃圾回收器就不会删除侦听器(除非 useWeakReference 参数设置为 true)。

复制 EventDispatcher 实例时并不复制其中附加的事件侦听器。(如果新近创建的节点需要一个事件侦听器,必须在创建该节点后附加该侦听器。)但是,如果移动 EventDispatcher 实例,则其中附加的事件侦听器也会随之移动。

如果在正在处理事件的节点上注册事件侦听器,则不会在当前阶段触发事件侦听器,但会在事件流的稍后阶段触发,如冒泡阶段。

如果从正在处理事件的节点中删除事件侦听器,则该事件侦听器仍由当前操作触发。删除事件侦听器后,决不会再次调用该事件侦听器(除非再次注册以备将来处理)。

assignFocus 将键盘焦点设置为由 objectToFocus 指定的交互式对象,焦点方向由 direction 参数指定。如果无法将焦点设置到目标或 direction 不是有效的类型。 ErrorErrorobjectToFocusflash.display:InteractiveObject要设置焦点的对象;如果要从舞台上任何元素中清除焦点,则为 nulldirectionStringobjectToFocus 设置焦点所使用的方向。有效值枚举为 FocusDirection 类中的常量。 将键盘焦点分配给一个交互式对象并指定焦点的来自方向。 将键盘焦点设置为由 objectToFocus 指定的交互式对象,焦点方向由 direction 参数指定。

焦点方向的概念必须由应用程序(或应用程序框架)来定义。虽然可以使用其他可用的属性来确定排序原则,但交互式对象并不存在固有的焦点排序。例如,您可以按照交互式对象在舞台上或在显示列表中的位置对这些对象进行排序。调用 assignFocus() 等效于设置 Stage.focus 属性,但它还具有另外的功能,可以表示设置焦点时所使用的方向。

在接收焦点时,objectToFocus 将调度 focusIn 事件。FocusEvent 对象的 direction 属性将报告 direction 参数的设置。

如果将 HTMLLoader 对象赋予 objectToFocus 参数,则 HTMLLoader 对象会根据 direction 参数值在 HTML DOM 中选择适当的可获得焦点对象。如果该参数值为 FocusDirection.BOTTOM,则 HTML DOM 中位于读取顺序末尾的可获得焦点对象将获得焦点。如果该参数值为 FocusDirection.TOP,则 HTML DOM 中位于读取顺序开头的可获得焦点对象将获得焦点。如果该参数值为 NONE,则 HTMLLoader 对象会在不更改其当前已设置焦点元素的情况下获得焦点。

flash.display.Stage.focusflash.display.FocusDirectionflash.events.FocusEvent
dispatchEvent 将事件调度到事件流中。调用 Stage 对象的 dispatchEvent() 方法会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一个安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError如果成功调度了事件,则值为 true。值 false 表示失败或对事件调用了 preventDefault()Booleaneventflash.events:Event调度到事件流中的 Event 对象。如果正在重新调度事件,则会自动创建此事件的一个克隆。在调度了事件后,其 target 属性将无法更改,因此您必须创建此事件的一个新副本以能够重新调度。 将事件调度到事件流中。事件目标是对其调用 dispatchEvent() 方法的 EventDispatcher 对象。 getChildAtflash.display:DisplayObjectindexintgetChildIndexintchildflash.display:DisplayObjecthasEventListener 检查 EventDispatcher 对象是否为特定事件类型注册了任何侦听器。调用 Stage 对象的 hasEventListener() 方法会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一个安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError如果指定类型的侦听器已注册,则值为 true;否则,值为 falseBooleantypeString事件的类型。 检查 EventDispatcher 对象是否为特定事件类型注册了任何侦听器。这样,您就可以确定 EventDispatcher 对象在事件流层次结构中的哪个位置改变了对事件类型的处理。要确定特定事件类型是否确实触发了事件侦听器,请使用 willTrigger()

hasEventListener()willTrigger() 的区别是:hasEventListener() 只检查它所属的对象,而 willTrigger() 检查整个事件流以查找由 type 参数指定的事件。

当从 LoaderInfo 对象调用 hasEventListener() 时,只考虑调用方可以访问的侦听器。

invalidate 调用 invalidate() 方法,以便在出现下一个 Flash 运行时必须呈现显示列表的时机(例如,当播放头前进到一个新帧)时,向其发送提醒显示对象的信号。在下一次 Flash 运行时必须刷新舞台时,向其发送更新显示对象属性的信号。 调用 invalidate() 方法,以便在出现下一个 Flash 运行时必须呈现显示列表的时机(例如,当播放头前进到一个新帧)时,向其发送提醒显示对象的信号。调用 invalidate() 方法后,在显示列表下次呈现时,Flash 运行时会向每个已注册侦听 render 事件的显示对象发送一个 render 事件。每次您希望 Flash 运行时发送 render 事件时,都必须调用 invalidate() 方法。

render 事件使您可以在显示列表实际呈现前对其进行更改。因此,您就可以将对显示列表的更新尽可能地向后延迟。这样可以通过消除不必要的屏幕更新来提高性能。

只将 render 事件调度到与调用 stage.invalidate() 方法的代码位于同一安全域中的显示对象,或位于通过 Security.allowDomain() 方法被授予权限的安全域中的显示对象。

flash.events.Event.RENDER
isFocusInaccessible 确定 Stage.focus 属性是否因某些安全原因返回 null。true(如果具有焦点的对象属于 SWF 文件无权访问的安全沙箱)。 Boolean确定 Stage.focus 属性是否因某些安全原因返回 null 确定 Stage.focus 属性是否因某些安全原因返回 null。也就是说,如果具有焦点的对象属于 SWF 文件无权访问的安全沙箱,那么 isFocusInaccessible 就会返回 trueremoveChildAt 从 DisplayObjectContainer 的子列表中指定的 index 位置删除子 DisplayObject。调用 Stage 对象的 removeChildAt() 方法会因任何调用方没有与要删除的对象位于同一个安全沙箱而引发异常。为避免出现这种情况,该对象的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError已删除的 DisplayObject 实例。 flash.display:DisplayObjectindexint要删除的 DisplayObject 的子索引。 从 DisplayObjectContainer 的子列表中指定的 index 位置删除子 DisplayObject。将已删除子项的 parent 属性设置为 null;如果没有对该子项的任何其他引用,则将该对象作为垃圾回收。DisplayObjectContainer 中该子项之上的任何显示对象的索引位置都减去 1。

垃圾回收器重新分配未使用的内存空间。当在某处变量或对象不再被主动地引用或存储时,如果不存在对该变量或对象的任何其它引用,则垃圾回收器将清理并擦除其过去占用的内存空间。

removeChildflash.display:DisplayObjectchildflash.display:DisplayObjectsetAspectRatio 将舞台设置成使用指定长宽比的方向。作为 newAspectRatio 参数传递的值无效。此值必须与 StageAspectRatio 类中定义的常量之一匹配。 ArgumentErrorArgumentErrornewAspectRatioString所需长宽比的类型代码(StageAspectRatio.PORTRAITStageAspectRatio.LANDSCAPE)。 将舞台设置成使用指定长宽比的方向。

如果由于方法调用导致舞台方向更改,Stage 对象将调度 orientationChange 事件。

要检查是否支持设备方向,请检查 Stage.supportsOrientantionChange 属性的值。

AIR 配置文件支持:移动设备支持此功能,但桌面操作系统或用于电视的 AIR 设备不支持此功能。您可以使用 Stage.supportsOrientantionChange 属性在运行时测试是否受支持。有关在多个配置文件之间支持 API 的详细信息,请参阅 AIR 配置文件支持

StageAspectRatiosupportsOrientationChange
setChildIndex 更改现有子项在显示对象容器中的位置。调用 Stage 对象的 setChildIndex() 方法会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一个安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityErrorchildflash.display:DisplayObject要为其更改索引编号的 DisplayObject 子实例。 indexint生成的 child 显示对象的索引编号。 更改现有子项在显示对象容器中的位置。这会影响子对象的分层。例如,下例在索引位置 0、1、2 处分别显示 a、b、c 三个显示对象:

在使用 setChildIndex() 方法并指定一个已经占用的索引位置时,唯一发生更改的位置是显示对象先前的位置和新位置之间的位置。所有其他位置将保持不变。如果将一个子项移动到比它当前的索引更低的索引处,则这两个索引之间的所有子项的索引引用都将增加 1。如果将一个子项移动到比它当前的索引更高的索引处,则这两个索引之间的所有子项的索引引用都将减小 1。例如,如果上例中的显示对象容器名为 container,则可以通过调用以下代码来交换带有 a 和 b 标记的显示对象的位置:

container.setChildIndex(container.getChildAt(1), 0);

该代码产生以下对象排列:

setOrientation 将舞台设置成指定方向。作为 newOrientation 参数传递的值无效。此值必须与 StageOriention 类中定义的一个常量匹配,但 StageOrientation.UNKNOWN 常量除外。 ArgumentErrorArgumentErrornewOrientationString新的舞台方向。 将舞台设置成指定方向。

newOrientation 参数设置为下列四个值之一,这些值被定义为 StageOrientation 类中的常量:

StageOrientation 常量舞台方向StageOrientation.DEFAULT将舞台方向设置为默认方向(正面向上)。StageOrientation.ROTATED_RIGHT将舞台方向设置为向右旋转。StageOrientation.ROTATED_LEFT将舞台方向设置为向左旋转。StageOrientation.UPSIDE_DOWN将舞台方向设置为倒置翻转。

不要将此参数设置为 StageOrientation.UNKNOWN 或表中未列出的任何其他字符串值。

要检查是否支持不断更改的设备方向,请检查 Stage.supportsOrientantionChange 属性的值。检查 supportedOrientations 属性提供的列表,以确定当前设备支持哪些方向。

设置方向是一个异步操作。它不保证您在调用 setOrientation() 方法后立即完成。为 orientationChange 事件添加一个事件侦听器,以确定何时完成方向更改。

重要说明:在 AIR 2.6 之前,Android 设备上不支持 setOrientation() 方法。

autoOrientssupportsOrientationChangeStageOrientationEventStageOrientationorientationChangeflash.events:StageOrientationEvent作为对 setOrientation() 方法调用的结果,舞台已调整大小。 作为对 setOrientation() 方法调用的结果,舞台已调整大小。
swapChildrenAtindex1intindex2intswapChildren 交换两个指定子对象的 Z 轴顺序(从前到后顺序)。调用 Stage 对象的 swapChildrenAt() 方法会因任何调用方没有与要互换的任一对象的所有者位于同一安全沙箱而引发异常。为避免出现这种情况,对象所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityErrorchild1flash.display:DisplayObject第一个子对象。 child2flash.display:DisplayObject第二个子对象。 交换两个指定子对象的 Z 轴顺序(从前到后顺序)。显示对象容器中所有其他子对象的索引位置保持不变。 willTrigger 检查是否用此 EventDispatcher 对象或其任何始祖为指定事件类型注册了事件侦听器。调用 Stage 对象的 willTrigger() 方法会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一个安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError如果将会触发指定类型的侦听器,则值为 true;否则,值为 falseBooleantypeString事件的类型。 检查是否用此 EventDispatcher 对象或其任何始祖为指定事件类型注册了事件侦听器。将指定类型的事件调度给此 EventDispatcher 对象或其任一后代时,如果在事件流的任何阶段触发了事件侦听器,则此方法返回 true

hasEventListener()willTrigger() 方法的区别是:hasEventListener() 只检查它所属的对象,而 willTrigger() 方法检查整个事件流以查找由 type 参数指定的事件。

当从 LoaderInfo 对象调用 willTrigger() 时,只考虑调用方可以访问的侦听器。

align 一个 StageAlign 类中指定舞台在 Flash Player 或浏览器中的对齐方式的值。String 一个 StageAlign 类中指定舞台在 Flash Player 或浏览器中的对齐方式的值。以下是有效值:

垂直对齐方式水平对齐方式StageAlign.TOP顶对齐居中对齐StageAlign.BOTTOM底对齐居中对齐StageAlign.LEFT居中对齐左对齐StageAlign.RIGHT居中对齐右对齐StageAlign.TOP_LEFT顶对齐左对齐StageAlign.TOP_RIGHT顶对齐右对齐StageAlign.BOTTOM_LEFT底对齐左对齐StageAlign.BOTTOM_RIGHT底对齐右对齐

align 属性只可用于与 Stage 所有者(主 SWF 文件)位于同一安全沙箱的对象。为避免出现这种情况,Stage 所有者可以通过调用 Security.allowDomain() 方法或 Security.alowInsecureDomain() 方法来向域的调用对象授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。

flash.display.StageAlign
allowsFullScreen 指定此舞台是否允许使用全屏模式。 Boolean 指定此舞台是否允许使用全屏模式。 autoOrients 指定当设备方向更改时舞台是否自动更改方向。Boolean 指定当设备方向更改时舞台是否自动更改方向。

此属性的初始值是从应用程序描述符的 autoOrients 元素派生的,默认为 false。将该属性更改为 false 时,不能保证行为。 在某些设备上,舞台保持当前方向。在其他设备上,舞台方向更改为设备定义的“标准”方向,之后,不会再发生舞台方向更改。

AIR 配置文件支持:移动设备支持此功能,但桌面操作系统或用于电视的 AIR 设备不支持此功能。您可以使用 Stage.supportsOrientantionChange 属性在运行时测试是否受支持。有关在多个配置文件之间支持 API 的详细信息,请参阅 AIR 配置文件支持

deviceOrientationsupportsOrientationChange
colorCorrectionSupport 指定当前运行 Flash 运行时的操作系统是否支持颜色校正,以及 Flash 运行时是否可以读取并了解主(主要)监视器的颜色配置文件。String 指定当前运行 Flash 运行时的操作系统是否支持颜色校正,以及 Flash 运行时是否可以读取并了解主(主要)监视器的颜色配置文件。此属性还返回主机系统(通常是浏览器)上颜色校正的默认状态。当前返回值可能是:

三个可能的值是在 flash.display.ColorCorrectionSupport 类中具有对应常数的字符串。

  • “unsupported”:颜色校正不可用。
  • “defaultOn”:始终执行颜色校正。
  • “defaultOff”:从不执行颜色校正。
以下示例显示的事件处理程序用表明当前环境能否支持颜色校正的值填充一个文本字段。首先,该事件处理程序检查 stage.colorCorrectionSupport 以确定其是 DEFAULT_ON 还是 DEFAULT_OFF ,这两个值是来自 ColorCorrectionSupport 类的值。如果该属性是两个值中的一个,则文本字段显示当前值。否则,如果该值既不是 DEFAULT_ON 也不是 DEFAULT_OFF,则文本字段显示“不支持”。 function addHandler(add_event:Event) { if (stage.colorCorrectionSupport == ColorCorrectionSupport.DEFAULT_ON || stage.colorCorrectionSupport == ColorCorrectionSupport.DEFAULT_OFF) { lblHasCM.text = "stage.colorCorrectionSupport: " + stage.colorCorrectionSupport; } else { lblHasCM.text = "stage.colorCorrectionSupport: unsupported"; } }
flash.display.ColorCorrectionSupportcolorCorrection
colorCorrection 控制用于显示的 Flash 运行时颜色校正。String尝试使用监视器颜色校正 控制用于显示的 Flash 运行时颜色校正。只有在为监视器分配了有效的 ICC 颜色配置文件(指定设备的特定颜色属性)时,颜色校正才起作用。默认情况下,Flash 运行时尝试与其主机(通常是浏览器)的颜色校正匹配。

使用 Stage.colorCorrectionSupport 属性可确定颜色校正在当前系统和默认状态中是否可用。如果可以使用颜色校正,则将假定舞台上的所有颜色都处于 sRGB 颜色空间,这是最标准的颜色空间。在颜色校正过程中未考虑输入设备的源配置文件。不应用输入颜色校正;只将舞台输出映射到主监视器的 ICC 颜色配置文件。

通常,激活颜色管理有如下优点:可预知颜色并保持颜色的一致性、更好的转换、准确的校样以及更有效的跨媒体输出。但是请注意,由于设备相互之间或与原始图像的色域不同,因此颜色管理无法提供完美的转换。同时,尽管有颜色管理,但仍然需要自定义配置文件或编辑的配置文件。颜色配置文件取决于浏览器、操作系统 (OS)、OS 扩展、输出设备和应用程序支持。

应用颜色校正会降低 Flash 运行时的性能。Flash 运行时的颜色校正是文档样式的颜色校正,因为所有 SWF 影片都被视为带有隐式 sRGB 配置文件的文档。向显示色彩空间显示 SWF 文件(文档)时,使用 Stage.colorCorrectionSupport 属性告知 Flash 运行时正确的颜色。Flash 运行时只补尝监视器之间的差别,而不补偿输入设备(摄像头、扫描仪等)之间的差别。

三个可能的值是在 flash.display.ColorCorrection 类中具有对应常数的字符串。

  • “default”:使用与主机系统相同的颜色校正。
  • “on”:始终执行颜色校正。
  • “off”:从不执行颜色校正。
以下示例显示的事件处理程序切换当前 SWF 文件中的颜色校正,并用颜色校正的当前状态填充一个文本字段。如果 Stage.colorCorrection 值不是来自 ColorCorrection 类的值,则处理程序报告错误。 function addHandler(add_event:Event) { switch(stage.colorCorrection) { case ColorCorrection.ON: stage.colorCorrection = ColorCorrection.OFF; lblCMEnableState.text = "State: " + stage.colorCorrection; break; case ColorCorrection.OFF: stage.colorCorrection = ColorCorrection.DEFAULT; lblCMEnableState.text = "State: " + stage.colorCorrection; break; case ColorCorrection.DEFAULT: stage.colorCorrection = ColorCorrection.ON; lblCMEnableState.text = "State: " + stage.colorCorrection; break; default: lblCMEnableState.text = "Error."; break; }
flash.display.ColorCorrectioncolorCorrectionSupport
coloruintdeviceOrientation 设备的物理方向。String 设备的物理方向。

在具有滑出式键盘的设备上,在确定设备方向时,键盘的状态比加速计检测到的旋转有更高的优先级。因此,在具有侧装式键盘的纵向长宽比设备上,无论用户如何手持设备,当键盘打开时 deviceOrientation 属性都会报告 ROTATED_LEFT

设置或比较此属性的值时,使用 StageOrientation 类中定义的常量。

AIR 配置文件支持:移动设备支持此功能,但桌面操作系统或用于电视的 AIR 设备不支持此功能。您可以使用 Stage.supportsOrientationChange 属性在运行时测试是否受支持。有关在多个配置文件之间支持 API 的详细信息,请参阅 AIR 配置文件支持

autoOrientsStageOrientation
displayState 用于指定要使用哪个显示状态的 StageDisplayState 类的值。String调用 Stage 对象的 displayState 属性会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。在已显示设置对话框但用户没有响应时,尝试设置 displayState 属性 (property),或者如果 paramembed HTML 标签的 allowFullScreen 属性 (attribute) 没有设置为 true,则引发安全错误。 SecurityErrorSecurityError 用于指定要使用哪个显示状态的 StageDisplayState 类的值。以下是有效值:
  • StageDisplayState.FULL_SCREEN 将 AIR 应用程序或 Flash 运行时设置为将舞台扩展到用户的整个屏幕(禁用键盘输入)。
  • StageDisplayState.FULL_SCREEN_INTERACTIVE 将 AIR 应用程序设置成扩展舞台以覆盖用户的整个屏幕(允许键盘输入)。(对于在 Flash Player 的内容不适用。)
  • StageDisplayState.NORMAL 将 Flash 运行时设置回标准的舞台显示模式。

影片在全屏模式下的缩放行为由 scaleMode 设置确定(在 HTML 文件中使用 Stage.scaleMode 属性或 SWF 文件的 embed 标签设置进行设置)。如果 scaleMode 属性设置为 noScale,则当应用程序过渡为全屏模式时,舞台的 widthheight 属性将更新,舞台调度 resize 事件。如果设置了任何其他缩放模式,则缩放舞台及其内容以填充新屏幕尺寸。Stage 对象保持原来的 widthheight 值,不调度 resize 事件。

以下限制适用于在 HTML 页内播放的 SWF 文件(而不是使用独立 Flash Player 播放的文件或不在 AIR 运行时中运行的文件):

  • 要启用全屏模式,请将 allowFullScreen 参数添加到包含 SWF 文件的 HTML 页中的 objectembed 标签,同时将 allowFullScreen 设置为 "true",如下例所示: <param name="allowFullScreen" value="true" /> ... <embed src="example.swf" allowFullScreen="true" ... >

    HTML 页还可以使用脚本生成 SWF 嵌入标签。您需要修改脚本,以使其插入正确的 allowFullScreen 设置。Flash Professional 和 Flash Builder 生成的 HTML 页面使用 AC_FL_RunContent() 函数嵌入对 SWF 文件的引用,然后您需要添加 allowFullScreen 参数设置,如下所示:

    AC_FL_RunContent( ... "allowFullScreen", "true", ... )
  • 全屏模式是在响应用户单击鼠标或按键时初始化的;在没有用户输入的情况下,影片不能更改 Stage.displayState。在全屏模式下,Flash 运行时会限制键盘输入。可接受的键包括用于终止全屏模式的快捷键和非打印键,例如箭头、空格、Shift 键和 Tab 键。用于终止全屏模式的快捷键包括 Escape(Windows、Linux 和 Mac)、Ctrl+W (Windows)、Command+W (Mac) 和 Alt+F4。

    当用户进入全屏模式时,将在影片上面显示一个 Flash 运行时对话框,告诉用户已经进入了全屏模式,并可以按 Esc 键退出全屏模式。

  • 从 Flash Player 9.0.115.0 开始,全屏模式在无窗口模式下的工作方式与窗口模式相同。如果将窗口模式(HTML 中的 wmode)设置为不透明无窗口 (opaque) 或透明无窗口 (transparent),则可以启动全屏模式,但全屏窗口始终是不透明的。

对于在独立 Flash Player 或 AIR 中运行的 SWF 内容,存在这些限制。AIR 支持允许键盘输入的交互式全屏模式。

对于以全屏模式运行的 AIR 内容,在播放视频内容时,将禁用系统屏幕保护程序和节能选项,直到该视频停止或退出全屏模式。

在 Linux 上,将 displayState 设置为 StageDisplayState.FULL_SCREENStageDisplayState.FULL_SCREEN_INTERACTIVE 是一种异步操作。

下例以一种交互的方式演示如何通过修改 displayState 属性创造全屏体验。

注意:出于安全方面的限制,只有在某些情况下才能触发全屏,例如,如果用户单击了鼠标或按了键盘键。在浏览器中运行时,allowFullScreen 属性必须设置为 true。

package { import flash.display.Sprite; import flash.display.Stage; import flash.events.*; import flash.net.NetConnection; import flash.net.NetStream; import flash.media.Video; public class FullScreenExample extends Sprite { private var videoURL:String = "testVideo.flv"; private var connection:NetConnection; private var stream:NetStream; private var video:Video; public function FullScreenExample() { connection = new NetConnection(); connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); connection.connect(null); loaderInfo.addEventListener(Event.INIT, createMouseListener); } private function createMouseListener(event:Event):void { stage.addEventListener(MouseEvent.CLICK,toggleFullScreen); } private function toggleFullScreen(event:MouseEvent):void { switch(stage.displayState) { case "normal": stage.displayState = "fullScreen"; break; case "fullScreen": default: stage.displayState = "normal"; break; } } // Video related: private function netStatusHandler(event:NetStatusEvent):void { switch (event.info.code) { case "NetConnection.Connect.Success": connectStream(); break; case "NetStream.Play.StreamNotFound": trace("Unable to locate video: " + videoURL); break; } } private function connectStream():void { var stream:NetStream = new NetStream(connection); stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR, asyncErrorHandler); video = new Video(stage.stageWidth,stage.stageHeight); video.attachNetStream(stream); stream.play(videoURL); addChild(video); } private function securityErrorHandler(event:SecurityErrorEvent):void { trace("securityErrorHandler: " + event); } private function asyncErrorHandler(event:AsyncErrorEvent):void { // ignore AsyncErrorEvent events. } } }
flash.display.StageDisplayStateStage.scaleModeflash.events.FullScreenEventflash.events.Event.RESIZE
focus 具有键盘焦点的交互式对象;如果没有设置焦点,或者具有焦点的对象属于调用对象无权访问的安全沙箱,则为 null。flash.display:InteractiveObject如果不能将焦点设置到目标,则会引发错误。 ErrorError具有键盘焦点的对象。 具有键盘焦点的交互式对象;如果没有设置焦点,或者具有焦点的对象属于调用对象无权访问的安全沙箱,则为 null 以下示例将初始焦点设置到文本字段 myTF,以便用户不必执行单击即可开始键入。如果在创作工具界面中测试此代码,则仅可以访问几个键,因为主机(浏览器或工具)首先解释大多数按键。要查看此示例按预期方式工作的情况,请对其进行编译并运行 SWF 文件。 var myTF:TextField = new TextField(); myTF.border =true; myTF.type = TextFieldType.INPUT; addChild(myTF); stage.focus= myTF; frameRate 获取并设置舞台的帧速率。Number调用 Stage 对象的 frameRate 属性会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError 获取并设置舞台的帧速率。帧速率是指每秒显示的帧数。默认情况下,速率设置为第一个加载的 SWF 文件的帧速率。帧速率的有效范围为每秒 0.01 到 1000 个帧。

注意:应用程序可能由于以下原因而无法支持高帧速率设置:目标平台不够快或播放器与显示设备的垂直空白时间(在 LCD 设备上通常为 60 Hz)同步。在某些情况下,如果目标平台将占用高 CPU 使用率,它可能还会选择降低最大帧率。

对于在 Adobe AIR 中运行的内容,设置一个 Stage 对象的 frameRate 属性会更改所有 Stage 对象(由不同的 NativeWindow 对象使用)的帧速率。

fullScreenHeight 返回变为全屏大小时使用的显示器高度(如果立即进入该状态)。uint 返回变为全屏大小时使用的显示器高度(如果立即进入该状态)。如果用户有多台显示器,则使用的显示器是此时显示大部分舞台的显示器。

注意:在检索值和变为全屏大小之间,如果用户有机会将浏览器从一台显示器移到另一台显示器,则该值可能不正确。如果在将 Stage.displayState 设置为 StageDisplayState.FULL_SCREEN 的事件处理函数中检索值,则该值是正确的。

如果将 Stage.align 设置为 StageAlign.TOP_LEFT 并将 Stage.scaleMode 设置为 StageScaleMode.NO_SCALE,则该值是显示器的像素高度并且与舞台高度相同。

本示例创建一个舞台大小的绿色矩形,并在其上面放置一个红色正方形,它将作为按钮进行激活。单击红色正方形可触发 enterFullScreen() 事件处理函数,它将设置 fullScreenSourceRect 属性并进入全屏模式。为了设置 fullScreenSourceRect 属性,该事件处理函数先从红色正方形的位置和尺寸入手。然后,它将红色正方形的高宽比(宽度除以高度)与舞台在全屏宽度和高度下的高宽比进行比较,以便扩展矩形 (fullScreenSourceRect) 使其与屏幕高宽比相匹配。结果是红色正方形占据了显示器的整个高度,并且可以在每条边上看见绿色背景。如果高宽比不匹配,将在每条边上显示舞台背景颜色(默认情况下为白色),而不是显示绿色背景。

注意:应在浏览器中测试此示例。在“Flash 发布设置”对话框的“HTML”选项卡上,选择“仅 Flash - 允许全屏”模板。指定 Flash Player 的 9.0.115.0 版本,并确保在“格式”选项卡中选择了 Flash 和 HTML 格式。然后,发布生成的 HTML 文件,并在浏览器中打开该文件。

import flash.display.Sprite; import flash.display.Stage; import flash.display.StageDisplayState; import flash.events.MouseEvent; import flash.geom.Rectangle; // cover the stage with a green rectangle var greenRect:Sprite = new Sprite(); greenRect.graphics.beginFill(0x00FF00); greenRect.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight); addChild(greenRect); // create red square on stage, turn it into a button for going to full screen var redSquare:Sprite = new Sprite(); redSquare.graphics.beginFill(0xFF0000); redSquare.graphics.drawRect(0, 0, 300, 300); redSquare.x = 50; redSquare.y = 50; redSquare.addEventListener(MouseEvent.CLICK, enterFullScreen); redSquare.buttonMode = true; addChild(redSquare); function enterFullScreen(e:MouseEvent):void { // we will go to full screen zoomed in on the red square var redSquare:Sprite = e.target as Sprite; var fullScreenRect:Rectangle = new Rectangle(redSquare.x, redSquare.y, redSquare.width, redSquare.height); // calculate aspect ratio of the red square var rectAspectRatio:Number = fullScreenRect.width / fullScreenRect.height; // calculate aspect ratio of the screen var screenAspectRatio:Number = stage.fullScreenWidth / stage.fullScreenHeight; // change the fullScreenRect so that it covers the entire screen, keeping it centered on the redSquare // try commenting out this section to see what happens if you do not fix the aspect ratio. if (rectAspectRatio > screenAspectRatio) { var newHeight:Number = fullScreenRect.width / screenAspectRatio; fullScreenRect.y -= ((newHeight - fullScreenRect.height) / 2); fullScreenRect.height = newHeight; } else if (rectAspectRatio < screenAspectRatio) { var newWidth:Number = fullScreenRect.height * screenAspectRatio; fullScreenRect.x -= ((newWidth - fullScreenRect.width) / 2); fullScreenRect.width = newWidth; } // go to full screen stage.fullScreenSourceRect = fullScreenRect; stage.displayState = StageDisplayState.FULL_SCREEN; }
displayStatefullScreenSourceRectfullScreenWidthscaleModeStageDisplayStateflash.events.Event.RESIZEflash.events.FullScreenEvent
fullScreenSourceRect 设置 Flash 运行时以将特定的舞台区域放大到全屏模式。flash.geom:Rectangle 设置 Flash 运行时以将特定的舞台区域放大到全屏模式。如果可以,Flash 运行时会使用硬件进行缩放(使用用户计算机上的图形和视频卡),通常,以这种方式显示内容的速度比使用软件缩放快。

如果将此属性设为有效矩形并将 displayState 属性设为全屏模式,Flash 运行时将对指定区域进行缩放。ActionScript 中的实际舞台大小(以像素为单位)不会发生改变。Flash 运行时对矩形大小强制规定了最小限制,以容纳标准的“按 Esc 退出全屏模式”消息。通常,此限制大约为 260 x 30 个像素,但可能因平台和 Flash 运行时版本而异。

仅当 Flash 运行时未处于全屏模式时,才能设置此属性。要正确使用此属性,应先设置此属性,然后将 displayState 属性设置为全屏模式,如代码示例中所示。

要启用缩放功能,请将 fullScreenSourceRect 属性设置为矩形对象:

// valid, will enable hardware scaling stage.fullScreenSourceRect = new Rectangle(0,0,320,240);

要禁用缩放功能,请在 ActionScript 3.0 中设置 fullScreenSourceRect=null,而在 ActionScript 2.0 中设置 undefined

stage.fullScreenSourceRect = null;

最终用户还可以在“Flash Player 显示设置”中进行选择以关闭硬件缩放功能,默认情况下,将启用此功能。有关详细信息,请参阅 www.adobe.com/go/display_settings_cn

要利用硬件缩放功能,请将整个舞台或部分舞台设置为全屏模式。以下 ActionScript 3.0 代码将整个舞台设置为全屏模式: import flash.geom.*; { stage.fullScreenSourceRect = new Rectangle(0,0,320,240); stage.displayState = StageDisplayState.FULL_SCREEN; } 在以下示例中,用户可以通过单击舞台来切换播放视频的方式:全屏模式或正常模式。如果此示例的 SWF 在 Flash Player 9.0.115.0 或更高版本中运行,它将使用硬件加速功能来改进显示时的全屏缩放。

在使用带有硬件缩放的全屏模式之前,必须具备以下条件:

  1. 需要有 Flash Player 9.0.115.0 或更高版本,以及支持该版本的创作工具。
  2. 需要修改 HTML 模板以支持全屏模式。必须为 objectembed 标签将 allowFullScreen 属性设置为 true。(生成 SWF 嵌入标签的脚本也必须考虑到全屏模式。) 有关可用于 Flash Builder 的文件样本,请参阅文章“了解 Flash Player 9 中的全屏模式”
  3. 您的应用程序必须具有访问 FLV 视频文件的权限。在此示例中,假定 Flash 视频 (FLV) 文件与 SWF 文件在同一目录中。
  4. 用户必须允许使用全屏模式。
  5. 有关硬件缩放的更多信息,请参阅适用于 Flash Player 的文章:Exploring Flash Player support for high-definition H.264 video and AAC audio(了解高分辨率 H.264 视频和 AAC 音频的 Flash Player 支持)。

使用 NetConnection and NetStream 对象加载了一个 FLV 文件。由于 FLV 文件与 SWF 文件在同一目录中并且将通过 HTTP 进行连接,所以 NetConnection.connect() 方法的参数会被设置为 nullconnect NetConnection 对象会通过调度一个调用 netStatusHandler() 方法的 netStatus 事件来报告其状态。netStatusHandler() 方法会检查连接是否成功并调用 connectStream() 方法,而 connectStream() 方法创建一个使用 NetConnection 对象作为参数的 NetStream 对象。它还会创建一个视频对象并将 NetStream 对象附加到该视频对象。然后,该视频对象会被添加到显示列表中,并且会设置流进行播放。由于 FLV 视频文件不包含元数据或提示点信息,所以将会调度一个 AsyncError 事件。必须设置一个侦听器来处理该事件。这里设置了侦听器并且它忽略该事件。另外还为 NetStream 对象设置了 netStatus 事件的另一个侦听器。如果没有找到流,它将会显示一条错误信息。(请注意,可以使用 netStatusHandler() 来处理为流或连接报告的任意数量的不同状态信息。)

在可以访问所加载 SWF 文件的属性和方法时,会调用 createMouseListener() 方法。它会设置一个在用鼠标单击舞台时使用的事件侦听器。toggleFullScreen() 方法会检查显示状态是处于全屏模式还是处于正常模式。如果是正常模式,视频对象的大小会被设置为视频流的大小。fullScreenSourceRect 属性会被设置为一个与视频对象尺寸匹配的矩形。然后,Stage.displayMode 属性会被设置为全屏模式,这样就会导致源矩形中的视频扩展,从而填满全屏。如果符合系统要求,将会使用计算机的图形硬件来改进全屏视频呈现的性能,并且显示状态会被设置为全屏模式。为了捕捉在切换为全屏模式时可能出现的任何安全错误,可以使用 try...catch。(请注意,在设置 fullScreenSourceRect 属性之后,必须将显示状态设置为全屏模式。) 在切换到正常模式之前,会将视频对象的宽度和高度设回所保存的原始视频对象的高度和宽度。否则,为全屏模式而对视频对象所做的更改将会确定宽度和高度。

package { import flash.display.Sprite; import flash.display.StageDisplayState; import flash.media.Video; import flash.net.NetConnection; import flash.net.NetStream; import flash.events.NetStatusEvent; import flash.events.AsyncErrorEvent; import flash.events.SecurityErrorEvent; import flash.events.MouseEvent; import flash.events.Event; import flash.geom.Rectangle; public class Stage_fullScreenSourceRectExample2 extends Sprite { private var videoURL:String = "testVideo1.flv"; private var connection:NetConnection; private var stream:NetStream; private var myVideo:Video; private var savedWidth:uint; private var savedHeight:uint; public function Stage_fullScreenSourceRectExample2() { connection = new NetConnection(); connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); connection.connect(null); loaderInfo.addEventListener(Event.INIT, createMouseListener); } private function createMouseListener(event:Event):void { stage.addEventListener(MouseEvent.CLICK, toggleFullScreen); } private function toggleFullScreen(event:MouseEvent):void { if(stage.displayState == StageDisplayState.NORMAL) { myVideo.width = myVideo.videoWidth; myVideo.height = myVideo.videoHeight; try { stage.fullScreenSourceRect = new Rectangle(myVideo.x, myVideo.y, myVideo.width, myVideo.height); stage.displayState = StageDisplayState.FULL_SCREEN; } catch (e:SecurityError) { trace ("A security error occurred while switching to full screen: " + event); myVideo.width = savedWidth; myVideo.height = savedHeight; } }else { myVideo.width = savedWidth; myVideo.height = savedHeight; stage.displayState = StageDisplayState.NORMAL; } } private function netStatusHandler(event:NetStatusEvent):void { switch (event.info.code) { case "NetConnection.Connect.Success": connectStream(); break; case "NetStream.Play.StreamNotFound": trace ("Unable to locate video: " + videoURL); break; } } private function connectStream():void { var stream:NetStream = new NetStream(connection); stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler); stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR, asyncErrorHandler); myVideo = new Video(); myVideo.attachNetStream(stream); stream.play(videoURL); savedWidth = myVideo.width; savedHeight = myVideo.height; addChild(myVideo); } private function securityErrorHandler(event:SecurityErrorEvent):void { trace("securityErrorHandler: " + event); } private function asyncErrorHandler(event:AsyncErrorEvent):void { } } }
flash.display.StageDisplayStateStage.displayStateStage.scaleModeflash.events.FullScreenEventflash.events.Event.RESIZE
fullScreenWidth 返回变为全屏大小时使用的显示器宽度(如果立即进入该状态)。uint 返回变为全屏大小时使用的显示器宽度(如果立即进入该状态)。如果用户有多台显示器,则使用的显示器是此时显示大部分舞台的显示器。

注意:在检索值和变为全屏大小之间,如果用户有机会将浏览器从一台显示器移到另一台显示器,则该值可能不正确。如果在将 Stage.displayState 设置为 StageDisplayState.FULL_SCREEN 的事件处理函数中检索值,则该值是正确的。

如果将 Stage.align 设置为 StageAlign.TOP_LEFT 并将 Stage.scaleMode 设置为 StageScaleMode.NO_SCALE,则该值是显示器的像素宽度并且与舞台宽度相同。

本示例创建一个舞台大小的绿色矩形,并在其上面放置一个红色正方形,它将作为按钮进行激活。单击红色正方形可触发 enterFullScreen() 事件处理函数,它将设置 fullScreenSourceRect 属性并进入全屏模式。为了设置 fullScreenSourceRect 属性,该事件处理函数先从红色正方形的位置和尺寸入手。然后,它将红色正方形的高宽比(宽度除以高度)与舞台在全屏宽度和高度下的高宽比进行比较,以便扩展矩形 (fullScreenSourceRect) 使其与屏幕高宽比相匹配。结果是红色正方形占据了显示器的整个高度,并且可以在每条边上看见绿色背景。如果高宽比不匹配,将在每条边上显示舞台背景颜色(默认情况下为白色),而不是显示绿色背景。

注意:应在浏览器中测试此示例。在“Flash 发布设置”对话框的“HTML”选项卡上,选择“仅 Flash - 允许全屏”模板。指定 Flash Player 的 9.0.115.0 版本,并确保在“格式”选项卡中选择了 Flash 和 HTML 格式。然后,发布生成的 HTML 文件,并在浏览器中打开该文件。

import flash.display.Sprite; import flash.display.Stage; import flash.display.StageDisplayState; import flash.events.MouseEvent; import flash.geom.Rectangle; // cover the stage with a green rectangle var greenRect:Sprite = new Sprite(); greenRect.graphics.beginFill(0x00FF00); greenRect.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight); addChild(greenRect); // create red square on stage, turn it into a button for going to full screen var redSquare:Sprite = new Sprite(); redSquare.graphics.beginFill(0xFF0000); redSquare.graphics.drawRect(0, 0, 300, 300); redSquare.x = 50; redSquare.y = 50; redSquare.addEventListener(MouseEvent.CLICK, enterFullScreen); redSquare.buttonMode = true; addChild(redSquare); function enterFullScreen(e:MouseEvent):void { // we will go to full screen zoomed in on the red square var redSquare:Sprite = e.target as Sprite; var fullScreenRect:Rectangle = new Rectangle(redSquare.x, redSquare.y, redSquare.width, redSquare.height); // calculate aspect ratio of the red square var rectAspectRatio:Number = fullScreenRect.width / fullScreenRect.height; // calculate aspect ratio of the screen var screenAspectRatio:Number = stage.fullScreenWidth / stage.fullScreenHeight; // change the fullScreenRect so that it covers the entire screen, keeping it centered on the redSquare // try commenting out this section to see what happens if you do not fix the aspect ratio. if (rectAspectRatio > screenAspectRatio) { var newHeight:Number = fullScreenRect.width / screenAspectRatio; fullScreenRect.y -= ((newHeight - fullScreenRect.height) / 2); fullScreenRect.height = newHeight; } else if (rectAspectRatio < screenAspectRatio) { var newWidth:Number = fullScreenRect.height * screenAspectRatio; fullScreenRect.x -= ((newWidth - fullScreenRect.width) / 2); fullScreenRect.width = newWidth; } // go to full screen stage.fullScreenSourceRect = fullScreenRect; stage.displayState = StageDisplayState.FULL_SCREEN; }
displayStatefullScreenHeightfullScreenSourceRectscaleModeStageDisplayStateflash.events.Event.RESIZEflash.events.FullScreenEvent
height 表示显示对象的高度,以像素为单位。Number引用 Stage 对象的 height 属性会因任何调用者没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError即使调用对象是 Stage 所有者(主 SWF 文件),设置 Stage 对象的 height 属性也是非法的。 IllegalOperationErrorflash.errors:IllegalOperationError 表示显示对象的高度,以像素为单位。高度是根据显示对象内容的范围来计算的。如果您设置了 height 属性,则 scaleY 属性会相应调整,如以下代码所示: var rect:Shape = new Shape(); rect.graphics.beginFill(0xFF0000); rect.graphics.drawRect(0, 0, 100, 100); trace(rect.scaleY) // 1; rect.height = 200; trace(rect.scaleY) // 2;

除 TextField 和 Video 对象以外,没有内容的显示对象(如一个空的 Sprite)的高度为 0,即使您尝试将 height 设置为其他值,也是这样。

mouseChildren 确定对象的子级是否支持鼠标或用户输入设备。Boolean引用 Stage 对象的 mouseChildren 属性会因任何调用者没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError 确定对象的子级是否支持鼠标或用户输入设备。如果对象支持鼠标或用户输入设备,用户可以通过使用鼠标或用户输入设备与之交互。默认值为 true

当您使用 Sprite 类的实例(而不是使用 SimpleButton 类)来创建按钮时,此属性很有用。当您使用 Sprite 实例来创建按钮时,可以选择使用 addChild() 方法添加其他 Sprite 实例来修饰该按钮。此过程可能导致鼠标事件出现意外行为,因为当您期望父实例成为鼠标事件的目标对象时,作为子项添加的 Sprite 实例却可能成为目标对象。要确保父实例用作鼠标事件的目标对象,您可以将父实例的 mouseChildren 属性设置为 false

设置此属性不会调度任何事件。您必须使用 addEventListener() 方法才能创建交互式功能。

nativeWindow 对包含此舞台的 NativeWindow 对象的引用。flash.display:NativeWindow 对包含此舞台的 NativeWindow 对象的引用。

窗口表示本机操作系统的窗口,舞台表示窗口所包含的内容。此属性仅对在支持 NativeWindow 类的平台上的 AIR 中运行的内容有效。在其他平台上,此属性将为 null。在 Flash Player 中(在浏览器中运行的内容),此属性也将为 null

numChildren 返回此对象的子项数目。int引用 Stage 对象的 numChildren 属性会因任何调用者没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError 返回此对象的子项数目。 orientation 当前舞台方向。String 当前舞台方向。此属性设置为以下四个值之一,这些值被定义为 StageOrientation 类中的常量: StageOrientation 常量舞台方向StageOrientation.DEFAULT屏幕处于默认方向(正面向上)。StageOrientation.ROTATED_RIGHT屏幕向右旋转。StageOrientation.ROTATED_LEFT屏幕向左旋转。StageOrientation.UPSIDE_DOWN屏幕倒置翻转。StageOrientation.UNKNOWN应用程序尚未确定屏幕的初始方向。可以为 orientationChange 事件添加事件侦听器。

要设置舞台方向,请使用 setOrientation() 方法。

重要说明:从 2.6 命名空间开始,在 Android 设备上支持 orientation 属性。

StageOrientationautoOrientsdeviceOrientationsupportsOrientationChange
quality StageQuality 类中的一个用于指定使用哪种呈现品质的值。String调用 Stage 对象的 quality 属性会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError StageQuality 类中的一个用于指定使用哪种呈现品质的值。以下是有效值:
  • StageQuality.LOW -- 低呈现品质。不消除图形的锯齿,不对位图进行平滑处理,但运行时仍使用 mip 贴图技术。
  • StageQuality.MEDIUM -- 中等呈现品质。图形是使用 2 x 2 像素网格消除锯齿的,而位图平滑处理取决于 Bitmap.smoothing 设置。运行时使用 mip 贴图技术。此设置适用于不包含文本的影片。
  • StageQuality.HIGH -- 高呈现品质。图形是使用 4 x 4 像素网格消除锯齿的,而位图平滑处理取决于 Bitmap.smoothing 设置。运行时使用 mip 贴图技术。这是 Flash Player 使用的默认呈现品质设置。
  • StageQuality.BEST -- 极高呈现品质。图形是使用 4 x 4 像素网格消除锯齿的。如果将 Bitmap.smoothing 设置为 true,则运行时会使用产生较少伪像的高品质降级算法(但是,使用 StageQuality.BEST 时将 Bitmap.smoothing 设置为 true 会显著降低性能,因此不建议使用此设置)。

较高的品质设置可以使缩放的位图得到较好的呈现品质。不过,较高的品质设置从运算角度看更昂贵。尤其在呈现缩放的视频时,使用较高的品质设置可以降低帧速率。

在 Adobe AIR 的桌面配置文件中,quality 可设置为 StageQuality.BESTStageQuality.HIGH(默认值为 StageQuality.HIGH)。试图将其设置为其他值不会产生任何效果(且该属性保持不变)。在 AIR 的移动配置文件中,所有四个品质设置均可用。在移动设备上,默认值为 StageQuality.MEDIUM

对于在 Adobe AIR 中运行的内容,设置一个 Stage 对象的 quality 属性会更改所有 Stage 对象(由不同的 NativeWindow 对象使用)的呈现品质。

注意:操作系统绘制设备字体,因此,这些设备字体不会受 quality 属性的影响。
flash.display.StageQualityflash.display.Bitmap.smoothing
scaleMode 一个 StageScaleMode 类中指定要使用哪种缩放模式的值。String调用 Stage 对象的 scaleMode 属性会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError一个 StageScaleMode 类中指定要使用哪种缩放模式的值。 一个 StageScaleMode 类中指定要使用哪种缩放模式的值。以下是有效值:
  • StageScaleMode.EXACT_FIT -- 整个应用程序在指定区域中可见,但不尝试保持原始高宽比。可能会发生扭曲,应用程序可能会拉伸或压缩显示。
  • StageScaleMode.SHOW_ALL -- 整个应用程序在指定区域中可见,且不发生扭曲,同时保持应用程序的原始高宽比。应用程序的两侧可能会显示边框。
  • StageScaleMode.NO_BORDER -- 整个应用程序填满指定区域,不发生扭曲,但有可能进行一些裁切,同时保持应用程序的原始高宽比。
  • StageScaleMode.NO_SCALE -- 整个应用程序的大小固定,因此,即使播放器窗口的大小更改,它也会保持不变。如果播放器窗口比内容小,则可能进行一些裁切。
flash.display.StageScaleMode
showDefaultContextMenu 指定是显示还是隐藏 Flash 运行时上下文菜单中的默认项。Boolean调用 Stage 对象的 showDefaultContextMenu 属性会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError指定显示或隐藏 Flash Player 上下文菜单中的默认项。 指定是显示还是隐藏 Flash 运行时上下文菜单中的默认项。

如果将 showDefaultContextMenu 属性设置为 true(默认设置),则会显示所有上下文菜单项。如果 showDefaultContextMenu 属性设置为 false,则只显示“设置”和“关于...”菜单项。

softKeyboardRect 当前被软键盘覆盖的舞台区域。flash.geom:Rectangle 当前被软键盘覆盖的舞台区域。

当软键盘不可见时,此区域的大小为零 (0,0,0,0)。

当键盘打开时,softKeyboardRect 将在调度 softKeyboardActivate 事件时进行设置。如果键盘的大小在打开时发生变化,则运行时会更新 softKeyboardRect 属性并调度另一个 softKeyboardActivate 事件。

注意:在 Android 上,如果操作系统没有提供准确确定区域所需的信息,则将估计键盘覆盖的区域。在全屏模式下,以及打开键盘以相应 InteractiveObject 接收焦点或调用 requestSoftKeyboard() 方法时,就会出现此问题。

SoftKeyboardEventInteractiveObject.needsSoftKeyboard
stageFocusRect 指定对象在具有焦点时是否显示加亮的边框。Boolean调用 Stage 对象的 stageFocusRect 属性会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError指定对象在具有焦点时是否显示加亮的边框。 指定对象在具有焦点时是否显示加亮的边框。 stageHeight 舞台的当前高度(以像素为单位)。int调用 Stage 对象的 stageHeight 属性会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError 舞台的当前高度(以像素为单位)。

如果将 Stage.scaleMode 属性的值设置 StageScaleMode.NO_SCALE,则当用户调整该窗口的大小时,舞台内容将保持其大小,而 stageHeight 属性将发生更改以反映由 SWF 文件占用的屏幕区域的新高度大小。(在其他缩放模式中,stageHeight 属性始终反映 SWF 文件的原始高度。)可以为 resize 事件添加事件侦听器,然后使用 Stage 类的 stageHeight 属性确定调整大小后的 Flash 运行时窗口的实际像素尺寸。使用该事件侦听器可以控制用户调整窗口大小时屏幕内容的调整方式。

设置 stageHeight 属性时,用于电视的 AIR 设备与桌面设备的表现稍有不同。如果 Stage.scaleMode 属性设置为 StageScaleMode.NO_SCALE,并且您设置了 stageHeight 属性,则舞台高度将直到 SWF 的下一帧才更改。

注意:在承载 SWF 文件的 HTML 页上,objectembed 标签的 height 属性必须设置为一个百分数(比如 100%),而不是像素。如果该设置是由 JavaScript 代码生成的,则 AC_FL_RunContent() 方法的 height 参数也必须设置为百分数。此百分数应用于 stageHeight 值。

flash.display.StageScaleMode
stageVideos 播放外部视频可以使用的 StageVideo 对象列表。 播放外部视频可以使用的 StageVideo 对象列表。

一次只能使用有限数量的 StageVideo 对象。SWF 开始运行时,可用 StageVideo 对象的数量取决于平台以及可用硬件。

要使用 StageVideo 对象,请将 stageVideos 矢量对象的成员调度给一个 StageVideo 变量。

所有 StageVideo 对象都显示在舞台上,位于所有显示对象后面。StageVideo 对象以它们在 stageVideos 矢量对象中的显示顺序显示在舞台上。例如,如果 stageVideos 矢量对象包含三个条目:

  1. stageVideos 矢量对象 0 索引中的 StageVideo 对象显示在所有 StageVideo 对象后面。
  2. 索引 1 中的 StageVideo 对象显示在索引 0 中的 StageVideo 对象前面。
  3. 索引 2 中的 StageVideo 对象显示在索引 1 中的 StageVideo 对象前面。

使用 StageVideo.depth 属性来更改此排序。

注意:用于电视的 AIR 设备仅支持一个 StageVideo 对象。

下列代码展示了如何获取一个 StageVideo 对象: var stageVideo:StageVideo; if ( stage.stageVideos.length >= 1 ) { stageVideo = stage.stageVideos[0]; }
flash.media.StageVideoflash.events.StageVideoEvent
stageWidth 指定舞台的当前宽度(以像素为单位)。int调用 Stage 对象的 stageWidth 属性会因任何调用方没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError 指定舞台的当前宽度(以像素为单位)。

如果将 Stage.scaleMode 属性的值设置 StageScaleMode.NO_SCALE,则当用户调整该窗口的大小时,舞台内容将保持其定义的大小,而 stageWidth 属性将发生更改以反映由 SWF 文件占用的屏幕区域的新宽度大小。(在其他缩放模式中,stageWidth 属性始终反映 SWF 文件的原始宽度。)可以为 resize 事件添加事件侦听器,然后使用 Stage 类的 stageWidth 属性确定调整大小后的 Flash 运行时窗口的实际像素尺寸。使用该事件侦听器可以控制用户调整窗口大小时屏幕内容的调整方式。

设置 stageWidth 属性时,用于电视的 AIR 设备与桌面设备表现稍有不同。如果 Stage.scaleMode 属性设置为 StageScaleMode.NO_SCALE,而且您设置了 stageWidth 属性,则舞台宽度将直到 SWF 的下一帧才会更改。

注意:在承载 SWF 文件的 HTML 页上,objectembed 标签的 width 属性必须设置为一个百分数(比如 100%),而不是像素。如果该设置是由 JavaScript 代码生成的,则 AC_FL_RunContent() 方法的 width 参数也必须设置为百分数。此百分数应用于 stageWidth 值。

flash.display.StageScaleMode
supportedOrientations 当前设备支持的方向。 当前设备支持的方向。

您可以使用此列表中包括的方向字符串作为 setOrientation() 方法的参数。设置不支持的方向失败,没有错误。

可能的方向包括:

StageOrientation 常量舞台方向StageOrientation.DEFAULT将舞台方向设置为默认方向(正面向上)。StageOrientation.ROTATED_RIGHT将舞台方向设置为向右旋转。StageOrientation.ROTATED_LEFT将舞台方向设置为向左旋转。StageOrientation.UPSIDE_DOWN将舞台方向设置为倒置翻转。
StageOrientationautoOrientssetOrientationorientation
supportsOrientationChange 应用程序是否支持更改舞台方向(和设备旋转)。Boolean 应用程序是否支持更改舞台方向(和设备旋转)。当前在移动设备上所运行的 AIR 应用程序中,此属性仅为 trueautoOrientsdeviceOrientationsupportsOrientationChangetabChildren 确定对象的子项是否支持 Tab 键。Boolean引用 Stage 对象的 tabChildren 属性会因任何调用者没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError 确定对象的子项是否支持 Tab 键。为对象的子项启用或禁用 Tab 切换。默认值为 true

注意:不要将 tabChildren 属性用于 Flex。而应使用 mx.core.UIComponent.hasFocusableChildren 属性。

textSnapshot 返回此 DisplayObjectContainer 实例的 TextSnapshot 对象。flash.text:TextSnapshot引用 Stage 对象的 textSnapshot 属性会因 Stage 类未实现该属性而引发异常。为避免出现这种情况,请调用显示对象容器而非 Stage 对象的 textSnapshot 属性。 IllegalOperationErrorflash.errors:IllegalOperationError 返回此 DisplayObjectContainer 实例的 TextSnapshot 对象。 width 表示显示对象的宽度,以像素为单位。Number引用 Stage 对象的 width 属性会因任何调用者没有与 Stage 所有者(主 SWF 文件)位于同一安全沙箱而引发异常。为避免出现这种情况,Stage 的所有者可以通过调用 Security.allowDomain() 方法或 Security.allowInsecureDomain() 方法来向域的调用方授予权限。有关详细信息,请参阅《ActionScript 3.0 开发人员指南》中的“安全性”一章。 SecurityErrorSecurityError即使您是 Stage 所有者,设置 Stage 对象的 width 属性也是非法的。 IllegalOperationErrorflash.errors:IllegalOperationError 表示显示对象的宽度,以像素为单位。宽度是根据显示对象内容的范围来计算的。如果您设置了 width 属性,则 scaleX 属性会相应调整,如以下代码所示: var rect:Shape = new Shape(); rect.graphics.beginFill(0xFF0000); rect.graphics.drawRect(0, 0, 100, 100); trace(rect.scaleX) // 1; rect.width = 200; trace(rect.scaleX) // 2;

除 TextField 和 Video 对象以外,没有内容的显示对象(如一个空的 Sprite)的宽度为 0,即使您尝试将 width 设置为其他值,也是这样。

wmodeGPU 表示 GPU 合成是否可用及是否正在使用中。Boolean 表示 GPU 合成是否可用及是否正在使用中。仅当下列三个条件同时存在时,wmodeGPU 的值才为 true

  • 已请求 GPU 合成。
  • GPU 合成可用。
  • GPU 合成正在使用。

具体来说,wmodeGPU 属性表示下列条件之一:

  1. 尚未请求 GPU 合成或 GPU 合成不可用。在这种情况下,wmodeGPU 属性值为 false
  2. 已请求 GPU 合成(如果适用且可用),但是由于内容限制,此环境正在“回退模式”(非最佳渲染方式)下工作。在这种情况下,wmodeGPU 属性值为 true
  3. 已请求 GPU 合成(如果适用且可用),并且环境正在最佳模式下工作。在这种情况下,wmodeGPU 属性值也为 true

换句话说,wmodeGPU 属性会标识呈现环境的功能和状态。对于不支持 GPU 合成的运行时(例如,AIR 1.5.2),此值始终为 false,因为(如上所述)此值仅在已请求 GPU 合成、GPU 合成可用且正在使用时为 true

wmodeGPU 属性用于确定 GPU 合成在运行时是否正在使用中。wmodeGPU 的值表示是否将由硬件对您的内容进行缩放,以使您可以显示正确大小的图形。您还可以确定是否要通过快速途径渲染,以使您可以对内容复杂性进行相应调整。

对于位于浏览器中的 Flash Player,可由承载 SWF 文件的页面中的 wmode HTML 参数的 gpu 的值请求 GPU 合成。对于其他配置,可在 SWF 文件(使用 SWF 创作工具进行设置)头中请求 GPU 合成。

但是,wmodeGPU 属性不标识当前渲染性能。即使 GPU 合成“正在使用中”,渲染过程可能也不会在最佳模式下进行操作。要调整您的内容以实现最佳渲染,请使用 Flash 运行时调试版本并在您的 mm.cfg 文件中设置 DisplayGPUBlendsetting

注意:从运行时首次执行渲染传递之前运行的 ActionScript 引用此属性时,此属性始终为 false。例如,如果您从 Adobe Flash Professional 的第 1 帧的脚本检查 wmodeGPU,而且您的 SWF 文件是运行时新实例中加载的第一个 SWF 文件,则 wmodeGPU 值为 false。至少发生一次渲染传递后,才能获取精确值。如果为 DisplayObjectexitFrame 事件编写事件侦听器,则 wmodeGPU 值是正确的值。

以下示例在渲染显示对象 mySprite 后检查 wmodeGPU 属性,使您可以获取精确值。 mySprite.addEventListener(EXIT_FRAME, exithandler): function exithandler(exiteventobject:Event):void { trace(stage.wmodeGPU); }
DisplayObject exitFrame 事件
NativeWindowInitOptions NativeWindowInitOptions 类定义用于构造新的 NativeWindow 实例的初始化选项。Object NativeWindowInitOptions 类定义用于构造新的 NativeWindow 实例的初始化选项。

创建窗口后,不能更改初始化选项中定义的属性。

注意:对于由 AIR 自动创建的初始应用程序窗口,所有这些属性(type 除外)均在应用程序的描述符中设置。初始窗口的类型始终为 NativeWindowType.NORMAL

flash.display.NativeWindowflash.display.NativeWindowTypeflash.display.NativeWindowSystemChromeNativeWindowInitOptions 创建新的 NativeWindowInitOptions 对象。 创建新的 NativeWindowInitOptions 对象。

新创建的对象的默认值为:

  • systemChrome = NativeWindowSystemChrome.STANDARD
  • type = NativeWindowType.NORMAL
  • transparent = false
  • owner = null
  • resizable = true
  • maximizable = true
  • minimizable = true
maximizable 指定用户是否可以最大化窗口。Booleantrue 指定用户是否可以最大化窗口。

对于带有系统镶边的窗口,此设置将影响窗口最大化按钮的外观。它还将影响系统管理的用户界面的其他部分,比如 Microsoft Windows 中的窗口菜单。

设置为 false 时,用户将无法最大化窗口。直接调用 NativeWindow maximize() 方法可使窗口最大化。

操作系统行为注意事项:

  • 在某些操作系统中(比如 Mac OS X),最大化窗口后并不会阻止调整窗口大小,若要阻止窗口缩放或调整大小,maximizableresizable 必须同时设置为 false
  • 即使在 maximizable 属性设置为 false 时,某些 Linux 窗口管理器也允许用户最大化窗口。
flash.display.NativeWindow.displayState
minimizable 指定用户是否可以最小化窗口。Booleantrue 指定用户是否可以最小化窗口。

对于带有系统镶边的窗口,此设置将影响窗口最小化按钮的外观。它还将影响系统管理的用户界面的其他部分,比如 Microsoft Windows 中的窗口菜单。

设置为 false 时,用户将无法最小化窗口。直接调用 NativeWindow minimize() 方法可使窗口最小化。

注意:即使在 minimizable 属性设置为 false 时,某些 Linux 窗口管理器也允许用户最小化窗口。

flash.display.NativeWindow.displayState
owner 指定应该拥有使用此 NativeWindowInitOptions 创建的任何窗口的 NativeWindow 对象。flash.display:NativeWindow<code>null</code> 指定应该拥有使用此 NativeWindowInitOptions 创建的任何窗口的 NativeWindow 对象。

当窗口具有所有者时,该窗口始终显示在其所有者的前面,随其所有者一起最小化和隐藏,在其所有者关闭时关闭。

flash.display.NativeWindow.ownerflash.display.NativeWindow.listOwnedWindows()
resizable 指定用户是否可以调整窗口大小。Booleantrue 指定用户是否可以调整窗口大小。

设置为 false 时,用户无法使用系统镶边调整窗口大小。在发生鼠标事件时调用 NativeWindow startResize() 方法可以允许用户调整窗口大小。直接设置窗口边界也可更改窗口大小。

操作系统行为注意事项:

  • 在某些操作系统中(比如 Mac OS X),最大化窗口是一种调整大小操作,若要阻止窗口缩放或调整大小,maximizableresizable 必须同时设置为 false
  • 即使在 resizable 属性设置为 false 时,某些 Linux 窗口管理器也允许用户调整窗口大小。
flash.display.NativeWindow.bounds
systemChrome 指定是否为窗口提供系统镶边。StringNativeWindowSystemChrome.STANDARD 指定是否为窗口提供系统镶边。

镶边指的是允许用户控制窗口的桌面属性的窗口控件。系统镶边使用桌面环境的标准控件,其中可以运行 AIR 应用程序,并符合本机操作系统的标准外观。

要使用由框架(诸如 Flex)提供的镶边,或要提供您自己的窗口镶边,请将 systemChrome 设置为 NativeWindowSystemChrome.NONE

用作此属性的有效值的常数在 NativeWindowSystemChrome 类中定义:

  • NativeWindowSystemChrome.NONE
  • NativeWindowSystemChrome.STANDARD

如果未指定,systemChrome 的默认值为 NativeWindowSystemChrome.STANDARD

对于带有系统镶边的窗口,不支持将 transparent 属性设置为 true

flash.display.NativeWindowSystemChrome
transparent 指定窗口是否支持针对桌面的透明度和 Alpha 混合。Booleanfalse 指定窗口是否支持针对桌面的透明度和 Alpha 混合。

如果为 true,则窗口显示与桌面复合。窗口中未被显示对象覆盖的区域或被 Alpha 设置接近 0 的显示对象覆盖的区域,从效果上说是不可见的,不会截获鼠标事件(窗口下面的桌面对象将接收这些事件)。对象不再截获鼠标事件时的 Alpha 值在大约 0.06 和 0.01 之间变化,具体取决于操作系统。

对于带有系统镶边的窗口,不支持将 transparent 属性设置为 true

注意:并非所有 Linux 窗口管理器都支持透明效果。在这种系统上,窗口的透明区域为与黑色的复合色。

type 指定要创建的窗口的类型。StringNativeWindowType.NORMAL 指定要创建的窗口的类型。

用作此属性的有效值的常量在 NativeWindowType 类中定义:

  • NativeWindowType.NORMAL -- 一个典型窗口。普通窗口使用全尺寸镶边,并显示在 Windows 或 Linux 任务栏中。
  • NativeWindowType.UTILITY -- 一个工具调板。实用程序窗口使用较细的系统镶边,而且不显示在 Windows 的任务栏中。
  • NativeWindowType.LIGHTWEIGHT — 轻量窗口不能包含系统镶边,而且不显示在 Windows 或 Linux 任务栏中。此外,在 Windows 中轻量型窗口没有系统菜单(Alt+空格键)。轻量型窗口适用于通知气泡和控件,比如用于可打开一个短期显示区域的组合框。使用轻量类型时,必须将 systemChrome 设置为 NativeWindowSystemChrome.NONE

如果未指定,type 的默认值为 NativeWindowType.NORMAL

flash.display.NativeWindowType
ShaderParameter ShaderParameter 实例表示着色器内核的单一输入参数。Object ShaderParameter 实例表示着色器内核的单一输入参数。可以将内核定义为接受在内核执行过程中使用的 0 个、1 个或更多参数。ShaderParameter 提供有关参数的信息,比如参数所需数据的类型。它还提供一个机制,用于设置在着色器执行时使用的参数值。要为着色器参数指定一个或多个值,请创建包含这个值或这些值的数组,并将其赋予 value 属性。

表示 Shader 实例的参数的 ShaderParameter 实例将作为 Shader 实例的 data 属性的一个属性进行访问。ShaderParameter 属性的名称与着色器代码中参数的名称相同。例如,如果着色器定义一个名为 radius 的参数,则表示 radius 参数的 ShaderParameter 实例可作为 radius 属性使用,如下所示:

var radiusParam:ShaderParameter = myShader.data.radius;

除了 ShaderParameter 类的已定义属性外,每个 ShaderParameter 实例还具有与为参数定义的任何元数据对应的附加属性。创建 ShaderParameter 对象时会将这些属性添加到该对象中。这些属性的名称与着色器源代码中指定的元数据名称相匹配。每个属性的数据类型因对应元数据的数据类型而异。文本元数据值(如“description”)是 String 实例。具有非字符串值(如 minValuedefaultValue)的元数据属性表示为 Array 实例。元素的数量和元素数据类型对应于元数据值。

例如,假设一个着色器包括以下两个参数声明:

parameter float2 size < description: "The size of the image to which the kernel is applied"; minValue: float2(0.0, 0.0); maxValue: float2(100.0, 100.0); defaultValue: float2(50.0, 50.0); >; parameter float radius < description: "The radius of the effect"; minValue: 0.0; maxValue: 50.0; defaultValue: 25.0; >;

对应于 size 参数的 ShaderParameter 实例除了其内置属性外还具有以下元数据属性:

属性名称数据类型name字符串"size"description字符串"The size of the image to which the kernel is applied"minValueArray[0, 0]maxValueArray[100, 100]defaultValueArray[50, 50]

对应于 radius 参数的 ShaderParameter 具有以下附加属性:

属性名称数据类型name字符串"radius"description字符串"The radius of the effect"minValueArray[0]maxValueArray[50]defaultValueArray[25]

通常,开发人员代码不直接创建 ShaderParameter 实例。在创建 Shader 实例时,将为着色器的每个参数创建一个 ShaderParameter 实例。

flash.display.ShaderDataflash.display.Shader.dataShaderParameter 创建 ShaderParameter 实例。 创建 ShaderParameter 实例。开发人员代码不直接调用 ShaderParameter 构造函数。在创建 Shader 实例时,将为着色器的每个参数创建一个 ShaderParameter 实例。 index 参数的从 0 开始的索引。int 参数的从 0 开始的索引。 type 着色器中定义的参数的数据类型。String 着色器中定义的参数的数据类型。type 属性的可能值的集合由 ShaderParameterType 类中的常量定义。 flash.display.ShaderParameterTypevalue 以参数值形式传入到着色器的一个或多个值。Array 以参数值形式传入到着色器的一个或多个值。value 属性为索引数组。数组元素的数量和类型对应于参数的数据类型(可使用 type 属性确定)。

下表表示参数类型以及 value 数组元素的对应数量和数据类型:

参数类型元素数量元素数据类型float (ShaderParameterType.FLOAT)1Numberfloat2 (ShaderParameterType.FLOAT2)2Numberfloat3 (ShaderParameterType.FLOAT3)3Numberfloat4 (ShaderParameterType.FLOAT4)4Numberint (ShaderParameterType.INT)1int 或 uintint2 (ShaderParameterType.INT2)2int 或 uintint3 (ShaderParameterType.INT3)3int 或 uintint4 (ShaderParameterType.INT4)4int 或 uintbool (ShaderParameterType.BOOL)1Booleanbool2 (ShaderParameterType.BOOL2)2Booleanbool3 (ShaderParameterType.BOOL3)3Booleanbool4 (ShaderParameterType.BOOL4)4Booleanfloat2x2 (ShaderParameterType.MATRIX2X2)4Numberfloat3x3 (ShaderParameterType.MATRIX3X3)9Numberfloat4x4 (ShaderParameterType.MATRIX4X4)16Number

对于矩阵参数类型,数组元素将填充矩阵的行,然后填充列。例如,假设使用以下 ActionScript 行来填充名为 myMatrixfloat2x2 参数:

myShader.data.myMatrix.value = [.1, .2, .3, .4];

在着色器内,矩阵元素具有以下值:

  • myMatrix[0][0]: .1
  • myMatrix[0][1]: .2
  • myMatrix[1][0]: .3
  • myMatrix[1][1]: .4
GradientType GradientType 类为 flash.display.Graphics 类的 beginGradientFill() 和 lineGradientStyle() 方法中的 type 参数提供值。Object GradientType 类为 flash.display.Graphics 类的 beginGradientFill()lineGradientStyle() 方法中的 type 参数提供值。 LINEAR 用于指定线性渐变填充的值。linearString 用于指定线性渐变填充的值。 RADIAL 用于指定放射状渐变填充的值。radialString 用于指定放射状渐变填充的值。 InterpolationMethod InterpolationMethod 类为 Graphics.beginGradientFill() 和 Graphics.lineGradientStyle() 方法中的 interpolationMethod 参数提供值。Object InterpolationMethod 类为 Graphics.beginGradientFill()Graphics.lineGradientStyle() 方法中的 interpolationMethod 参数提供值。此参数确定在呈现渐变时所用的 RGB 空间。 flash.display.Graphics.beginGradientFill()flash.display.Graphics.lineGradientStyle()LINEAR_RGB 指定应使用线性 RGB 插值方法。linearRGBString 指定应使用线性 RGB 插值方法。这意味着使用基于线性 RGB 颜色模型的 RGB 颜色空间。 RGBRGB 指定应使用 RGB 插值方法。rgbString 指定应使用 RGB 插值方法。这意味着使用指数式 sRGB(标准 RGB)空间来呈现渐变。sRGB 空间是一种 W3C 批准的标准,用于定义红色、绿色和蓝色成分值和可见成分颜色实际浓度之间的非线性转换。

例如,假设有两种颜色之间的简单线性渐变(spreadMethod 参数设置为 SpreadMethod.REFLECT)。不同的插值方法对外观的影响如下所示:

InterpolationMethod.LINEAR_RGBInterpolationMethod.RGB
LINEAR_RGB
IGraphicsPath 此接口用于定义可用作 flash.display.Graphics 方法和绘图类中的路径参数的对象。 此接口用于定义可用作 flash.display.Graphics 方法和绘图类中的路径参数的对象。使用此接口的实现器类来创建和管理路径属性数据,并将相同的数据重新用于不同的实例。 flash.display.Graphics.drawGraphicsData()flash.display.Graphics.drawPath()IGraphicsFill 此接口用于定义可用作 flash.display.Graphics 方法和绘图类中的填充参数的对象。 此接口用于定义可用作 flash.display.Graphics 方法和绘图类中的填充参数的对象。使用此接口的实现器类来创建和管理填充属性数据,并将相同的数据重新用于不同的实例。 flash.display.Graphics.drawGraphicsData()flash.display.GraphicsStroke.fillLoaderInfo LoaderInfo 类可提供有关已加载的 SWF 文件或图像文件(JPEG、GIF 或 PNG)的信息。flash.events:EventDispatcher LoaderInfo 类可提供有关已加载的 SWF 文件或图像文件(JPEG、GIF 或 PNG)的信息。LoaderInfo 对象可用于任何显示对象。提供的信息包括加载进度、加载程序的 URL 和加载内容、媒体的字节总数以及媒体的标示的高度和宽度。

您可以通过以下两种方法访问 LoaderInfo 对象:

  • flash.display.Loader 对象的 contentLoaderInfo 属性 -- contentLoaderInfo 属性始终可用于任何 Loader 对象。对于尚未调用 load()loadBytes() 方法,或者尚未充分加载的 Loader 对象,在尝试访问 contentLoaderInfo 属性的多个属性时,将引发错误。
  • 显示对象的 loaderInfo 属性。

Loader 对象的 contentLoaderInfo 属性提供有关 Loader 对象正在加载的内容的信息,而 DisplayObject 的 loaderInfo 属性提供有关该显示对象的根 SWF 文件的信息。

当使用 Loader 对象加载显示对象(如 SWF 文件或位图)时,显示对象的 loaderInfo 属性与 Loader 对象 (DisplayObject.loaderInfo = Loader.contentLoaderInfo) 的 contentLoaderInfo 属性相同。由于 SWF 文件的主类的实例没有 Loader 对象,因此 loaderInfo 属性是访问 SWF 文件主类实例的 LoaderInfo 的唯一方法。

下图显示了对于 SWF 文件主类实例、Loader 对象的 contentLoaderInfo 属性以及加载对象的 loaderInfo 属性,LoaderInfo 对象的不同用法:

在加载操作未完成时,Loader 对象的 contentLoaderInfo 属性的某些属性不可用。您可以获得某些属性,如 bytesLoadedbytesTotalurlloaderURLapplicationDomain。当 loaderInfo 对象调度 init 事件时,您可以访问 loaderInfo 对象以及加载的图像或 SWF 文件的所有属性。

注意:LoaderInfo 对象的所有属性都是只读的。

EventDispatcher.dispatchEvent() 方法不适用于 LoaderInfo 对象。如果在 LoaderInfo 对象上调用 dispatchEvent(),将引发 IllegalOperationError 异常。

下例使用 LoaderInfoExample 类在舞台上显示一幅图像。执行下列步骤可完成此操作:
  1. 属性 url被创建,该属性是图像的位置和名称。
  2. 类构造函数创建一个名为 loader 的 Loader 对象。
  3. loader 对象将事件侦听器进行实例化,以确保图像正确加载。
  4. 构造函数创建一个 URLRequest 对象的新实例 request,该实例带有传递的 url,这样,就可以知道文件的名称和位置。
  5. 然后,request 对象被传递给 loader 对象的 load() 方法,该方法会将图像加载到显示列表上。

重要提示:该示例要求您在编译的 SWF 文件所在的目录中添加一个名为 Image.gif 的文件。使用具有一个适合主 SWF 文件尺寸的区域的图像。

package { import flash.display.Loader; import flash.display.LoaderInfo; import flash.display.Sprite; import flash.events.*; import flash.net.URLRequest; public class LoaderInfoExample extends Sprite { private var url:String = "Image.gif"; public function LoaderInfoExample() { var loader:Loader = new Loader(); loader.contentLoaderInfo.addEventListener(Event.INIT, initHandler); loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); var request:URLRequest = new URLRequest(url); loader.load(request); addChild(loader); } private function initHandler(event:Event):void { var loader:Loader = Loader(event.target.loader); var info:LoaderInfo = LoaderInfo(loader.contentLoaderInfo); trace("initHandler: loaderURL=" + info.loaderURL + " url=" + info.url); } private function ioErrorHandler(event:IOErrorEvent):void { trace("ioErrorHandler: " + event); } } }
flash.display.Loaderflash.display.Loader.contentflash.display.DisplayObjectflash.display.DisplayObject.loaderInfohttpStatus 在通过 HTTP 发出网络请求并且可以检测到 HTTP 状态代码时调度。flash.events.HTTPStatusEvent.HTTP_STATUSflash.events.HTTPStatusEvent 在通过 HTTP 发出网络请求并且可以检测到 HTTP 状态代码时调度。 Loader.load()unload 每次使用 Loader 对象的 unload() 方法删除已加载对象时,或者当同一 Loader 对象执行第二次加载并且在加载开始之前删除了原始内容时,由 LoaderInfo 对象调度。flash.events.Event.UNLOADflash.events.Event 当使用 Loader 对象的 unload() 方法删除已加载对象时,或者当同一 Loader 对象执行第二次加载并且在加载开始之前删除了原始内容时,由 LoaderInfo 对象调度。 Loader.load()Loader.unload()progress 在下载操作过程中收到数据时调度。flash.events.ProgressEvent.PROGRESSflash.events.ProgressEvent 在下载操作过程中收到数据时调度。 Loader.load()open 在加载操作开始时调度。flash.events.Event.OPENflash.events.Event 在加载操作开始时调度。 Loader.load()ioError 在发生导致加载操作失败的输入或输出错误时调度。flash.events.IOErrorEvent.IO_ERRORflash.events.IOErrorEvent 在发生导致加载操作失败的输入或输出错误时调度。 Loader.load()init 当已加载的 SWF 文件的属性和方法可供访问并做好使用准备时进行调度。flash.events.Event.INITflash.events.Event 当已加载的 SWF 文件的属性和方法可供访问并做好使用准备时进行调度。不过,内容可能仍在下载之中。如果存在以下条件,则 LoaderInfo 对象将调度 init 事件:
  • 可以访问与加载的对象关联的所有属性和方法以及与 LoaderInfo 对象关联的属性和方法。
  • 所有子对象的构造函数已完成。
  • 已执行所加载的 SWF 主时间轴的第一帧中的所有 ActionScript 代码。

例如,在加载影片或动画的第一帧时将调度 Event.INIT。然后,影片将可供访问并可添加到显示列表中。不过,下载完整的影片可能需要花更长的时间。只有在加载了完整的影片之后才会调度 Event.COMPLETE

init 事件始终在 complete 事件之前。

Loader.load()
complete 成功加载数据后调度。flash.events.Event.COMPLETEflash.events.Event 成功加载数据后调度。也就是说,当已下载所有内容并且已完成加载过程时调度它。complete 事件始终在 init 事件之后调度。当该对象已做好访问准备(尽管可能仍在下载内容)时,将调度 init 事件。 Loader.load()getLoaderInfoByDefinition 返回与定义为对象的 SWF 文件相关联的 LoaderInfo 对象。调用方不在本地受信任沙箱中运行。 SecurityErrorSecurityError关联的 LoaderInfo 对象。当在非调试器构建中调用时(或未启用调试时),或当引用的 object 没有相关联的 LoaderInfo 对象(比如由 AIR 运行时使用的某些对象)时,返回 nullflash.display:LoaderInfoobjectObject要为其获取关联 LoaderInfo 对象的对象。 返回与定义为对象的 SWF 文件相关联的 LoaderInfo 对象。 actionScriptVersion 被加载的 SWF 文件的 ActionScript 版本。uint如果文件未完整下载,不足以检索到所请求的信息。 ErrorError如果文件不是 SWF 文件。 ErrorError 被加载的 SWF 文件的 ActionScript 版本。通过使用 ActionScriptVersion 类中的枚举(如 ActionScriptVersion.ACTIONSCRIPT2ActionScriptVersion.ACTIONSCRIPT3)来指定语言版本。

注意:此属性始终具有值 ActionScriptVersion.ACTIONSCRIPT2ActionScriptVersion.ACTIONSCRIPT3。ActionScript 1.0 和 2.0 都被报告为 ActionScriptVersion.ACTIONSCRIPT2(版本 2.0)。此属性只对 ActionScript 1.0 和 2.0 与 ActionScript 3.0 进行区分。

flash.display.ActionScriptVersion
applicationDomain 加载外部 SWF 文件后,包含在已加载类中的所有 ActionScript 3.0 定义将存储在 applicationDomain 属性中。flash.system:ApplicationDomain不允许调用方的此安全沙箱访问此 ApplicationDomain。 SecurityErrorSecurityError 加载外部 SWF 文件后,包含在已加载类中的所有 ActionScript 3.0 定义将存储在 applicationDomain 属性中。

SWF 文件中的所有代码被定义为存在于应用程序域中。主应用程序就在当前的应用程序域中运行。系统域包含所有应用程序域,包括当前域和由 Flash Player 或 Adobe AIR 使用的所有类。

所有应用程序域(系统域除外)都有关联的父域。主应用程序的 applicationDomain 的父域为系统域。已加载的类仅在其父级中没有相关定义时才进行定义。不能用较新的定义覆盖已加载的类定义。

有关应用程序域的使用示例,请参阅《ActionScript 3.0 开发人员指南》中的“客户端系统环境”一章。

flash.system.ApplicationDomain
bytesLoaded 媒体已加载的字节数。uint 媒体已加载的字节数。如果此数字与 bytesTotal 的值相等,则会加载所有字节。 bytesTotal 整个媒体文件中压缩的字节数。uint 整个媒体文件中压缩的字节数。

在此 LoaderInfo 对象相应的 Loader 对象调度第一个 progress 事件之前,bytesTotal 为 0。在该 Loader 对象调度第一个 progress 事件之后,bytesTotal 反映的是要下载的实际字节数。

flash.events.ProgressEventflash.display.Loader
bytes 与 LoaderInfo 对象相关联的字节数。flash.utils:ByteArray如果由于安全限制的缘故而阻止访问此 API 的对象访问加载的对象。例如,如果 Loader 对象尝试访问 contentLoaderInfo.content 属性,但未向其授予访问加载的内容的安全权限,则可能会出现此情况。

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

SecurityErrorSecurityError
与 LoaderInfo 对象相关联的字节数。
childAllowsParent 表示内容(子级)对加载者(父级)的信任关系。Boolean 文件未完整下载而不足以检索到所请求的信息时引发。 ErrorError 表示内容(子级)对加载者(父级)的信任关系。如果子项允许父项访问,则为 true;否则为 false。如果子对象已调用 allowDomain() 方法向父域授予权限,或者在子域中加载了向父域授予权限的 URL 策略,则将此属性设置为 true。如果子级和父级在同一域中,则此属性设置为 true

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

childSandboxBridge 一个对象,它可以通过所加载内容的代码进行设置以公开可以由 Loader 对象的沙箱中的代码访问的属性和方法。Object只有所加载内容的沙箱中的内容可以设置此属性。 SecurityErrorSecurityError 一个对象,它可以通过所加载内容的代码进行设置以公开可以由 Loader 对象的沙箱中的代码访问的属性和方法。此沙箱桥 使来自非应用程序域的内容对 AIR 应用程序沙箱中的脚本具有受控的访问权,反之亦然。沙箱桥充当沙箱之间的通道,在应用程序安全沙箱和非应用程序安全沙箱之间提供显式交互。 parentSandboxBridgecontentType 被加载文件的 MIME 类型。String 被加载文件的 MIME 类型。如果所加载的文件内容不足以确定类型,则该值为 null。以下列表给出了可能的值:
  • "application/x-shockwave-flash"
  • "image/jpeg"
  • "image/gif"
  • "image/png"
content 与此 LoaderInfo 对象关联的已加载对象。flash.display:DisplayObject如果由于安全限制的缘故而阻止访问此 API 的对象访问加载的对象。例如,如果 Loader 对象尝试访问 contentLoaderInfo.content 属性,但未向其授予访问加载的内容的安全权限,则可能会出现此情况。

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

SecurityErrorSecurityError
与此 LoaderInfo 对象关联的已加载对象。
frameRate 被加载的 SWF 文件的标示的帧速率,以每秒帧数为单位。Number如果文件未完整下载,不足以检索到所请求的信息。 ErrorError如果文件不是 SWF 文件。 ErrorError 被加载的 SWF 文件的标示的帧速率,以每秒帧数为单位。此数字通常是整数,但并不需要是整数。

此值可能与使用时的实际帧速率不同。Flash Player 或 Adobe AIR 在任何时候为所有加载的 SWF 文件只使用单个帧速率,此帧速率由主 SWF 文件的标称帧速率确定。此外,根据硬件、声音同步和其他因素,可能无法达到主帧速率。

height 加载文件的标示的高度。int如果文件未完整下载,不足以检索到所请求的信息。 ErrorError 加载文件的标示的高度。此值可能与所显示内容的实际高度不同,因为被加载的内容或其父显示对象可能被缩放。 isURLInaccessible 表示 LoaderInfo.url 属性是否已截断。Boolean 表示 LoaderInfo.url 属性是否已截断。当 isURLInaccessible 值为 true 时,LoaderInfo.url 值只是从中加载内容的最终 URL 的域。例如,如果从 http://www.adobe.com/assets/hello.swf 加载内容,并且 LoaderInfo.url 属性的值为 http://www.adobe.com,则此属性会被截断。仅当下列所有值也全部为 true 时,isURLInaccessible 值才为 true
  • 当加载此内容时,发生 HTTP 重定向。
  • 调用 Loader.load() 的 SWF 文件所在域与此内容的最终 URL 所在域不同。
  • 调用 Loader.load() 的 SWF 文件不具有访问此内容的权限。授予访问此内容的权限的方式与为 BitmapData.draw() 授予权限的方式相同:调用 Security.allowDomain() 以访问 SWF 文件(或对于非 SWF 文件内容,建立一个策略文件并使用 LoaderContext.checkPolicyFile 属性)。

注意:isURLInaccessible 属性是为 Flash Player 10.1 和 AIR 2.0 添加的。但是,如果 Flash 运行时支持该属性,则该属性适用于所有版本的 SWF 文件。因此,在“严谨模式”下使用某些创作工具会导致出现编译错误。要避免出现此错误,请使用间接语法 myLoaderInfo["isURLInaccessible"],或禁用严谨模式。如果您使用的是 Flash Professional CS5 或 Flex SDK 4.1,则可以对在 Flash Player 10.1 和 AIR 2 之前发布的运行时使用和编译此 API。

对于 AIR 中的应用程序内容,该属性的值始终为 false

urlBitmapData.draw()flash.system.Security.allowDomain()flash.system.LoaderContext.checkPolicyFile
loaderURL SWF 文件的 URL,该 SWF 文件启动对此 LoaderInfo 对象所描述的媒体的加载。String SWF 文件的 URL,该 SWF 文件启动对此 LoaderInfo 对象所描述的媒体的加载。对于 SWF 文件的主类的实例,此 URL 与 SWF 文件自己的 URL 相同。 loader 与此 LoaderInfo 对象关联的 Loader 对象。flash.display:Loader如果由于安全限制的缘故而阻止访问此 API 的对象访问 Loader 对象。例如,如果加载的 SWF 文件尝试访问其 loaderInfo.loader 属性,但未向其授予访问正在加载的 SWF 文件的安全权限,则可能会出现此情况。

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

SecurityErrorSecurityError
与此 LoaderInfo 对象关联的 Loader 对象。如果此 LoaderInfo 对象是 SWF 文件的主类实例的 loaderInfo 属性,则没有关联的 Loader 对象。
parameters 包含名称-值对的对象,表示为被加载的 SWF 文件提供的参数。Object 包含名称-值对的对象,表示为被加载的 SWF 文件提供的参数。

可以使用 for-in 循环来提取 parameters 对象中的所有名称和值。

参数的两个源为:主 SWF 文件的 URL 中的查询字符串和 FlashVars HTML 参数(这只影响主 SWF 文件)的值。

parameters 属性替换了 ActionScript 1.0 和 2.0 提供 SWF 文件参数作为主时间轴的技术。

Loader 对象(该对象包含使用 ActionScript 1.0 或 2.0 的 SWF 文件)的 parameters 属性的值为 null。只有对于包含使用 ActionScript 3.0 的 SWF 文件的 Loader 对象,该值才非 null。

parentAllowsChild 表示加载者(父级)对内容(子级)的信任关系。Boolean 文件未完整下载而不足以检索到所请求的信息时引发。 ErrorError 表示加载者(父级)对内容(子级)的信任关系。如果父项允许子项访问,则为 true;否则为 false。如果父对象调用了 allowDomain() 方法向子域授予权限,或者在父域中加载了向子域授予权限的 URL 策略文件,则将此属性设置为 true。如果子级和父级在同一域中,则此属性设置为 true

有关安全性的详细信息,请参阅 Flash Player 开发人员中心主题:安全性

parentSandboxBridge 一个对象,它可以在 Loader 对象的沙箱中通过代码进行设置以公开可以由所加载内容的代码访问的属性和方法。Object只有 Loader 对象的沙箱中的内容可以设置此属性。 SecurityErrorSecurityError 一个对象,它可以在 Loader 对象的沙箱中通过代码进行设置以公开可以由所加载内容的代码访问的属性和方法。此沙箱桥 使来自非应用程序域的内容对 AIR 应用程序沙箱中的脚本具有受控的访问权,反之亦然。沙箱桥充当沙箱之间的通道,在应用程序安全沙箱和非应用程序安全沙箱之间提供显式交互。 childSandboxBridgesameDomain 表示加载者和内容之间的域关系:如果它们具有相同的原始域,则为 true;否则为 false。Boolean 文件未完整下载而不足以检索到所请求的信息时引发。 ErrorError 表示加载者和内容之间的域关系:如果它们具有相同的原始域,则为 true;否则为 falsesharedEvents EventDispatcher 实例,可用于跨安全边界交换事件。flash.events:EventDispatcher EventDispatcher 实例,可用于跨安全边界交换事件。即使 Loader 对象和加载的内容源于彼此不信任的安全域,两者仍然可以访问 sharedEvents 并通过此对象发送和接收事件。 swfVersion 已加载的 SWF 文件的文件格式版本。uint如果文件未完整下载,不足以检索到所请求的信息。 ErrorError如果文件不是 SWF 文件。 ErrorError 已加载的 SWF 文件的文件格式版本。使用 SWFVersion 类(如 SWFVersion.FLASH7SWFVersion.FLASH9)中的枚举指定文件格式。 flash.display.SWFVersionuncaughtErrorEvents 一个在此 LoaderInfo 对象的 SWF 文件中的代码中发生无法处理的错误时调度 uncaughtError 事件的对象。flash.events:UncaughtErrorEvents 一个在此 LoaderInfo 对象的 SWF 文件中的代码中发生无法处理的错误时调度 uncaughtError 事件的对象。当任何 try..catch 块引发错误时,或调度的 ErrorEvent 对象没有注册的侦听器时,会发生未被捕获的错误。

当与此 LoaderInfo 关联的 SWF 完成加载时,会创建此属性。在此之前,uncaughtErrorEvents 属性保持为 null。在只包含 ActionScript 的项目中,可以在 SWF 文件主类的构造函数执行期间或执行后访问此属性。对于 Flex 项目,uncaughtErrorEvents 属性在调度 applicationComplete 事件之后可用。

以下示例演示了使用未被捕获的错误事件处理程序检测 ActionScript 项目中的未被捕获的错误的过程。此示例定义了一个 uncaughtError 事件处理程序来检测未被捕获的错误。此示例还提供了一个按钮,如果单击该按钮,将引发由未被捕获的错误处理程序捕获的错误。

在构造函数中,代码为由 LoaderInfo 对象的 uncaughtErrorEvents 属性调度的 uncaughtError 事件注册了一个侦听器。

uncaughtErrorHandler() 方法中,代码检查 error 属性的数据类型并做出相应的响应。

package { import flash.display.Sprite; import flash.events.ErrorEvent; import flash.events.MouseEvent; import flash.events.UncaughtErrorEvent; public class UncaughtErrorEventExample extends Sprite { public function UncaughtErrorEventExample() { loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaughtErrorHandler); drawUI(); } private function uncaughtErrorHandler(event:UncaughtErrorEvent):void { if (event.error is Error) { var error:Error = event.error as Error; // do something with the error } else if (event.error is ErrorEvent) { var errorEvent:ErrorEvent = event.error as ErrorEvent; // do something with the error } else { // a non-Error, non-ErrorEvent type was thrown and uncaught } } private function drawUI():void { var btn:Sprite = new Sprite(); btn.graphics.clear(); btn.graphics.beginFill(0xFFCC00); btn.graphics.drawRect(0, 0, 100, 50); btn.graphics.endFill(); addChild(btn); btn.addEventListener(MouseEvent.CLICK, clickHandler); } private function clickHandler(event:MouseEvent):void { throw new Error("Gak!"); } } }
以下示例是与上述示例相同的 Flex 示例,将使用 MXML 文档而不是 ActionScript 类作为根内容。 <?xml version="1.0" encoding="utf-8"?> <s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark" xmlns:mx="library://ns.adobe.com/flex/halo" applicationComplete="applicationCompleteHandler();"> <fx:Script> <![CDATA[ import flash.events.ErrorEvent; import flash.events.MouseEvent; import flash.events.UncaughtErrorEvent; private function applicationCompleteHandler():void { loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaughtErrorHandler); } private function uncaughtErrorHandler(event:UncaughtErrorEvent):void { if (event.error is Error) { var error:Error = event.error as Error; // do something with the error } else if (event.error is ErrorEvent) { var errorEvent:ErrorEvent = event.error as ErrorEvent; // do something with the error } else { // a non-Error, non-ErrorEvent type was thrown and uncaught } } private function clickHandler(event:MouseEvent):void { throw new Error("Gak!"); } ]]> </fx:Script> <s:Button label="Cause Error" click="clickHandler(event);"/> </s:WindowedApplication>
UncaughtErrorEventLoader.uncaughtErrorEvents
url 所加载媒体的 URL。String 所加载媒体的 URL。

在此 LoaderInfo 对象的对应 Loader 对象调度第一个 progress 事件之前,url 属性的值可能只反映在对 Loader 对象的 load() 方法的调用中指定的初始 URL。在第一个 progress 事件之后,url 属性将在解析了任何重定向和相对 URL 后反映媒体的最终 URL。

在某些情况下,url 属性的值会被截断;有关详细信息,请参阅 isURLInaccessible 属性。

isURLInaccessibleflash.display.Loader.load()
width 被加载内容的标示的宽度。int如果文件未完整下载,不足以检索到所请求的信息。 ErrorError 被加载内容的标示的宽度。此值可能与所显示内容的实际宽度不同,因为被加载的内容或其父显示对象可能被缩放。
StageQuality StageQuality 类为 Stage.quality 属性提供值。Object StageQuality 类为 Stage.quality 属性提供值。 flash.display.Stage.qualityBEST 指定极高呈现品质:使用 4 x 4 像素网格消除图形锯齿,并且始终对位图进行平滑处理。bestString 指定极高呈现品质:使用 4 x 4 像素网格消除图形锯齿,并且始终对位图进行平滑处理。 HIGH 指定高呈现品质:使用 4 x 4 像素网格消除图形锯齿,并且如果影片是静态的,则还对位图进行平滑处理。highString 指定高呈现品质:使用 4 x 4 像素网格消除图形锯齿,并且如果影片是静态的,则还对位图进行平滑处理。 LOW 指定低呈现品质:不消除图形的锯齿,不对位图进行平滑处理。lowString 指定低呈现品质:不消除图形的锯齿,不对位图进行平滑处理。 MEDIUM 指定中等呈现品质:使用 2 x 2 像素网格消除图形锯齿,但不对位图进行平滑处理。mediumString 指定中等呈现品质:使用 2 x 2 像素网格消除图形锯齿,但不对位图进行平滑处理。此设置适用于不包含文本的影片。 BitmapData 使用 BitmapData 类可以处理 Bitmap 对象的位图图像的数据(像素)。允许使用 Bitmap 对象的位图数据。 flash.display:IBitmapDrawableObject 使用 BitmapData 类,您可以处理 Bitmap 对象的数据(像素)。可以使用 BitmapData 类的方法创建任意大小的透明或不透明位图图像,并在运行时采用多种方式操作这些图像。也可以访问使用 flash.display.Loader 类加载的位图图像的 BitmapData。

此类允许您将位图呈现操作与 Flash Player 的内部显示更新例程分隔开来。通过直接操作 BitmapData 对象,您可以创建复杂的图像,不会因连续重新绘制矢量数据的内容而产生每帧开销。

BitmapData 类的方法支持通过可用于非位图显示对象的滤镜无法得到的效果。

BitmapData 对象包含像素数据的数组。此数据可以表示完全不透明的位图,或表示包含 Alpha 通道数据的透明位图。以上任一类型的 BitmapData 对象都作为 32 位整数的缓冲区进行存储。每个 32 位整数确定位图中单个像素的属性。

每个 32 位整数都是四个 8 位通道值(从 0 到 255)的组合,这些值描述像素的 Alpha 透明度以及红色、绿色、蓝色 (ARGB) 值。(对于 ARGB 值,最高有效字节代表 Alpha 通道值,其后的有效字节分别代表红色、绿色和蓝色通道值。)

将这四个通道(Alpha、红色、绿色和蓝色)与 BitmapData.copyChannel() 方法或 DisplacementMapFilter.componentXDisplacementMapFilter.componentY 属性一起使用时,这些通道以数字形式表示,并且这些数字在 BitmapDataChannel 类中由以下常量表示:

  • BitmapDataChannel.ALPHA
  • BitmapDataChannel.RED
  • BitmapDataChannel.GREEN
  • BitmapDataChannel.BLUE

通过使用 Bitmap 对象的 bitmapData 属性,可以将 BitmapData 对象附加到 Bitmap 对象。

可以使用 Graphics.beginBitmapFill() 方法用 BitmapData 对象填充 Graphics 对象。

在 AIR 运行时中,DockIcon、Icon、InteractiveIcon 和 SystemTrayIcon 类中的每个类都包括一个 bitmaps 属性,该属性是定义图标的位图图像的 BitmapData 对象的数组。

在 AIR 1.5 和 Flash Player 10 中,BitmapData 对象的最大宽度或高度为 8,191 像素,并且像素总数不能超过 16,777,215 像素。(因此,如果 BitmapData 对象的宽度为 8,191 像素,则其高度只能为 2,048 像素。)在 Flash Player 9 及早期版本和 AIR 1.1 及早期版本中,高度最大为 2,880 像素,宽度最大为 2,880 像素。

如果 BitmapData 对象无效(例如,如果它的 height == 0width == 0),或者已通过 dispose() 处理了该对象,则对 BitmapData 对象的任何方法或属性的调用都会引发 ArgumentError 错误。

下例使用 BitmapDataExample 类将图像 Image.gif 加载到位于默认位置 (0, 0) 的 DisplayObject 中。然后,将 Image.gif 的副本放在原图像的右边,它使用 threshold() 方法。此任务是使用以下步骤完成的:
  1. 创建 url 属性,它是图像文件的位置和名称
  2. 类构造函数创建一个 Loader 对象,该对象随后对一个事件侦听器进行实例化,该事件侦听器的调度是在 completeHandler() 方法完成图像操作以后进行的。
  3. 然后,requestURLRequest 对象被传递给 loader.load(),该方法使用显示对象将图像加载到内存中。
  4. 图像随后将被放在显示列表中,后者将图像显示在屏幕上,坐标为 x = 0, y = 0
  5. 然后,completeHandler() 方法执行以下操作:
    • 创建另一个 Loader 对象以及使用 Loader 对象初始化的 Bitmap 对象。
    • 创建第二个 Bitmap 对象 duplicate,该对象再调用 duplicateImage() 方法,该方法创建原始图像的副本。
    • 创建一个 BitmapData 对象,该对象将被分配给 duplicate 对象的 BitmapData 对象。
    • 创建一个与原始图像具有相同的坐标、宽度和高度的新的 Rectangle 对象。
    • 创建一个新的 Point 对象,其默认为 x = 0, y = 0
    • 创建以下变量:
      • operation -- 当阈值大于或等于原始值时应用新颜色。
      • threshold -- 与每个像素相比较的值(在本例中是 Alpha 值为 0xCC 的浅灰色)。
      • color -- 对通过阈值测试的像素设置的颜色,在本例中为纯黄色。
      • mask -- 正好相反的颜色(透明的蓝色)。
      • copySource -- 设置为 false,指示阈值未通过测试时不复制像素值。该值没有意义,因为图像是重复的,并且只更改通过了阈值测试的像素。
    • 使用前面的变量调用 threshold() 方法。得到的阈值计算式如下所示:if (current pixel Value & 0x000000FF) >= (0xCCCCCCCC & 0x000000FF) then set pixel to 0xFFFFFF00

注意:

  • 您需要编译 SWF 文件,并将“本地播放安全性”设置为“只访问本地文件”。
  • 此示例要求将名为 Image.gif 的文件与您的 SWF 文件放在同一目录中。
  • 建议使用宽度最大约为 80 像素的图像。

package { import flash.display.Bitmap; import flash.display.BitmapData; import flash.display.Loader; import flash.display.Sprite; import flash.events.*; import flash.geom.Point; import flash.geom.Rectangle; import flash.net.URLRequest; public class BitmapDataExample extends Sprite { private var url:String = "Image.gif"; private var size:uint = 80; public function BitmapDataExample() { configureAssets(); } private function configureAssets():void { var loader:Loader = new Loader(); loader.contentLoaderInfo.addEventListener(Event.COMPLETE, completeHandler); loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); var request:URLRequest = new URLRequest(url); loader.x = size * numChildren; loader.load(request); addChild(loader); } private function duplicateImage(original:Bitmap):Bitmap { var image:Bitmap = new Bitmap(original.bitmapData.clone()); image.x = size * numChildren; addChild(image); return image; } private function completeHandler(event:Event):void { var loader:Loader = Loader(event.target.loader); var image:Bitmap = Bitmap(loader.content); var duplicate:Bitmap = duplicateImage(image); var bitmapData:BitmapData = duplicate.bitmapData; var sourceRect:Rectangle = new Rectangle(0, 0, bitmapData.width, bitmapData.height); var destPoint:Point = new Point(); var operation:String = ">="; var threshold:uint = 0xCCCCCCCC; var color:uint = 0xFFFFFF00; var mask:uint = 0x000000FF; var copySource:Boolean = true; bitmapData.threshold(bitmapData, sourceRect, destPoint, operation, threshold, color, mask, copySource); } private function ioErrorHandler(event:IOErrorEvent):void { trace("Unable to load image: " + url); } } }
flash.display.Bitmap.bitmapDataflash.desktop.DockIcon.bitmapsflash.display.Graphics.beginBitmapFill()flash.desktop.Icon.bitmapsflash.desktop.InteractiveIcon.bitmapsflash.display.Loaderflash.desktop.SystemTrayIcon.bitmapsBitmapData 创建一个具有指定的宽度和高度的 BitmapData 对象。宽度和/或高度超过最大尺寸。 ArgumentErrorArgumentErrorwidthint位图图像的宽度,以像素为单位。 heightint位图图像的高度,以像素为单位。 transparentBooleantrue指定位图图像是否支持每个像素具有不同的透明度。默认值为 true(透明)。要创建完全透明的位图,请将 transparent 参数的值设置为 true,将 fillColor 参数的值设置为 0x00000000(或设置为 0)。将 transparent 属性设置为 false 可以略微提升呈现性能。 fillColoruint0xFFFFFFFF用于填充位图图像区域的 32 位 ARGB 颜色值。默认值为 0xFFFFFFFF(纯白色)。 创建一个具有指定的宽度和高度的 BitmapData 对象。如果为 fillColor 参数指定一个值,则位图中的每个像素都将设置为该颜色。

默认情况下,将位图创建为透明位图,除非您为 transparent 参数传递值 false。创建了不透明位图后,将无法将其更改为透明位图。不透明位图中的每个像素仅使用 24 位的颜色通道信息。如果将位图定义为透明,则每个像素将使用 32 位的颜色通道信息,其中包括 Alpha 透明度通道。

在 AIR 1.5 和 Flash Player 10 中,BitmapData 对象的最大宽度或高度为 8,191 像素,并且像素总数不能超过 16,777,215 像素。(因此,如果 BitmapData 对象的宽度为 8,191 像素,则其高度只能为 2,048 像素。)在 Flash Player 9 及早期版本和 AIR 1.1 及早期版本中,高度最大为 2,880 像素,宽度最大为 2,880 像素。如果指定的宽度值或高度值大于 2880,则不会创建新实例。

applyFilter 取得一个源图像和一个滤镜对象,并生成过滤的图像。sourceBitmapData、sourceRect、destPoint 或滤镜为空。 TypeErrorTypeErrorBitmapData 对象的透明度与滤镜操作不兼容。 IllegalOperationErrorflash.errors:IllegalOperationError一个数字,表示是否成功应用了滤镜。如果返回 0,则说明已成功应用了滤镜。如果返回一个负数,则说明在应用该滤镜的过程中出现了错误。 sourceBitmapDataflash.display:BitmapData要使用的输入位图图像。源图像可以是另一个 BitmapData 对象,也可以引用当前 BitmapData 实例。 sourceRectflash.geom:Rectangle定义要用作输入的源图像区域的矩形。 destPointflash.geom:Point目标图像(当前 BitmapData 实例)中与源矩形的左上角对应的点。 filterflash.filters:BitmapFilter用于执行过滤操作的滤镜对象。每种滤镜都有某些要求,如下所示:
  • BlurFilter — 此滤镜可使用不透明或透明的源图像和目标图像。如果这两种图像的格式不匹配,则在过滤过程中生成的源图像副本将与目标图像的格式匹配。
  • BevelFilter、DropShadowFilter、GlowFilter、ChromeFilter — 这些滤镜的目标图像必须是透明图像。调用 DropShadowFilter 或 GlowFilter 会创建包含投影或发光的 Alpha 通道数据的图像。它不会在目标图像上创建投影。如果将这些滤镜中的任何滤镜用于不透明的目标图像,将会引发异常.
  • ConvolutionFilter — 此滤镜可使用不透明或透明的源图像和目标图像。
  • ColorMatrixFilter — 此滤镜可使用不透明或透明的源图像和目标图像。
  • DisplacementMapFilter — 此滤镜可使用不透明或透明的源图像和目标图像,但源图像和目标图像的格式必须相同。
取得一个源图像和一个滤镜对象,并生成过滤的图像。

此方法依赖于内置滤镜对象的行为,这些对象确定受输入源矩形影响的目标矩形。

应用滤镜后,结果图像可能会大于输入图像。例如,如果使用 BlurFilter 类来模糊源矩形 (50,50,100,100),并且目标点为 (10,10),则在目标图像中更改的区域将会由于该模糊处理而大于 (10,10,60,60)。这会在 applyFilter() 调用过程中在内部发生。

如果 sourceBitmapData 参数的 sourceRect 参数是内部区域,如 200 x 200 图像中的 (50,50,100,100),则滤镜会使用 sourceRect 参数外部的源像素来生成目标矩形。

如果 BitmapData 对象和指定为 sourceBitmapData 参数的对象是同一对象,应用程序将使用该对象的临时副本来执行滤镜。为了获得最佳性能,请避免这种情况。

下例演示如何将模糊滤镜应用于 BitmapData 实例: import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Point; import flash.geom.Rectangle; import flash.filters.BlurFilter; var bmd:BitmapData = new BitmapData(80, 30, false, 0xFFCC00); var rect:Rectangle = new Rectangle(10, 10, 40, 10); bmd.fillRect(rect, 0xFF0000); var pt:Point = new Point(10, 10); var filter:BlurFilter = new BlurFilter(); bmd.applyFilter(bmd, rect, pt, filter); var bm:Bitmap = new Bitmap(bmd); addChild(bm);
flash.filters.BevelFilterflash.filters.BlurFilterflash.filters.ColorMatrixFilterflash.filters.ConvolutionFilterflash.filters.DisplacementMapFilterflash.filters.DropShadowFilterflash.filters.GlowFilterflash.display.DisplayObject.filters
clone 返回一个新的 BitmapData 对象,它是对原始实例的克隆,包含与原始实例所含位图完全相同的副本。一个新的 BitmapData 对象,它与原始对象相同。 flash.display:BitmapData返回一个新的 BitmapData 对象,包含与原始位图完全相同的副本。 返回一个新的 BitmapData 对象,它是对原始实例的克隆,包含与原始实例所含位图完全相同的副本。 下例演示如何克隆 BitmapData 实例,并演示在修改克隆的 BitmapData 实例时,原始实例保持不变: import flash.display.Bitmap; import flash.display.BitmapData; var bmd1:BitmapData = new BitmapData(100, 80, false, 0x00000000); var bmd2:BitmapData = bmd1.clone(); bmd1.setPixel32(1, 1, 0xFFFFFFFF); trace(bmd1.getPixel32(1, 1).toString(16)); // ffffffff trace(bmd2.getPixel32(1, 1).toString(16)); // ff000000 var bm1:Bitmap = new Bitmap(bmd1); this.addChild(bm1); var bm2:Bitmap = new Bitmap(bmd2); bm2.x = 110; this.addChild(bm2); colorTransform 使用 ColorTransform 对象调整位图图像的指定区域中的颜色值。rect 或 colorTransform 为空。 TypeErrorTypeErrorrectflash.geom:Rectangle一个 Rectangle 对象,它定义在其中应用 ColorTransform 对象的图像区域。 colorTransformflash.geom:ColorTransform一个 ColorTransform 对象,它描述要应用的颜色转换值。 使用 ColorTransform 对象调整位图图像的指定区域中的颜色值。如果矩形与位图图像的边界匹配,则此方法将转换整个图像的颜色值。 下例演示如何将颜色转换应用于 BitmapData 对象的左半部分(矩形): import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; import flash.geom.ColorTransform; var bmd:BitmapData = new BitmapData(80, 30, false, 0xFF0000); var cTransform:ColorTransform = new ColorTransform(); cTransform.alphaMultiplier = 0.5 var rect:Rectangle = new Rectangle(0, 0, 40, 30); bmd.colorTransform(rect, cTransform); var bm:Bitmap = new Bitmap(bmd); addChild(bm); flash.geom.ColorTransformflash.geom.Rectanglecompare 比较两个 BitmapData 对象。otherBitmapData 为空。 TypeErrorTypeError如果两个 BitmapData 对象的尺寸(宽度和高度)相同,则方法将返回一个新的 BitmapData 对象,其中包含两个对象之间的差异(请参阅主要讨论内容)。如果这两个 BitmapData 对象相同,则该方法返回数字 0。如果这两个 BitmapData 对象的宽度不相等,则该方法返回数字 -3。如果这两个 BitmapData 对象的高度不相等,则该方法返回数字 -4。 ObjectotherBitmapDataflash.display:BitmapData要与源 BitmapData 对象比较的 BitmapData 对象。 比较两个 BitmapData 对象。如果两个 BitmapData 对象的尺寸(宽度和高度)相同,该方法将返回一个新的 BitmapData 对象,其中的每个像素都是两个源对象中的像素之间的“差”:
  • 如果两个像素相等,则差异像素为 0x00000000。
  • 如果两个像素具有不同的 RGB 值(忽略 Alpha 值),则差异像素为 0xRRGGBB,其中 RR/GG/BB 分别是红色、绿色和蓝色通道之间的个别差异值(源对象中的像素值减去 otherBitmapData 对象中的像素值)。本例中忽略了 Alpha 通道差异。
  • 如果只有 Alpha 通道值不同,则像素值为 0xZZFFFFFF,其中 ZZ 是 Alpha 值差异(源对象中的 Alpha 值减去 otherBitmapData 对象中的 Alpha 值)。

例如,考虑下面两个 BitmapData 对象:

var bmd1:BitmapData = new BitmapData(50, 50, true, 0xFFFF8800); var bmd2:BitmapData = new BitmapData(50, 50, true, 0xCCCC6600); var diffBmpData:BitmapData = bmd1.compare(bmd2) as BitmapData; trace ("0x" + diffBmpData.getPixel(0,0).toString(16); // 0x332200

注意:用于填充这两个 BitmapData 对象的颜色具有略微不同的 RGB 值(0xFF0000 和 0xFFAA00)。compare() 方法的结果是一个新的 BitmapData 对象,其中的每个像素都显示两个位图之间 RGB 值的差异。

以下面两个 BitmapData 对象为例,其中 RGB 颜色相同,但 Alpha 值不同。

var bmd1:BitmapData = new BitmapData(50, 50, true, 0xFFFFAA00); var bmd2:BitmapData = new BitmapData(50, 50, true, 0xCCFFAA00); var diffBmpData:BitmapData = bmd1.compare(bmd2) as BitmapData; trace ("0x" + diffBmpData.getPixel32(0,0).toString(16); // 0x33ffffff

compare() 方法的结果是一个新的 BitmapData 对象,其中的每个像素都显示两个位图之间 Alpha 值的差异。

如果 BitmapData 对象相同(宽度、高度和像素值都相同),则方法返回数字 0。

如果这两个 BitmapData 对象的宽度不相等,则该方法返回数字 -3。

如果 BitmapData 对象的高度不相等,但宽度相同,则方法返回数字 -4。

以下示例比较两个具有不同宽度(50 和 60)的 Bitmap 对象:

var bmd1:BitmapData = new BitmapData(100, 50, false, 0xFFFF0000); var bmd2:BitmapData = new BitmapData(100, 60, false, 0xFFFFAA00); trace(bmd1.compare(bmd2)); // -4
下例显示通过比较两个尺寸相同的 BitmapData 对象而得到的 BitmapData 对象中的像素值: import flash.display.Bitmap; import flash.display.BitmapData; var bmd1:BitmapData = new BitmapData(50, 50, true, 0xFFFFAA00); var bmd2:BitmapData = new BitmapData(50, 50, true, 0xCCFFAA00); var diffBmpData:BitmapData = BitmapData(bmd1.compare(bmd2)); var diffValue:String = diffBmpData.getPixel32(1, 1).toString(16); trace (diffValue); // 33ffffff var bm1:Bitmap = new Bitmap(bmd1); addChild(bm1); var bm2:Bitmap = new Bitmap(bmd2); addChild(bm2); bm2.x = 60;
copyChannel 将数据从另一个 BitmapData 对象或当前 BitmapData 对象的一个通道传输到当前 BitmapData 对象的某个通道中。sourceBitmapData、sourceRect 或 destPoint 为空。 TypeErrorTypeErrorsourceBitmapDataflash.display:BitmapData要使用的输入位图图像。源图像可以是另一个 BitmapData 对象,也可以指当前 BitmapData 对象。 sourceRectflash.geom:Rectangle源 Rectangle 对象。若只想复制位图内较小区域中的通道数据,请指定一个小于 BitmapData 对象整体大小的源矩形。 destPointflash.geom:Point目标 Point 对象,它表示将要在其中放置新通道数据的矩形区域的左上角。若只想将通道数据从目标图像中的一个区域复制到其他区域,请指定一个 (0,0) 以外的点。 sourceChanneluint源通道。使用来自 BitmapDataChannel 类(BitmapDataChannel.REDBitmapDataChannel.BLUEBitmapDataChannel.GREENBitmapDataChannel.ALPHA)的值。 destChanneluint目标通道。使用来自 BitmapDataChannel 类(BitmapDataChannel.REDBitmapDataChannel.BLUEBitmapDataChannel.GREENBitmapDataChannel.ALPHA)的值。 将数据从另一个 BitmapData 对象或当前 BitmapData 对象的一个通道传输到当前 BitmapData 对象的某个通道中。目标 BitmapData 对象的其他通道中的所有数据都将被保留。

源通道值和目标通道值可以是下列值之一:

  • BitmapDataChannel.RED
  • BitmapDataChannel.GREEN
  • BitmapDataChannel.BLUE
  • BitmapDataChannel.ALPHA
下例演示如何将 BitmapData 对象中的红色通道复制到一个在 20 x 20 像素的自身区域中的蓝色通道。 import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; import flash.geom.Point; var bmd:BitmapData = new BitmapData(100, 80, false, 0x00FF0000); var rect:Rectangle = new Rectangle(0, 0, 20, 20); var pt:Point = new Point(10, 10); bmd.copyChannel(bmd, rect, pt, BitmapDataChannel.RED, BitmapDataChannel.BLUE); var bm:Bitmap = new Bitmap(bmd); this.addChild(bm);
flash.geom.Rectangle
copyPixels 为没有拉伸、旋转或色彩效果的图像之间的像素处理提供一个快速例程。sourceBitmapData、sourceRect 和 destPoint 为空。 TypeErrorTypeErrorsourceBitmapDataflash.display:BitmapData要从中复制像素的输入位图图像。源图像可以是另一个 BitmapData 实例,也可以指当前 BitmapData 实例。 sourceRectflash.geom:Rectangle定义要用作输入的源图像区域的矩形。 destPointflash.geom:Point目标点,它表示将在其中放置新像素的矩形区域的左上角。 alphaBitmapDataflash.display:BitmapDatanull第二个 Alpha BitmapData 对象源。 alphaPointflash.geom:PointnullAlpha BitmapData 对象源中与 sourceRect 参数的左上角对应的点。 mergeAlphaBooleanfalse要使用 Alpha 通道,请将该值设置为 true。要复制不含 Alpha 通道的像素,请将该值设置为 false 为没有拉伸、旋转或色彩效果的图像之间的像素处理提供一个快速例程。此方法在目标 BitmapData 对象的目标点将源图像的矩形区域复制为同样大小的矩形区域。

如果包括 alphaBitmap 参数和 alphaPoint 参数,则可以将另一个图像用作源图像的 Alpha 源。如果源图像具有 Alpha 数据,则这两组 Alpha 数据都用于将源图像中的像素组合到目标图像中。alphaPoint 参数是 Alpha 图像中与源矩形左上角对应的点。源图像和 Alpha 图像交叉区域之外的任何像素都不会被复制到目标图像。

mergeAlpha 属性控制在将透明图像复制到另一透明图像时是否使用 Alpha 通道。要复制含有 Alpha 通道数据的像素,请将 mergeAlpha 属性设置为 true。默认情况下,mergeAlpha 属性为 false

下例演示如何将一个 BitmapData 对象中 20 x 20 像素的区域内的像素复制到另一个 BitmapData 对象: import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; import flash.geom.Point; var bmd1:BitmapData = new BitmapData(40, 40, false, 0x000000FF); var bmd2:BitmapData = new BitmapData(80, 40, false, 0x0000CC44); var rect:Rectangle = new Rectangle(0, 0, 20, 20); var pt:Point = new Point(10, 10); bmd2.copyPixels(bmd1, rect, pt); var bm1:Bitmap = new Bitmap(bmd1); this.addChild(bm1); var bm2:Bitmap = new Bitmap(bmd2); this.addChild(bm2); bm2.x = 50;
dispose 释放用来存储 BitmapData 对象的内存。 释放用来存储 BitmapData 对象的内存。

对图像调用 dispose() 方法时,该图像的宽度和高度将设置为 0。对此 BitmapData 实例的方法或属性的所有后续调用都将失败,并引发异常。

BitmapData.dispose() 立即释放由实际的位图数据占用的内存(一个位图最多可使用 64 MB 的内存)。使用 BitmapData.dispose() 后,BitmapData 对象不再可用,而且,如果对 BitmapData 对象调用函数,Flash 运行时将引发异常。但是,BitmapData.dispose() 不会将 BitmapData 对象(大约 128 个字节)作为垃圾回收;由实际的 BitmapData 对象占用的内存在垃圾回收器收集 BitmapData 对象时释放。

下例显示在调用 dispose() 方法后调用 BitmapData 对象的方法所产生的结果(引发异常): import flash.display.BitmapData; var myBitmapData:BitmapData = new BitmapData(100, 80, false, 0x000000FF); trace(myBitmapData.getPixel(1, 1)); // 255 == 0xFF myBitmapData.dispose(); try { trace(myBitmapData.getPixel(1, 1)); } catch (error:Error) { trace(error); // ArgumentError }
flash.system.System.gc()
draw 使用 Flash 运行时矢量渲染器在位图图像上绘制 source 显示对象。source 参数不是 BitmapData 或 DisplayObject 对象。 ArgumentErrorArgumentErrorsource 对象及其所有子对象(如果是 Sprite 或 MovieClip 对象)与调用方不来自同一个域,或者不在调用方可通过调用 Security.allowDomain() 方法访问的内容中。此限制不适用于应用程序安全沙箱中的 AIR 内容。 SecurityErrorSecurityError源为空或不是有效的 IBitmapDrawable 对象。 ArgumentErrorArgumentErrorsourceflash.display:IBitmapDrawable要绘制到 BitmapData 对象的显示对象或 BitmapData 对象。(DisplayObject 和 BitmapData 类实现 IBitmapDrawable 接口。) matrixflash.geom:Matrixnull一个 Matrix 对象,用于缩放、旋转位图或转换位图的坐标。如果不想将矩阵转换应用于图像,请将此参数设置为恒等矩阵(使用默认 new Matrix() 构造函数创建),或传递 null 值。 colorTransformflash.geom:ColorTransformnull一个 ColorTransform 对象,用于调整位图的颜色值。如果没有提供任何对象,则不会转换位图图像的颜色。如果必须传递此参数但又不想转换图像,请将此参数设置为使用默认 new ColorTransform() 构造函数创建的 ColorTransform 对象。 blendModeStringnull来自 flash.display.BlendMode 类的一个字符串值,指定要应用于所生成位图的混合模式。 clipRectflash.geom:Rectanglenull一个 Rectangle 对象,定义要绘制的源对象的区域。 如果不提供此值,则不会进行剪裁,并且将绘制整个源对象。 smoothingBooleanfalse一个布尔值,用于确定因在 matrix 参数中指定缩放或旋转而对 BitmapData 对象进行缩放或旋转以后,是否对该对象进行平滑处理。smoothing 参数只有在 source 参数是 BitmapData 对象时才适用。在将 smoothing 设置为 false 的情况下,经过旋转或缩放的 BitmapData 图像可能会显得像素化或带有锯齿。例如,下面两个图像的 source 参数使用同一个 BitmapData 对象,但对左侧的图像,smoothing 参数设置为 true,对右侧的图像,该参数设置为 false

在将 smoothing 设置为 true 的情况下绘制位图要比在将 smoothing 设置为 false 的情况下执行相同操作更为缓慢。

使用 Flash 运行时矢量渲染器在位图图像上绘制 source 显示对象。可以指定 matrixcolorTransformblendMode 和目标 clipRect 参数来控制呈现的执行方式。您可以根据需要指定是否应在缩放时对位图进行平滑处理(这只适用于源对象是 BitmapData 对象的情况)。

此方法与如何在创作工具界面中使用对象的标准矢量渲染器来绘制对像直接对应。

源显示对象不对此调用使用其任何已应用的转换。它会被视为存在于库或文件中,没有矩阵转换、没有颜色转换,也没有混合模式。要使用对象自己的 transform 属性来绘制显示对象(如影片剪辑),可以将其 transform 属性对象复制到使用 BitmapData 对象的 Bitmap 对象的 transform 属性。

Flash Player 9.0.115.0 及更高版本和 Adobe AIR 中,通过 RTMP 支持此方法。在 Flash Media Server 上,可以在服务器端脚本中控制对流的访问。有关详细信息,请参阅 Server-Side ActionScript Language Reference for Adobe Flash Media Server(《Adobe Flash Media Server 服务器端 ActionScript 语言参考》)中的 Client.audioSampleAccessClient.videoSampleAccess 属性。

如果 source 对象和其所有子对象(如果是 Sprite 或 MovieClip 对象)与调用方不来自同一个域,或者不在调用方可通过调用 Security.allowDomain() 方法访问的内容中,则调用 draw() 将引发 SecurityError 异常。此限制不适用于应用程序安全沙箱中的 AIR 内容。

对于使用所加载的位图图像作为 source 也有一些限制。如果所加载的图像来自与调用方相同的域,则调用 draw() 方法成功。此外,图像服务器上的跨域策略文件可以向调用 draw() 方法的 SWF 内容的域授予权限。在这种情况下,必须设置 LoaderContext 对象的 checkPolicyFile 属性,并在调用用于加载图像的 Loader 对象的 load() 方法时使用 LoaderContext 对象作为 context 参数。这些限制不适用于应用程序安全沙箱中的 AIR 内容。

在 Windows 中,draw() 方法无法在 Adobe AIR 的 HTMLLoader 对象中捕获嵌入 HTML 页的 SWF 内容。

draw() 方法无法捕获 Adobe AIR 中的 PDF 内容。也无法捕获 Adobe AIRwmode 属性设置为“window”的 HTML 中嵌入的 SWF 内容。

下例演示如何将 TextField 对象绘制到 BitmapData 对象: import flash.display.Bitmap; import flash.display.BitmapData; import flash.text.TextField; var tf:TextField = new TextField(); tf.text = "bitmap text"; var myBitmapData:BitmapData = new BitmapData(80, 20); myBitmapData.draw(tf); var bmp:Bitmap = new Bitmap(myBitmapData); this.addChild(bmp);
flash.display.BlendModeflash.geom.ColorTransformflash.geom.Matrixflash.system.JPEGLoaderContext
fillRect 使用指定的 ARGB 颜色填充一个矩形像素区域。矩形是空的。 TypeErrorTypeErrorrectflash.geom:Rectangle要填充的矩形区域。 coloruint用于填充区域的 ARGB 颜色值。通常以十六进制格式指定 ARGB 颜色;例如,0xFF336699。 使用指定的 ARGB 颜色填充一个矩形像素区域。 下例演示如何用蓝色填充 BitmapData 对象的一个矩形区域: import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; var myBitmapData:BitmapData = new BitmapData(40, 40, false, 0x0000FF00); var rect:Rectangle = new Rectangle(0, 0, 20, 20); myBitmapData.fillRect(rect, 0x0000FF); var bm:Bitmap = new Bitmap(myBitmapData); addChild(bm); flash.geom.RectanglefloodFill 对图像执行倾倒填充操作,从 (x, y) 坐标开始,填充一种特定的颜色。xint图像的 x 坐标。 yint图像的 y 坐标。 coloruint要用作填充色的 ARGB 颜色。 在图像上执行倾倒填充操作,从 (x, y) 坐标开始。 对图像执行倾倒填充操作,从 (x, y) 坐标开始,填充一种特定的颜色。floodFill() 方法类似于各种绘图程序中的“颜料桶”工具。该颜色是包含 Alpha 信息和颜色信息的 ARGB 颜色。 下面的示例演示如何用红色填充 BitmapData 对象的一个区域,即围绕由点 (10, 10) 定义的像素的区域,在该区域中所有颜色均与该点的颜色相匹配 import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; var myBitmapData:BitmapData = new BitmapData(40, 40, false, 0x0000FF00); var rect:Rectangle = new Rectangle(0, 0, 20, 20); myBitmapData.fillRect(rect, 0x000000FF); rect = new Rectangle(15, 15, 25, 25); myBitmapData.fillRect(rect, 0x000000FF); myBitmapData.floodFill(10, 10, 0x00FF0000); var bm:Bitmap = new Bitmap(myBitmapData); addChild(bm); generateFilterRect 已知 BitmapData 对象、源矩形和滤镜对象,确定 applyFilter() 方法调用所影响的目标矩形。sourceRect 或滤镜为空。 TypeErrorTypeError一个目标矩形,它是使用图像、sourceRect 参数和滤镜计算得到的。 flash.geom:RectanglesourceRectflash.geom:Rectangle一个矩形,它定义要用作输入的源图像的区域。 filterflash.filters:BitmapFilter一个滤镜对象,用于计算目标矩形。 确定将受 applyFilter() 调用影响的目标矩形。 已知 BitmapData 对象、源矩形和滤镜对象,确定 applyFilter() 方法调用所影响的目标矩形。

例如,模糊滤镜影响的区域通常比原始图像大。由一个默认 BlurFilter 实例过滤的 100 x 200 像素图像,其中 blurX = blurY = 4 将生成一个目标矩形 (-2,-2,104,204)generateFilterRect() 方法使您可以提前了解到此目标矩形的大小,以便能够在执行滤镜操作之前相应地调整目标图像的大小。

有些滤镜会基于源图像大小裁剪其目标矩形。例如,一个内部 DropShadow 不会生成比其源图像大的结果。在此 API 中,BitmapData 对象用作源范围而不是源 rect 参数。

下例演示如何使用 generateFilterRect() 方法来确定模糊滤镜的结果将要占据的矩形区域。generateFilterRect() 方法的结果由 trace() 函数输出: import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Point; import flash.geom.Rectangle; import flash.filters.BlurFilter; var bmd:BitmapData = new BitmapData(80, 30, false, 0xFFCC00); var rect:Rectangle = new Rectangle(10, 10, 40, 10); bmd.fillRect(rect, 0xFF0000); var pt:Point = new Point(10, 10); var filter:BlurFilter = new BlurFilter(); trace(bmd.generateFilterRect(rect, filter)); // (x=8, y=8, w=44, h=14) bmd.applyFilter(bmd, rect, pt, filter); var bm:Bitmap = new Bitmap(bmd); addChild(bm); 请注意,generateFilterRect() 方法不会应用滤镜。调用 applyFilter() 方法来应用滤镜。
getColorBoundsRect 确定矩形区域是将位图图像中指定颜色的所有像素完全包括起来(如果将 findColor 参数设置为 true),还是将不包括指定颜色的所有像素完全包括起来(如果将 findColor 参数设置为 false)。指定颜色的图像区域。 flash.geom:Rectanglemaskuint一个十六进制值,指定要考虑的 ARGB 颜色的位。通过使用 & (bitwise AND) 运算符,将颜色值与此十六进制值合并。 coloruint一个十六进制值,指定要匹配(如果 findColor 设置为 true)或 匹配(如果 findColor 设置为 false)的 ARGB 颜色。 findColorBooleantrue如果该值设置为 true,则返回图像中颜色值的范围。如果该值设置为 false,则返回图像中不存在此颜色的范围。 确定矩形区域是将位图图像中指定颜色的所有像素完全包括起来(如果将 findColor 参数设置为 true),还是将不包括指定颜色的所有像素完全包括起来(如果将 findColor 参数设置为 false)。

例如,如果有一个源图像并且想要确定包含非零 Alpha 通道的图像矩形,请传递 {mask: 0xFF000000, color: 0x00000000} 作为参数。如果 findColor 参数设置为 true,则会在整个图像中搜索其 (value & mask) == color 的像素范围(其中 value 是像素的颜色值)。如果 findColor 参数设置为 false,则在整个图像中搜索以下像素的范围,这些像素满足条件 (value & mask) != color(其中 value 是像素的颜色值)。要确定图像周围的空白区域,请传递 {mask: 0xFFFFFFFF, color: 0xFFFFFFFF} 以查找非空白像素的范围。

下例将创建一个 BitmapData 对象,其上半部分的像素为红色。然后,该示例将调用 getColorBoundsRect() 方法来确定其中像素为红色 (0xFF0000) 的矩形;最后,调用同一方法来确定其中像素不为红色的矩形(通过将 findColor 参数设置为 false): import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; var bmd:BitmapData = new BitmapData(80, 40, false, 0xFFFFFF); var rect:Rectangle = new Rectangle(0, 0, 80, 20); bmd.fillRect(rect, 0xFF0000); var maskColor:uint = 0xFFFFFF; var color:uint = 0xFF0000; var redBounds:Rectangle = bmd.getColorBoundsRect(maskColor, color, true); trace(redBounds); // (x=0, y=0, w=80, h=20) var notRedBounds:Rectangle = bmd.getColorBoundsRect(maskColor, color, false); trace(notRedBounds); // (x=0, y=20, w=80, h=20) var bm:Bitmap = new Bitmap(bmd); addChild(bm);
getPixel32 返回一个 ARGB 颜色值,它包含 Alpha 通道数据和 RGB 数据。一个表示 ARGB 像素值的数字。如果 (x, y) 坐标在图像范围以外,则返回 0。 uintxint像素的 x 位置。 yint像素的 y 位置。 返回一个 ARGB 颜色值,它包含 Alpha 通道数据和 RGB 数据。此方法与 getPixel() 方法类似,后者返回没有 Alpha 通道数据的 RGB 颜色。

BitmapData 对象中的所有像素都作为预乘颜色值进行存储。预乘图像像素具有已经与 Alpha 数据相乘的红色、绿色和蓝色通道值。例如,如果 Alpha 值为 0,则 RGB 通道的值也为 0,与它们未经过相乘的值无关。这种丢失数据的情况可能会在执行操作时导致一些问题。所有 BitmapData 方法都采用并返回未经过相乘的值。内部像素表示形式在其作为值返回之前从经过预乘的形式转换为未经过相乘的形式。在设置操作过程中,设置原始图像像素之前,像素值是经过预乘的。

下面的示例创建一个用颜色填充的 BitmapData 对象,然后使用 getPixel32() 方法确定左上角像素中的颜色值,并随之确定每个颜色成分(Alpha、红色、绿色和蓝色)的十六进制值: import flash.display.BitmapData; var bmd:BitmapData = new BitmapData(80, 40, true, 0xFF44AACC); var pixelValue:uint = bmd.getPixel32(0, 0); var alphaValue:uint = pixelValue >> 24 & 0xFF; var red:uint = pixelValue >> 16 & 0xFF; var green:uint = pixelValue >> 8 & 0xFF; var blue:uint = pixelValue & 0xFF; trace(alphaValue.toString(16)); // ff trace(red.toString(16)); // 44 trace(green.toString(16)); // aa trace(blue.toString(16)); // cc
getPixel()setPixel32()
getPixel 返回一个整数,它表示 BitmapData 对象中在特定点 (x, y) 处的 RGB 像素值。一个表示 RGB 像素值的数字。如果 (x, y) 坐标在图像范围以外,则该方法返回 0。 uintxint像素的 x 位置。 yint像素的 y 位置。 返回一个整数,它表示 BitmapData 对象中在某个特定点上的 RGB 像素值。 返回一个整数,它表示 BitmapData 对象中在某个特定点 (x, y) 处的 RGB 像素值。getPixel() 方法将返回一个未经过相乘的像素值。没有返回任何 Alpha 信息。

BitmapData 对象中的所有像素都作为预乘颜色值进行存储。预乘图像像素具有已经与 Alpha 数据相乘的红色、绿色和蓝色通道值。例如,如果 Alpha 值为 0,则 RGB 通道的值也为 0,与它们未经过相乘的值无关。这种丢失数据的情况可能会在执行操作时导致一些问题。所有 BitmapData 方法都采用并返回未经过相乘的值。内部像素表示形式在其作为值返回之前从经过预乘的形式转换为未经过相乘的形式。在设置操作过程中,设置原始图像像素之前,像素值是经过预乘的。

下例创建一个用红色填充的 BitmapData 对象,然后使用 getPixel() 方法确定左上角像素中的颜色值: import flash.display.BitmapData; var bmd:BitmapData = new BitmapData(80, 40, false, 0xFF0000); var pixelValue:uint = bmd.getPixel(0, 0); trace(pixelValue.toString(16)); // ff0000;
getPixel32()setPixel()
getPixels 从像素数据的矩形区域生成一个字节数组。矩形是空的。 TypeErrorTypeError表示给定矩形中的像素的 ByteArray。 flash.utils:ByteArrayrectflash.geom:Rectangle当前 BitmapData 对象中的一个矩形区域。 从像素数据的矩形区域生成一个字节数组。为每个像素将一个无符号整数(32 位未经相乘的像素值)写入字节数组。 下例将创建一个用随机杂点像素填充的 BitmapData 对象,然后通过 getPixels() 方法用 BitmapData 对象的像素值来填充 ByteArray 对象 import flash.display.BitmapData; import flash.geom.Rectangle; import flash.utils.ByteArray; var bmd:BitmapData = new BitmapData(80, 40, true); var seed:int = int(Math.random() * int.MAX_VALUE); bmd.noise(seed); var bounds:Rectangle = new Rectangle(0, 0, bmd.width, bmd.height); var pixels:ByteArray = bmd.getPixels(bounds); flash.utils.ByteArraygetVector 从像素数据的矩形区域生成一个矢量数组。矩形是空的。 TypeErrorTypeError表示给定矩形的 Vector。 rectflash.geom:Rectangle当前 BitmapData 对象中的一个矩形区域。 从像素数据的矩形区域生成一个矢量数组。为指定矩形返回一个无符号整数(32 位未经相乘的像素值)的 Vector 对象。 histogram 计算 BitmapData 对象的 256 值二进制数直方图。hRectflash.geom:Rectanglenull要使用的 BitmapData 对象的区域。 计算 BitmapData 对象的 256 值二进制数直方图。此方法返回包含四个矢量的 Vector 对象。<Number> 个实例(四个包含数字对象的 Vector 对象)。这四个 Vector 实例依次表示红色、绿色、蓝色和 Alpha 成分。每个 Vector 实例包含从 0 到 255 这 256 个值,这些值表示各个成分值的填充计数。 hitTest 在一个位图图像与一个点、矩形或其他位图图像之间执行像素级的点击检测。secondObject 参数不是 Point、Rectangle、Bitmap 或 BitmapData 对象。 ArgumentErrorArgumentErrorfirstPoint 为空。 TypeErrorTypeError如果发生点击,则值为 true;否则为 falseBooleanfirstPointflash.geom:Point 任意坐标空间中 BitmapData 图像的左上角的位置。在定义 secondBitmapPoint 参数时,使用了相同的坐标空间。 firstAlphaThresholduint最小的 Alpha 通道值,此点击测试将其视为不透明的。 secondObjectObject一个 Rectangle、Point、Bitmap 或 BitmapData 对象。 secondBitmapDataPointflash.geom:Pointnull一个点,用于定义第二个 BitmapData 对象中的一个像素位置。仅当 secondObject 的值是 BitmapData 对象时使用此参数。 secondAlphaThresholduint1最小的 Alpha 通道值,它在第二个 BitmapData 对象中被视为不透明的。仅当 secondObject 的值是 BitmapData 对象,并且这两个 BitmapData 对象都为透明时使用此参数。 在一个位图图像与一个点、矩形或其他位图图像之间执行像素级的点击检测。根据定义,点击区域是指一个不透明像素或两个重叠的不透明像素上的点或矩形的重叠部分。在执行点击测试时,将不会考虑两个对象中任何一个对象的拉伸、旋转或其他变形。

如果某个图像是不透明图像,则此方法会将其视为完全不透明的矩形。两个图像必须是透明图像才能执行判断透明度的像素级点击测试。当您在测试两个透明图像时,Alpha 阈值参数将控制哪些 Alpha 通道值(从 0 到 255)将被视为是不透明的。

下例将创建一个仅在矩形区域 (20, 20, 40, 40) 中不透明的 BitmapData 对象,然后调用 hitTest() 方法,且使用 Point 对象作为 secondObject。在第一次调用中,Point 对象定义 BitmapData 对象的左上角,是透明的;在第二次调用中,Point 对象定义 BitmapData 对象的中心,是不透明的。 import flash.display.BitmapData; import flash.geom.Rectangle; import flash.geom.Point; var bmd1:BitmapData = new BitmapData(80, 80, true, 0x00000000); var rect:Rectangle = new Rectangle(20, 20, 40, 40); bmd1.fillRect(rect, 0xFF0000FF); var pt1:Point = new Point(1, 1); trace(bmd1.hitTest(pt1, 0xFF, pt1)); // false var pt2:Point = new Point(40, 40); trace(bmd1.hitTest(pt1, 0xFF, pt2)); // true
lock 锁定图像,以使引用 BitmapData 对象的任何对象(如 Bitmap 对象)在此 BitmapData 对象更改时不会更新。 锁定图像,以使引用 BitmapData 对象的任何对象(如 Bitmap 对象)在此 BitmapData 对象更改时不会更新。要提高性能,请在对 setPixel()setPixel32() 方法进行多次调用之前和之后使用此方法及 unlock() 方法。 下例根据 Bitmap 对象 picturebitmapData 属性创建一个 BitmapData 对象。然后,该示例先调用 lock() 方法再调用复杂的自定义函数 complexTransformation(),该函数可修改 BitmapData 对象。(picture 对象和 complexTransformation() 函数未在本示例中定义。) 即使 complexTransformation() 函数更新了 picture 对象的 bitmapData 属性,这些更新也只有在代码对 bitmapData 对象调用 unlock() 方法之后才会得到体现: import flash.display.BitmapData; var bitmapData:BitmapData = picture.bitmapData; bitmapData.lock(); bitmapData = complexTransformation(bitmapData); bitmapData.unlock(); picture.bitmapData = bitmapData; setPixel()setPixel32()unlock()merge 对每个通道执行从源图像向目标图像的混合。sourceBitmapData、sourceRect 或 destPoint 为空。 TypeErrorTypeErrorsourceBitmapDataflash.display:BitmapData要使用的输入位图图像。源图像可以是另一个 BitmapData 对象,也可以引用当前 BitmapData 对象。 sourceRectflash.geom:Rectangle定义要用作输入的源图像区域的矩形。 destPointflash.geom:Point目标图像(当前 BitmapData 实例)中与源矩形的左上角对应的点。 redMultiplieruint一个要与红色通道值相乘的十六进制 uint 值。 greenMultiplieruint一个要与绿色通道值相乘的十六进制 uint 值。 blueMultiplieruint一个要与蓝色通道值相乘的十六进制 uint 值。 alphaMultiplieruint一个要与 Alpha 透明度值相乘的十六进制 uint 值。 对每个通道执行从源图像向目标图像的混合。对于每个通道和每个像素,将基于源和目标像素的通道值来计算新值。例如,在红色通道中,新值是按如下方式计算的(其中 redSrc 是源图像中像素的红色通道值,而 redDest 是目标图像中对应像素的红色通道值):

new redDest = [(redSrc * redMultiplier) + (redDest * (256 - redMultiplier))] / 256;

redMultipliergreenMultiplierblueMultiplieralphaMultiplier 值是用于每个颜色通道的乘数。应使用从 00x100 (256) 的十六进制值范围,其中 0 指定在结果中使用来自目标的完整值,0x100 指定使用来自源的完整值,介于两者之间的数字指定使用混合值 (如 0x80 表示 50%)。

下例将创建两个 BitmapData 对象。这两个对象的大小均为 100 x 80 像素。第一个对象用绿色填充,第二个对象用红色填充。该代码调用 merge() 方法,将第二个 BitmapData 对象的像素合并到第一个 BitmapData 对象中,但仅在指定矩形区域上进行: import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; import flash.geom.Point; var bmd1:BitmapData = new BitmapData(100, 80, true, 0xFF00FF00); var bmd2:BitmapData = new BitmapData(100, 80, true, 0xFFFF0000); var rect:Rectangle = new Rectangle(0, 0, 20, 20); var pt:Point = new Point(20, 20); var mult:uint = 0x80; // 50% bmd1.merge(bmd2, rect, pt, mult, mult, mult, mult); var bm1:Bitmap = new Bitmap(bmd1); addChild(bm1); var bm2:Bitmap = new Bitmap(bmd2); addChild(bm2); bm2.x = 110;
noise 使用表示随机杂点的像素填充图像。randomSeedint要使用的随机种子数。如果您保持使所有其他参数不变,可以通过改变随机种子值来生成不同的伪随机结果。杂点函数是一个映射函数,不是真正的随机数生成函数,所以它每次都会根据相同的随机种子创建相同的结果。 lowuint0要为每个通道生成的最低值(0 到 255)。 highuint255要为每个通道生成的最高值(0 到 255)。 channelOptionsuint7一个数字,可以是四个颜色通道值(BitmapDataChannel.REDBitmapDataChannel.BLUEBitmapDataChannel.GREENBitmapDataChannel.ALPHA)的任意组合。您可以使用 logical OR (|) 运算符来组合通道值。 grayScaleBooleanfalse一个布尔值。如果该值为 true,则会通过将所有颜色通道设置为相同的值来创建一个灰度图像。将此参数设置为 true 不会影响 Alpha 通道的选择。 使用表示随机杂点的像素填充图像。 下例将创建两个 BitmapData 对象,并对这两个对象都调用 noise() 方法。但是,对于第一个对象的 noise() 方法的调用,grayscale 参数设置为 false,而对于第二个对象的 noise() 方法的调用,该参数设置为 true import flash.display.Bitmap; import flash.display.BitmapData; import flash.display.BitmapDataChannel; var bmd1:BitmapData = new BitmapData(80, 80); var bmd2:BitmapData = new BitmapData(80, 80); var seed:int = int(Math.random() * int.MAX_VALUE); bmd1.noise(seed, 0, 0xFF, BitmapDataChannel.RED, false); bmd2.noise(seed, 0, 0xFF, BitmapDataChannel.RED, true); var bm1:Bitmap = new Bitmap(bmd1); this.addChild(bm1); var bm2:Bitmap = new Bitmap(bmd2); this.addChild(bm2); bm2.x = 90; flash.display.BitmapDataChannel.REDflash.display.BitmapDataChannel.BLUEflash.display.BitmapDataChannel.GREENflash.display.BitmapDataChannel.ALPHApaletteMap 重新映射一个具有最多四组调色板数据(每个通道一组)的图像中的颜色通道值。sourceBitmapData、sourceRect 或 destPoint 为空。 TypeErrorTypeErrorsourceBitmapDataflash.display:BitmapData要使用的输入位图图像。源图像可以是另一个 BitmapData 对象,也可以引用当前 BitmapData 实例。 sourceRectflash.geom:Rectangle定义要用作输入的源图像区域的矩形。 destPointflash.geom:Point目标图像(当前 BitmapData 对象)中与源矩形的左上角对应的点。 redArrayArraynull如果 redArray 不为 null,则 red = redArray[source red value] else red = source rect valuegreenArrayArraynull如果 greenArray 不为 null,则 green = greenArray[source green value] else green = source green value. blueArrayArraynull如果 blueArray 不为 null,则 blue = blueArray[source blue value] else blue = source blue valuealphaArrayArraynull如果 alphaArray 不为 null,则 alpha = alphaArray[source alpha value] else alpha = source alpha value 重新映射一个具有最多四组调色板数据(每个通道一组)的图像中的颜色通道值。

Flash 运行时通过下列步骤生成结果图像:

  1. 计算了红色、绿色、蓝色和 Alpha 值后,将使用标准 32 位整数算法将它们相加在一起。
  2. 每个像素的红色、绿色、蓝色和 Alpha 通道值被分别提取为一个 0 到 255 的值。使用这些值在相应的数组中查找新的颜色值:redArraygreenArrayblueArrayalphaArray。这四个数组中的每一个都应包含 256 个值。
  3. 在检索了所有四个新通道值之后,它们会被组合成一个应用于像素的标准 ARGB 值。

此方法可以支持跨通道效果。每个输入数组可以包含完整的 32 位值,并且在将这些值相加到一起时不会发生任何移位。此例程不支持按通道锁定。

如果没有为通道指定数组,则颜色通道会从源图像复制到目标图像。

您可以为多种效果(例如,常规调色板映射)使用此方法(采用一个通道并将其转换为假颜色图像)。您也可以为各种高级颜色操作算法(例如,灰度系数、曲线、级别和量化)使用此方法。

下例将创建一个中心有红色方框的绿色 BitmapData 对象,然后使用 paletteMap() 方法在 BitmapData 对象的下半部分的矩形中将红色与绿色交换: import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; import flash.geom.Point; var myBitmapData:BitmapData = new BitmapData(80, 80, false, 0x00FF0000); myBitmapData.fillRect(new Rectangle(20, 20, 40, 40), 0x0000FF00); var redArray:Array = new Array(256); var greenArray:Array = new Array(256); for(var i:uint = 0; i < 255; i++) { redArray[i] = 0x00000000; greenArray[i] = 0x00000000; } redArray[0xFF] = 0x0000FF00; greenArray[0xFF] = 0x00FF0000; var bottomHalf:Rectangle = new Rectangle(0, 0, 100, 40); var pt:Point = new Point(0, 0); myBitmapData.paletteMap(myBitmapData, bottomHalf, pt, redArray, greenArray); var bm1:Bitmap = new Bitmap(myBitmapData); addChild(bm1);
perlinNoise 生成 Perlin 杂点图像。baseXNumber要在 x 方向上使用的频率。例如,要生成大小适合 64 x 128 图像的杂点,请为 baseX 值传递 64。 baseYNumber要在 y 方向上使用的频率。例如,要生成大小适合 64 x 128 图像的杂点,请为 baseY 值传递 128。 numOctavesuint要组合以创建此杂点的 octave 函数或各个杂点函数的数目。octave 的数目越多,创建的图像越细腻。octave 的数目越多,需要的处理时间也会越长。 randomSeedint要使用的随机种子数。如果您保持使所有其他参数不变,可以通过改变随机种子值来生成不同的伪随机结果。Perlin 杂点函数是一个映射函数,不是真正的随机数生成函数,所以它会每次根据相同的随机种子创建相同的结果。 stitchBoolean一个布尔值。如果该值为 true,则该方法将尝试平滑图像的转变边缘以创建无缝的纹理,用于作为位图填充进行平铺。 fractalNoiseBoolean一个布尔值。如果该值为 true,则该方法将生成碎片杂点;否则,它将生成湍流。带有湍流的图像具有可见的不连续性渐变,可以使其具有更接近锐化的视觉效果,例如火焰或海浪。 channelOptionsuint7 一个数字,可以是四个颜色通道值(BitmapDataChannel.REDBitmapDataChannel.BLUEBitmapDataChannel.GREENBitmapDataChannel.ALPHA)的任意组合。您可以使用 logical OR (|) 运算符来组合通道值。 grayScaleBooleanfalse一个布尔值。如果该值为 true,则通过将红色、绿色和蓝色通道的每一个值都设置为相同的值来创建一个灰度图像。如果此值设置为 true,则 Alpha 通道值将不会受到影响。 offsetsArraynull与每个 octave 的 xy 偏移量相对应的点数组。通过操作这些偏移量值,您可以平滑滚动 perlinNoise 图像的图层。偏移数组中的每个点将影响一个特定的 octave 杂点函数。 生成 Perlin 杂点图像。

Perlin 杂点生成算法会内插单个随机杂点函数名为 octave 并将它们组合成一个函数,该函数生成多个看起来很自然的随机杂点。就像音乐上的八音度,每个 octave 函数的频率都是其前面一个 octave 函数频率的两倍。Perlin 杂点被描述为“杂点的碎片总和”,因为它将多组杂点数据与不同级别的细节组合在一起。

您可以使用 Perlin 杂点函数来模拟自然现象和风景,例如,木材纹理、云彩或山脉。在大多数情况下,Perlin 杂点函数的输出不会直接显示出来,而是用于增强其他图像并为其他图像提供伪随机变化。

简单的数字随机杂点函数通常生成具有粗糙的对比度点的图像。这种粗糙的对比度在自然界中通常是找不到的。Perlin 杂点算法混合了在不同的详细级别上进行操作的多个杂点函数。此算法在相邻的像素值间产生较小的变化。

下例将创建一个 200 x 200 像素的 BitmapData 对象,该对象调用 perlinNoise() 方法来生成红色和蓝色的水彩画效果: import flash.display.Bitmap; import flash.display.BitmapData; var bmd:BitmapData = new BitmapData(200, 200, false, 0x00CCCCCC); var seed:Number = Math.floor(Math.random() * 10); var channels:uint = BitmapDataChannel.RED | BitmapDataChannel.BLUE; bmd.perlinNoise(100, 80, 6, seed, false, true, channels, false, null); var bm:Bitmap = new Bitmap(bmd); addChild(bm);
pixelDissolve 执行源图像到目标图像的像素溶解,或使用同一图像执行像素溶解。sourceBitmapData、sourceRect 或 destPoint 为空。 TypeErrorTypeErrornumPixels 值为负 TypeErrorTypeError用于后续调用的新随机种子值。 intsourceBitmapDataflash.display:BitmapData要使用的输入位图图像。源图像可以是另一个 BitmapData 对象,也可以引用当前 BitmapData 实例。 sourceRectflash.geom:Rectangle定义要用作输入的源图像区域的矩形。 destPointflash.geom:Point目标图像(当前 BitmapData 实例)中与源矩形的左上角对应的点。 randomSeedint0用于开始像素溶解的随机种子。 numPixelsint0默认值是源区域(宽度 x 高度)的 1/30。 fillColoruint0一个 ARGB 颜色值,用于填充其源值等于目标值的像素。 执行源图像到目标图像的像素溶解,或使用同一图像执行像素溶解。Flash 运行时使用 randomSeed 值生成随机像素溶解。函数的返回值必须在后续调用中传入才能继续进行像素溶解,直至完成。

如果源图像不等于目标图像,则会使用所有的属性将像素从源复制到目标。此过程允许从空白图像溶解到完全填充的图像。

如果源图像和目标图像相等,则使用 color 参数填充像素。此过程允许从完全填充的图像溶解掉。在此模式中,将会忽略目标 point 参数。

下例使用 pixelDissolve() 方法一次溶解 40 个像素,直到所有像素的颜色都已更改,从而将 BitmapData 对象由灰色转换为红色: import flash.display.BitmapData; import flash.display.Bitmap; import flash.geom.Point; import flash.geom.Rectangle; import flash.utils.Timer; import flash.events.TimerEvent; var bmd:BitmapData = new BitmapData(100, 80, false, 0x00CCCCCC); var bitmap:Bitmap = new Bitmap(bmd); addChild(bitmap); var tim:Timer = new Timer(20); tim.start(); tim.addEventListener(TimerEvent.TIMER, timerHandler); function timerHandler(event:TimerEvent):void { var randomNum:Number = Math.floor(Math.random() * int.MAX_VALUE); dissolve(randomNum); } function dissolve(randomNum:Number):void { var rect:Rectangle = bmd.rect; var pt:Point = new Point(0, 0); var numberOfPixels:uint = 100; var red:uint = 0x00FF0000; bmd.pixelDissolve(bmd, rect, pt, randomNum, numberOfPixels, red); var grayRegion:Rectangle = bmd.getColorBoundsRect(0xFFFFFFFF, 0x00CCCCCC, true); if(grayRegion.width == 0 && grayRegion.height == 0 ) { tim.stop(); } }
scroll 按某一 (x, y) 像素量滚动图像。xint水平滚动量。 yint垂直滚动量。 将图像按一定量的 (x, y) 像素进行滚动。滚动区域之外的边缘区域保持不变。 下例显示将 Bitmap 数据对象向右滚动 40 个像素的效果: import flash.display.Bitmap; import flash.display.BitmapData; import flash.geom.Rectangle; var bmd:BitmapData = new BitmapData(80, 80, true, 0xFFCCCCCC); var rect:Rectangle = new Rectangle(0, 0, 40, 40); bmd.fillRect(rect, 0xFFFF0000); var bm:Bitmap = new Bitmap(bmd); addChild(bm); trace (bmd.getPixel32(50, 20).toString(16)); // ffcccccccc bmd.scroll(30, 0); trace (bmd.getPixel32(50, 20).toString(16)); // ffff0000 setPixel32 设置 BitmapData 对象单个像素的颜色和 Alpha 透明度值。xint像素值会更改的像素的 x 位置。 yint像素值会更改的像素的 y 位置。 coloruint生成的像素 ARGB 颜色。如果位图是不透明的(非透明)位图,则会忽略此颜色值的 Alpha 透明度部分。 设置 BitmapData 对象单个像素的颜色和 Alpha 透明度值。此方法与 setPixel() 方法类似;主要差别在于 setPixel32() 方法采用包含 Alpha 通道信息的 ARGB 颜色值。

BitmapData 对象中的所有像素都作为预乘颜色值进行存储。预乘图像像素具有已经与 Alpha 数据相乘的红色、绿色和蓝色通道值。例如,如果 Alpha 值为 0,则 RGB 通道的值也为 0,与它们未经过相乘的值无关。这种丢失数据的情况可能会在执行操作时导致一些问题。所有 BitmapData 方法都采用并返回未经过相乘的值。内部像素表示形式在其作为值返回之前从经过预乘的形式转换为未经过相乘的形式。在设置操作过程中,设置原始图像像素之前,像素值是经过预乘的。

注意:要提高性能,请在重复使用 setPixel()setPixel32() 方法时,在调用 setPixel()setPixel32() 方法之前先调用 lock() 方法,然后在做出所有像素更改后调用 unlock() 方法。此过程可防止引用此 BitmapData 实例的对象在您完成像素更改之前进行更新。

下例使用 setPixel32() 方法在 BitmapData 对象中绘制一条透明的 (Alpha == 0x60) 红色直线: import flash.display.Bitmap; import flash.display.BitmapData; var bmd:BitmapData = new BitmapData(80, 80, true, 0xFFCCCCCC); for (var i:uint = 0; i < 80; i++) { var red:uint = 0x60FF0000; bmd.setPixel32(i, 40, red); } var bm:Bitmap = new Bitmap(bmd); addChild(bm);
setPixel()getPixel32()lock()unlock()
setPixel 设置 BitmapData 对象的单个像素。xint像素值会更改的像素的 x 位置。 yint像素值会更改的像素的 y 位置。 coloruint生成的像素 RGB 颜色。 设置 BitmapData 对象的单个像素。在此操作过程中将会保留图像像素的当前 Alpha 通道值。RGB 颜色参数的值被视为一个未经过相乘的颜色值。

注意:要提高性能,请在重复使用 setPixel()setPixel32() 方法时,在调用 setPixel()setPixel32() 方法之前先调用 lock() 方法,然后在做出所有像素更改后调用 unlock() 方法。此过程可防止引用此 BitmapData 实例的对象在您完成像素更改之前进行更新。

下例使用 setPixel() 方法在 BitmapData 对象中绘制一条红色直线: import flash.display.Bitmap; import flash.display.BitmapData; var bmd:BitmapData = new BitmapData(80, 80, false, 0xCCCCCC); for (var i:uint = 0; i < 80; i++) { var red:uint = 0xFF0000; bmd.setPixel(i, 40, red); } var bm:Bitmap = new Bitmap(bmd); addChild(bm);
getPixel()setPixel32()lock()unlock()
setPixels 将字节数组转换为像素数据的矩形区域。inputByteArray 对象包括的数据不足以填充 rect 矩形的区域。在引发异常之前,该方法会尽可能多地填充像素。 EOFErrorflash.errors:EOFErrorrect 或 inputByteArray 为空。 TypeErrorTypeErrorrectflash.geom:Rectangle指定 BitmapData 对象的矩形区域。 inputByteArrayflash.utils:ByteArray一个 ByteArray 对象,由要在矩形区域中使用的 32 位未经过相乘的像素值组成。 将字节数组转换为像素数据的矩形区域。对于每个像素,将调用 ByteArray.readUnsignedInt() 方法并将返回值写入像素。如果字节数组在写入整个矩形之前结束,将返回函数。字节数组中的数据应该是 32 位 ARGB 像素值。在读取像素之前或之后,不会对字节数组执行搜索。 下例使用 getPixels()setPixels() 方法将像素从一个 BitmapData 对象复制到另一个 BitmapData 对象: import flash.display.Bitmap; import flash.display.BitmapData; import flash.utils.ByteArray; import flash.geom.Rectangle; var bmd1:BitmapData = new BitmapData(100, 100, true, 0xFFCCCCCC); var bmd2:BitmapData = new BitmapData(100, 100, true, 0xFFFF0000); var rect:Rectangle = new Rectangle(0, 0, 100, 100); var bytes:ByteArray = bmd1.getPixels(rect); bytes.position = 0; bmd2.setPixels(rect, bytes); var bm1:Bitmap = new Bitmap(bmd1); addChild(bm1); var bm2:Bitmap = new Bitmap(bmd2); addChild(bm2); bm2.x = 110; flash.utils.ByteArray.readUnsignedInt()setVector 将 Vector 转换为像素数据的矩形区域。矢量数组不够大,无法读取所有像素数据。 RangeErrorRangeErrorrectflash.geom:Rectangle指定 BitmapData 对象的矩形区域。 inputVector一个 Vector 对象,由将在矩形区域中使用的 32 位未经过相乘的像素值组成。 将 Vector 转换为像素数据的矩形区域。对于每个像素,将会读取 Vector 元素并将其写入到 BitmapData 像素中。Vector 中的数据应该是 32 位 ARGB 像素值。 threshold 根据指定的阈值测试图像中的像素值,并将通过测试的像素设置为新的颜色值。sourceBitmapData、sourceRect、destPoint 或操作为空。 TypeErrorTypeError操作字符串不是有效的操作 ArgumentErrorArgumentError已更改像素的数目。 uintsourceBitmapDataflash.display:BitmapData要使用的输入位图图像。源图像可以是另一个 BitmapData 对象,也可以引用当前 BitmapData 实例。 sourceRectflash.geom:Rectangle定义要用作输入的源图像区域的矩形。 destPointflash.geom:Point目标图像(当前 BitmapData 实例)中与源矩形的左上角对应的点。 operationString下列比较运算符之一(作为字符串传递):“<”、“<=”、“>”、“>=”、“==”“!=” thresholduint测试每个像素时要比较的值,以查看该值是达到还是超过阈值。 coloruint0阈值测试成功时对像素设置的颜色值。默认值为 0x00000000。 maskuint0xFFFFFFFF用于隔离颜色成分的遮罩。 copySourceBooleanfalse如果该值为 true,则源图像中的像素值将在阈值测试失败时复制到目标图像。如果为 false,则在阈值测试失败时不会复制源图像。 根据指定的阈值测试图像中的像素值,并将通过测试的像素设置为新的颜色值。通过使用 threshold() 方法,您可以隔离和替换图像中的颜色范围,并对图像像素执行其他逻辑操作。

threshold() 方法的测试逻辑如下所示:

  1. 如果 ((pixelValue & mask) operation (threshold & mask)),则将像素设置为 color
  2. 否则,如果 copySource == true,则将像素设置为 sourceBitmap 中的对应像素值。

operation 参数指定要用于阈值测试的比较运算符。例如,通过使用“==”作为 operation 参数,您可以隔离图像中的特定颜色值。或者通过使用 {operation: "<", mask: 0xFF000000, threshold: 0x7F000000, color: 0x00000000},您可以将所有目标像素设置为在源图像像素的 Alpha 小于 0x7F 时是完全透明的。您可以将此技巧用于动画过渡和其他效果。

下例使用 perlinNoise() 方法将蓝色和红色图案添加到一个 BitmapData 对象,然后使用 threshold() 方法将那些像素从第一个 BitmapData 对象复制到第二个 BitmapData 对象,并将红色值大于 0x80 (50%) 的那些像素替换成已设置为透明红色 (0x20FF0000) 的像素: import flash.display.Bitmap; import flash.display.BitmapData; import flash.display.BitmapDataChannel; import flash.geom.Point; import flash.geom.Rectangle; var bmd1:BitmapData = new BitmapData(200, 200, true, 0xFFCCCCCC); var seed:int = int(Math.random() * int.MAX_VALUE); var channels:uint = BitmapDataChannel.RED | BitmapDataChannel.BLUE; bmd1.perlinNoise(100, 80, 12, seed, false, true, channels, false, null); var bitmap1:Bitmap = new Bitmap(bmd1); addChild(bitmap1); var bmd2:BitmapData = new BitmapData(200, 200, true, 0xFFCCCCCC); var pt:Point = new Point(0, 0); var rect:Rectangle = new Rectangle(0, 0, 200, 200); var threshold:uint = 0x00800000; var color:uint = 0x20FF0000; var maskColor:uint = 0x00FF0000; bmd2.threshold(bmd1, rect, pt, ">", threshold, color, maskColor, true); var bitmap2:Bitmap = new Bitmap(bmd2); bitmap2.x = bitmap1.x + bitmap1.width + 10; addChild(bitmap2);
unlock 解除锁定图像,以使引用 BitmapData 对象的任何对象(如 Bitmap 对象)在此 BitmapData 对象更改时更新。changeRectflash.geom:Rectanglenull已更改的 BitmapData 对象的区域。如果没有为此参数指定值,则会认为 BitmapData 对象的整个区域已更改。此参数需要 Flash Player 9.0.115.0 版或更高版本。 解除锁定图像,以使引用 BitmapData 对象的任何对象(如 Bitmap 对象)在此 BitmapData 对象更改时更新。要提高性能,请在对 setPixel()setPixel32() 方法进行多次调用之前和之后使用此方法及 lock() 方法。 下例根据 Bitmap 对象 picturebitmapData 属性创建一个 BitmapData 对象。然后,该示例先调用 lock() 方法再调用复杂的自定义函数 complexTransformation(),该函数可修改 BitmapData 对象。(picture 对象和 complexTransformation() 函数未在本示例中定义。) 即使 complexTransformation() 函数更新了 picture 对象的 bitmapData 属性,这些更新也只有在代码对 bitmapData 对象调用 unlock() 方法之后才会得到体现: import flash.display.BitmapData; var bitmapData:BitmapData = picture.bitmapData; bitmapData.lock(); bitmapData = complexTransformation(bitmapData); bitmapData.unlock(); picture.bitmapData = bitmapData; lock()setPixel()setPixel32()height 位图图像的高度,以像素为单位。int 位图图像的高度,以像素为单位。 rect 定义位图图像大小和位置的矩形。flash.geom:Rectangle 定义位图图像大小和位置的矩形。矩形的顶部和左侧为零;宽度和高度等于 BitmapData 对象的宽度和高度(以像素为单位)。 transparent 定义位图图像是否支持每个像素具有不同的透明度。Boolean 定义位图图像是否支持每个像素具有不同的透明度。只有当通过为构造函数的 transparent 参数传入 true 来构造 BitmapData 对象时,才能设置此值。然后,在创建 BitmapData 对象之后,可以通过确定 transparent 属性的值是否为 true 来检查该对象是否支持每个像素具有不同的透明度。 width 位图图像的宽度,以像素为单位。int 位图图像的宽度,以像素为单位。
JointStyle JointStyle 类是指定要在绘制线条中使用的联接点样式的常量值枚举。Object JointStyle 类是指定要在绘制线条中使用的联接点样式的常量值枚举。提供的这些常量用作 flash.display.Graphics.lineStyle() 方法的 joints 参数中的值。此方法支持三种类型的连接:尖角、圆角和斜角,如下例所示:

下例使用 JointStyleExample 类显示应用于三组连接线的三种不同联接点样式的结果。执行下列步骤可完成该任务:
  1. 每条线的属性设置如下所示:
    • 将线条长度设置为 80 像素。
    • 将边框颜色设置为橙色。
    • 将边框大小设置为 30 像素。
    • 将加亮颜色设置为灰色。
    • 将加亮大小设置为 0 像素。
    • 将 Alpha 设置为 1,使其成为实线。
    • 将像素提示设置为 false(不提示笔触采用全部像素)。
    • 将线条缩放模式设置为正常,这将缩放粗细。
    • 声明了边框端点和尖角限制,但未进行设置,因此使用默认值。
  2. 类构造函数创建了三组两条连接的线段。线段的起始位置为 x = 0, y = 0,这是通过使用三种联接点样式(尖角、圆角和斜角)调用 doDrawCorner() 方法三次实现的。对 doDrawCorner() 的三次调用均使用先前列出的联接点样式和属性,来绘制两条连接的线段以及关联的线条加亮效果。实现此操作的方法是:首先创建一个新的 Shape 对象 child,然后使用 Graphics 类的方法来设置线条样式,并绘制线条和加亮效果。child 的每个实例都添加到显示列表中,并且在舞台上快速绘制。
  3. 然后使用 refreshLayout() 方法,在 y = 80 像素处并从 x = 80 像素处开始以 25 像素的线段间距重绘连接的线段。
package { import flash.display.DisplayObject; import flash.display.Graphics; import flash.display.JointStyle; import flash.display.LineScaleMode; import flash.display.Shape; import flash.display.Sprite; public class JointStyleExample extends Sprite { private var size:uint = 80; private var borderColor:uint = 0xFFCC00; private var borderSize:uint = 30; private var highlightColor:uint = 0x666666; private var highlightSize:uint = 0; private var gutter:uint = 25; private var borderAlpha:uint = 1; private var borderPixelHinting:Boolean = false; private var borderScaleMode:String = LineScaleMode.NORMAL; private var borderCaps:String; private var borderMiterLimit:uint; public function JointStyleExample() { doDrawCorner(JointStyle.MITER); doDrawCorner(JointStyle.ROUND); doDrawCorner(JointStyle.BEVEL); refreshLayout(); } private function doDrawCorner(jointStyle:String):void { var halfSize:uint = Math.round(size / 2); var child:Shape = new Shape(); child.graphics.lineStyle(borderSize, borderColor, borderAlpha, borderPixelHinting, borderScaleMode, borderCaps, jointStyle, borderMiterLimit); child.graphics.lineTo(0, 0); child.graphics.lineTo(size, 0); child.graphics.lineTo(halfSize, size); child.graphics.endFill(); child.graphics.moveTo(0, 0); child.graphics.lineStyle(highlightSize, highlightColor); child.graphics.lineTo(0, 0); child.graphics.lineTo(size, 0); child.graphics.lineTo(halfSize, size); addChild(child); } private function refreshLayout():void { var ln:uint = numChildren; var child:DisplayObject; var lastChild:DisplayObject = getChildAt(0); lastChild.x = size; lastChild.y = size; for (var i:uint = 1; i < ln; i++) { child = getChildAt(i); child.x = gutter + lastChild.x + lastChild.width; child.y = size; lastChild = child; } } } }
flash.display.Graphics.lineStyle()BEVEL 在 flash.display.Graphics.lineStyle() 方法的 joints 参数中指定斜角连接。bevelStringflash.display.Graphics.lineStyle() 方法的 joints 参数中指定斜角连接。 MITER 在 flash.display.Graphics.lineStyle() 方法的 joints 参数中指定尖角连接。miterStringflash.display.Graphics.lineStyle() 方法的 joints 参数中指定尖角连接。 ROUND 在 flash.display.Graphics.lineStyle() 方法的 joints 参数中指定圆角连接。roundStringflash.display.Graphics.lineStyle() 方法的 joints 参数中指定圆角连接。
AVM1Movie AVM1Movie 是表示使用 ActionScript 1.0 或 2.0 的 AVM1 影片剪辑的简单类。flash.display:DisplayObject AVM1Movie 是表示使用 ActionScript 1.0 或 2.0 的 AVM1 影片剪辑的简单类。(AVM1 是用于运行 ActionScript 1.0 和 2.0 的 ActionScript 虚拟机。AVM2 是用于运行 ActionScript 3.0 的 ActionScript 虚拟机。) 当 Loader 对象加载 Flash Player 8 或更低版本的 SWF 文件时,会创建 AVM1Movie 对象。AVM1Movie 对象可以使用继承自 DisplayObject 类的方法和属性(如 xywidth 等)。但是,不允许 AVM1Movie 对象和 AVM2 对象之间进行互操作(如调用方法或使用参数)。

AVM2 SWF 文件加载 AVM1 SWF 文件具有几个限制:

  • 加载的 AVM1Movie 对象将作为 AVM1 SWF 文件和它加载的所有 AVM1 SWF 文件的 psuedo-root 对象操作(如同将 ActionScript 1.0 lockroot 属性设置为 true)。AVM1 影片始终位于任何子级中任何 ActionScript 1.0 或 2.0 代码执行的顶部。除非在加载的 AVM1 SWF 文件中设置 lockroot 属性,否则加载的子级的 _root 属性通常均为该 AVM1 SWF 文件。
  • AVM1 内容无法将文件加载到各级别。例如,它无法通过调用 loadMovieNum("url", levelNum) 来加载文件。
  • 由 AVM2 SWF 文件加载的 AVM1 SWF 文件无法将其他 SWF 文件加载到 this。也就是说,它无法向其自身加载其他 SWF 文件。但是,由该 SWF 文件加载的子 Sprite 对象、MovieClip 对象或其他 AVM1 SWF 文件可以加载到 this
DisplayObjectLoader
ShaderInput ShaderInput 实例表示着色器内核的单一输入图像。Object ShaderInput 实例表示着色器内核的单一输入图像。可以将内核定义为接受在内核执行过程中使用的 0 个、1 个或更多源图像。ShaderInput 实例提供了一种机制,用于指定在着色器执行时使用的输入图像。要为输入指定值,请创建包含图像数据的 BitmapData、ByteArray 或 Vector.<Number> 实例,并将其赋予 input 属性。

表示 Shader 实例的输入图像的 ShaderInput 实例将作为 Shader 实例的 data 属性的一个属性进行访问。ShaderInput 属性的名称与着色器代码中输入的名称相同。例如,如果着色器定义一个名为 src 的输入,则表示 src 输入的 ShaderInput 实例可作为 src 属性使用,如此示例所示:

myShader.data.src.image = new BitmapData(50, 50, true, 0xFF990000);

对于 Shader 实例的某些用法,您无需指定输入图像,因为操作会自动指定输入图像。您只需要在 Shader 用于以下各项时指定输入:

  • 着色器填充
  • ShaderFilter:如果将着色器定义为使用一个以上的输入,则只适用于第二个输入或其他输入。(将自动使用应用了滤镜的对象作为第一个输入。)
  • 着色器混合模式:如果将着色器定义为使用两个以上的输入,则只适用于第三个输入或其他输入。(将自动使用正在进行混合的对象作为第一个和第二个输入。)
  • ShaderJob background execution

如果正在使用 ShaderJob 实例执行着色器来处理包含线性数据数组的 ByteArray,请在 ByteArray 中将 ShaderInput 实例的 height 设置为 1,并将 width 设置为 32 位浮点值数字。在这种情况下,必须将着色器中的输入定义为具有 image1 数据类型。

通常,开发人员代码不直接创建 ShaderInput 实例。在创建 Shader 实例时,将为着色器的每个输入创建一个 ShaderInput 实例。

flash.display.ShaderDataflash.display.Shader.dataflash.display.ShaderJobShaderInput 创建 ShaderInput 实例。 创建 ShaderInput 实例。开发人员代码不直接调用 ShaderInput 构造函数。在创建 Shader 实例时,将为着色器的每个输入创建一个 ShaderInput 实例。 channels 着色器输入所需的通道数量。int 着色器输入所需的通道数量。当输入数据为 ByteArray 或 Vector.<Number> 实例时,<Number> 实例时。 height 着色器输入的高度。int 着色器输入的高度。仅在输入数据为 ByteArray 或 Vector.<Number> 实例)。如果输入为 BitmapData 实例,则会自动确定高度。 index 着色器中的输入从 0 开始的索引,表示着色器中输入定义的顺序。int 着色器中的输入从 0 开始的索引,表示着色器中输入定义的顺序。 input 在着色器执行时使用的输入数据。Object 在着色器执行时使用的输入数据。此属性可以是 BitmapData 实例、ByteArray 实例或 Vector.<Number> 实例时。

如果将 ByteArray 值赋予 input 属性,则必须满足下列条件:

  • 必须设置 heightwidth 属性。
  • 字节数组的内容必须只包含 32 位浮点值。可以使用 ByteArray.writeFloat() 方法写入这些值。
  • ByteArray 的总长度(以字节为单位)必须正好为:width x height x channels x 4。
  • 字节数组的 endian 属性必须为 Endian.LITTLE_ENDIAN

如果将 Vector.<Number> 实例赋予 input 属性,则 Vector 的长度必须等于:width x height x channels

width 着色器输入的宽度。int 着色器输入的宽度。仅在输入数据为 ByteArray 或 Vector.<Number> 实例)。如果输入为 BitmapData 实例,则会自动确定宽度。
ColorCorrection ColorCorrection 类可为 flash.display.Stage.colorCorrection 属性提供值。Object ColorCorrection 类可为 flash.display.Stage.colorCorrection 属性提供值。 flash.display.Stage.colorCorrectionDEFAULT 使用主机的默认颜色校正。defaultString 使用主机的默认颜色校正。对于 Web 播放器,主机通常是一个浏览器,Flash Player 尝试使用相同的颜色校正作为承载 SWF 文件的网页。 OFF 关闭颜色校正,不论播放器主机环境如何。offString 关闭颜色校正,不论播放器主机环境如何。此设置可提供更快的性能。 ON 打开颜色校正,不论播放器主机环境(如果有)如何。onString 打开颜色校正,不论播放器主机环境(如果有)如何。 Shader Shader 实例表示 ActionScript 中的 Pixel Bender 着色器内核。Object Shader 实例表示 ActionScript 中的 Pixel Bender 着色器内核。要在应用程序中使用着色器,请为它创建一个 Shader 实例。然后,根据要创造的效果,按适当的方式使用该 Shader 实例。例如,要将着色器用作滤镜,可将 Shader 实例赋予 ShaderFilter 对象的 shader 属性。

着色器定义对图像中的所有像素执行的函数(一次一个像素)。对该函数的每次调用的结果都是图像中该像素坐标处的输出颜色。着色器可以指定一个或多个输入图像,这些图像的内容可用于确定函数的输出。着色器还可以指定一个或多个参数,这些参数是可用于计算函数输出的输入值。在单一着色器执行中,输入和参数值是常量。唯一发生变化的是像素(其颜色是函数结果)的坐标。针对多个输出像素坐标的着色器函数调用将并行执行,以改进着色器执行性能。

可以使用 URLLoader 实例在运行时加载着色器字节码。下面的示例演示如何在运行时加载着色器字节码文件并将其链接到一个 Shader 实例。

var loader:URLLoader = new URLLoader(); loader.dataFormat = URLLoaderDataFormat.BINARY; loader.addEventListener(Event.COMPLETE, onLoadComplete); loader.load(new URLRequest("myShader.pbj")); var shader:Shader; function onLoadComplete(event:Event):void { // Create a new shader and set the loaded data as its bytecode shader = new Shader(); shader.byteCode = loader.data; // You can also pass the bytecode to the Shader() constructor like this: // shader = new Shader(loader.data); // do something with the shader }

您还可以使用 [Embed] 元数据标记在编译时将着色器嵌入 SWF。只有在使用 Flex SDK 编译 SWF 时,[Embed] 元数据标记才可用。[Embed] 标记的 source 参数指向着色器文件,并且其 mimeType 参数为“application/octet-stream”,如此例中所示:

[Embed(source="myShader.pbj", mimeType="application/octet-stream)] var MyShaderClass:Class; // ... // create a new shader and set the embedded shader as its bytecode var shaderShader = new Shader(); shader.byteCode = new MyShaderClass(); // You can also pass the bytecode to the Shader() constructor like this: // var shader:Shader = new Shader(new MyShaderClass()); // do something with the shader

在任何一种情况下,都可以将原始着色器(URLLoader.data 属性或 [Embed] 数据类的实例)链接到 Shader 实例。如前面的示例所演示,您可以采用两种方式执行此操作。可以将着色器字节代码作为参数传递到 Shader() 构造函数。或者,可以将其设置为 Shader 实例的 byteCode 属性。

创建了 Shader 实例后,即可通过以下若干方式之一使用该实例:

  • 着色器填充:使用着色器的输出作为利用绘图 API 所绘制内容的填充。将 Shader 实例作为参数传递到 Graphics.beginShaderFill() 方法。
  • 着色器滤镜:使用着色器的输出作为应用于显示对象的图形滤镜。将 Shader 实例赋予 ShaderFilter 实例的 shader 属性。
  • 混合模式:着色器的输出呈现为两个重叠显示对象之间的混合。将 Shader 实例赋予两个显示对象中位于上层的对象的 blendShader 属性。
  • 后台着色器处理:着色器在后台执行(避免了冻结显示的可能性),并在处理完成时调度一个事件。将 Shader 实例赋予 ShaderJob 实例的 shader 属性。

在 GPU 呈现下不支持着色器填充、滤镜和混合。

移动浏览器支持:在移动浏览器中不支持此功能。

AIR 配置文件支持:所有桌面操作系统均支持此功能,但所有移动设备均不支持此功能。用于电视的 AIR 设备不支持此功能。有关在多个配置文件之间支持 API 的详细信息,请参阅 AIR 配置文件支持

下面的示例在运行时加载着色器字节码文件,并创建一个链接到该文件的 Shader 实例。

请注意,此示例假设应用程序输出目录所在的同一目录中有一个名为“donothing.pbj”的着色器字节码文件。ShaderData 类示例中提供了 DoNothing 着色器的 Pixel Bender 源代码。

package { import flash.display.Shader; import flash.display.Sprite; import flash.events.Event; import flash.net.URLLoader; import flash.net.URLLoaderDataFormat; import flash.net.URLRequest; public class LoadedShaderExample extends Sprite { private var loader:URLLoader; public function LoadedShaderExample() { loader = new URLLoader(); loader.dataFormat = URLLoaderDataFormat.BINARY; loader.addEventListener(Event.COMPLETE, loadCompleteHandler); loader.load(new URLRequest("donothing.pbj")); } private function loadCompleteHandler(event:Event):void { var shader:Shader = new Shader(); shader.byteCode = loader.data; // do something with the Shader instance } } }
下面的示例通过将着色器字节码文件编译到 SWF 中来嵌入该文件,并创建一个链接到该文件的 Shader 实例。

请注意,此示例假设应用程序源代码所在的同一目录中有一个名为“donothing.pbj”的着色器字节码文件,并且使用了 Flex SDK 来编译 SWF。ShaderData 类示例中提供了 DoNothing 着色器的 Pixel Bender 源代码。

package { import flash.display.Shader; import flash.display.Sprite; public class EmbeddedShaderExample extends Sprite { [Embed(source="donothing.pbj", mimeType="application/octet-stream")] private static var DoNothingShader:Class; public function EmbeddedShaderExample() { var shader:Shader = new Shader(); shader.byteCode = new DoNothingShader(); // do something with the Shader instance } } }
flash.display.DisplayObject.blendShaderflash.display.Graphics.beginShaderFill()flash.display.ShaderJobflash.filters.ShaderFilterflash.net.URLLoaderShader 创建一个新的 Shader 实例。codeflash.utils:ByteArraynull要链接到 Shader 的原始着色器字节代码。 创建一个新的 Shader 实例。 data 提供对 Shader 实例的参数、输入图像和元数据的访问。flash.display:ShaderData 提供对 Shader 实例的参数、输入图像和元数据的访问。在创建 Shader 实例时,将动态添加表示着色器参数的 ShaderParameter 对象、表示着色器输入图像的 ShaderInput 对象以及表示着色器元数据的其他值,作为 data 属性对象的属性。可以使用这些属性对着色器进行内部检查,以及设置参数和输入值。

有关访问和处理 data 对象的动态属性的信息,请参阅 ShaderData 类说明。

flash.display.ShaderDataflash.display.ShaderInputflash.display.ShaderParameter
precisionHint 着色器所执行数学运算的精度。String 着色器所执行数学运算的精度。

precisionHint 属性的可能值的集合由 ShaderPrecision 类中的常量定义。

默认值为 ShaderPrecision.FULL。将精度设置为 ShaderPrecision.FAST 可以加快数学运算速度,但会降低精度。

full 精度模式 (ShaderPrecision.FULL) 将按照 IEEE 32 位浮点标准的全宽计算所有数学运算,并在所有平台上提供一致的行为。在此模式下,某些数学运算(比如三角函数和指数函数)可能速度较慢。

fast 精度模式 (ShaderPrecision.FAST) 旨在获得最高性能,但在不同平台上和各种 CPU 配置下工作不一致。多数情况下,这种精度级别足以创建无可见失真的图形效果。

精度模式选择将影响以下着色器操作。在包含 SSE 指令集的 Intel 处理器上,这些操作的执行速度较快:

  • sin(x)
  • cos(x)
  • tan(x)
  • asin(x)
  • acos(x)
  • atan(x)
  • atan(x, y)
  • exp(x)
  • exp2(x)
  • log(x)
  • log2(x)
  • pow(x, y)
  • reciprocal(x)
  • sqrt(x)
flash.display.ShaderPrecision
byteCode 此 Shader 实例的原始着色器字节代码。flash.utils:ByteArray 此 Shader 实例的原始着色器字节代码。
LineScaleMode LineScaleMode 类为 Graphics.lineStyle() 方法中的 scaleMode 参数提供值。Object LineScaleMode 类为 Graphics.lineStyle() 方法中的 scaleMode 参数提供值。 flash.display.Graphics.lineStyle()HORIZONTAL 将此设置用作 lineStyle() 方法的 scaleMode 参数时,线条粗细只会垂直缩放。horizontalString 将此设置用作 lineStyle() 方法的 scaleMode 参数时,线条粗细只会垂直缩放。例如,考虑下面的圆形,它们是用一个像素的线条绘制的,每个圆的 scaleMode 参数都被设置为 LineScaleMode.VERTICAL。左侧的圆仅在垂直方向上缩放,右侧的圆同时在垂直和水平方向上缩放。

NONE 将此设置用作 lineStyle() 方法的 scaleMode 参数时,线条粗细不会缩放。noneString 将此设置用作 lineStyle() 方法的 scaleMode 参数时,线条粗细不会缩放。 NORMAL 将此设置用作 lineStyle() 方法的 scaleMode 参数时,线条粗细会始终随对象的缩放而缩放(默认值)。normalString 将此设置用作 lineStyle() 方法的 scaleMode 参数时,线条粗细会始终随对象的缩放而缩放(默认值)。 VERTICAL 将此设置用作 lineStyle() 方法的 scaleMode 参数时,线条粗细只会水平缩放。verticalString 将此设置用作 lineStyle() 方法的 scaleMode 参数时,线条粗细只会水平缩放。例如,考虑下面的圆形,它们是用一个像素的线条绘制的,每个圆的 scaleMode 参数都被设置为 LineScaleMode.HORIZONTAL。左侧的圆仅在水平方向上缩放,右侧的圆同时在垂直和水平方向上缩放。

IGraphicsData 此接口用于定义可用作 flash.display.Graphics 方法中的参数的对象,包括填充、笔触和路径。 此接口用于定义可用作 flash.display.Graphics 方法中的参数的对象,包括填充、笔触和路径。使用此接口的实现器类来创建和管理绘制属性数据,并将相同的数据重新用于不同的实例。然后,使用 Graphics 类的方法来呈现绘制对象。 flash.display.Graphics.drawGraphicsData()MovieClip MovieClip 类从以下类继承而来:Sprite、DisplayObjectContainer、InteractiveObject、DisplayObject 和 EventDispatcher。ActionScript 的基本显示对象创建了对象。 flash.display:Sprite MovieClip 类从以下类继承而来:Sprite、DisplayObjectContainer、InteractiveObject、DisplayObject 和 EventDispatcher。

不同于 Sprite 对象,MovieClip 对象拥有一个时间轴。

> 在 Flash Professional 中,MovieClip 类使用的方法提供的功能与定位影片剪辑的操作相同。还有一些其他方法在 Flash 创作工具的“动作”面板中的“动作”工具箱中没有等效动作。

在 Flash Professional 中放到舞台上的子实例无法由父实例构造函数中的代码进行访问,因为在执行代码时尚未在该位置创建这些实例。在访问子实例之前,父实例必须通过代码创建子实例,或者延迟访问用于侦听子实例以调度其 Event.ADDED_TO_STAGE 事件的回调函数。

如果修改包含补间动画的 MovieClip 对象的下列任一属性,该 MovieClip 对象中的播放头便会停止:alphablendModefiltersheightopaqueBackgroundrotationscaleXscaleYscale9GridscrollRecttransformvisiblewidthxy。但是,它不会停止在该 MovieClip 对象的任何子 MovieClip 对象中的播放头。

注意:仅当定义了 FEATURE_BITMAPCACHE 后 Flash Lite 4 才支持 MovieClip.opaqueBackground 属性。Flash Lite 4 的默认配置不会定义 FEATURE_BITMAPCACHE。要为合适的设备启用 MovieClip.opaqueBackground 属性,请在您的项目中定义 FEATURE_BITMAPCACHE。

下例用 MovieClipExample 类来说明如何监视 MovieClip 的各种属性。执行下列步骤可完成该任务:
  1. 构造函数定义一个文本字段,该文本字段用于显示 MovieClipExample 对象(扩展了 MovieClip)的属性值。
  2. getPropertiesString() 方法的返回值用作 outputText 文本字段的文本。getPropertiesString() 方法返回一个使用影片剪辑的以下属性值填充的字符串:currentFramecurrentLabelcurrentSceneframesLoadedtotalFramestrackAsMenu
  3. 构造函数中的两行代码调整 outputText 文本字段的 widthheight 属性。
  4. 构造函数的最后一行将 outputText 文本字段添加到显示列表。
package { import flash.display.MovieClip; import flash.text.TextField; public class MovieClipExample extends MovieClip { public function MovieClipExample() { var outputText:TextField = new TextField(); outputText.text = getPropertiesString(); outputText.width = stage.stageWidth; outputText.height = outputText.textHeight; addChild(outputText); } private function getPropertiesString():String { var str:String = "" + "currentFrame: " + currentFrame + "\n" + "currentLabel: " + currentLabel + "\n" + "currentScene: " + currentScene + "\n" + "framesLoaded: " + framesLoaded + "\n" + "totalFrames: " + totalFrames + "\n" + "trackAsMenu: " + trackAsMenu + "\n"; return str; } } }
MovieClip 创建新的 MovieClip 实例。 创建新的 MovieClip 实例。创建 MovieClip 之后,调用舞台上的显示对象容器的 addChild()addChildAt() 方法。 gotoAndPlay 从指定帧开始播放 SWF 文件。frameObject表示播放头转到的帧编号的数字,或者表示播放头转到的帧标签的字符串。如果您指定了一个数字,则该数字是相对于您指定的场景的。如果不指定场景,当前场景将确定要播放的全局帧编号。如果指定场景,播放头会跳到指定场景的帧编号。 sceneStringnull要播放的场景的名称。此参数是可选的。 从指定帧开始播放 SWF 文件。这会在帧中的所有剩余动作执行完毕后发生。要指定场景以及帧,请指定 scene 参数的值。 下面的代码使用 gotoAndPlay() 方法指示 mc1 影片剪辑的播放头从其当前位置前进 5 帧: mc1.gotoAndPlay(mc1.currentFrame + 5); 下面的代码使用 gotoAndPlay() 方法指示 mc1 影片剪辑的播放头移到名为 "Scene 12" 的场景中标记为 "intro" 的帧: mc1.gotoAndPlay("intro", "Scene 12"); gotoAndStop 将播放头移到影片剪辑的指定帧并停在那里。如果未在该影片剪辑中找到指定的 sceneframeArgumentErrorArgumentErrorframeObject表示播放头转到的帧编号的数字,或者表示播放头转到的帧标签的字符串。如果您指定了一个数字,则该数字是相对于您指定的场景的。如果不指定场景,当前场景将确定转到其中并停止的全局帧编号。如果指定了场景,播放头会转到指定场景中的帧编号并停止。 sceneStringnull场景的名称。此参数是可选的。 将播放头移到影片剪辑的指定帧并停在那里。这会在帧中的所有剩余动作执行完毕后发生。如果除了指定帧以外,您还希望指定场景,那么请指定 scene 参数。 下面的代码使用 gotoAndStop() 方法和 currentFrame 属性指示 mc1 影片剪辑的播放头从其当前位置前进 5 帧并停止: mc1.gotoAndStop(mc1.currentFrame + 5); 下面的代码使用 gotoAndStop() 指示 mc1 影片剪辑的播放头移到名为 "Scene 12" 的场景中标记为 "finale" 的帧并停止播放头: mc1.gotoAndStop("finale", "Scene 12"); nextFrame 将播放头转到下一帧并停止。 将播放头转到下一帧并停止。这会在帧中的所有剩余动作执行完毕后发生。 在下例中,由两个 SimpleButton 对象控制时间轴。prev 按钮将播放头移动到前一帧,nextBtn 按钮将播放头移动到下一帧: import flash.events.MouseEvent; mc1.stop(); prevBtn.addEventListener(MouseEvent.CLICK, goBack); nextBtn.addEventListener(MouseEvent.CLICK, goForward); function goBack(event:MouseEvent):void { mc1.prevFrame(); } function goForward(event:MouseEvent):void { mc1.nextFrame(); } prevFrame()nextScene 将播放头移动到 MovieClip 实例的下一场景。 将播放头移动到 MovieClip 实例的下一场景。这会在帧中的所有剩余动作执行完毕后发生。 在下例中,由两个 SimpleButton 对象控制时间轴。prevBtn 按钮将播放头移动到前一场景,nextBtn 按钮将播放头移动到下一场景: import flash.events.MouseEvent; mc1.stop(); prevBtn.addEventListener(MouseEvent.CLICK, goBack); nextBtn.addEventListener(MouseEvent.CLICK, goForward); function goBack(event:MouseEvent):void { mc1.prevScene(); } function goForward(event:MouseEvent):void { mc1.nextScene(); } play 在影片剪辑的时间轴中移动播放头。 在影片剪辑的时间轴中移动播放头。 下面的代码使用 stop() 方法来停止名为 mc1 的影片剪辑,并在用户单击名为 continueText 的文本字段时恢复播放: import flash.text.TextField; import flash.events.MouseEvent; var continueText:TextField = new TextField(); continueText.text = "Play movie..."; addChild(continueText); mc1.stop(); continueText.addEventListener(MouseEvent.CLICK, resumeMovie); function resumeMovie(event:MouseEvent):void { mc1.play(); } gotoAndPlay()prevFrame 将播放头转到前一帧并停止。 将播放头转到前一帧并停止。这会在帧中的所有剩余动作执行完毕后发生。 在下例中,由两个 SimpleButton 对象控制时间轴。prev 按钮将播放头移动到前一帧,nextBtn 按钮将播放头移动到下一帧: import flash.events.MouseEvent; mc1.stop(); prevBtn.addEventListener(MouseEvent.CLICK, goBack); nextBtn.addEventListener(MouseEvent.CLICK, goForward); function goBack(event:MouseEvent):void { mc1.prevFrame(); } function goForward(event:MouseEvent):void { mc1.nextFrame(); } prevScene 将播放头移动到 MovieClip 实例的前一场景。 将播放头移动到 MovieClip 实例的前一场景。这会在帧中的所有剩余动作执行完毕后发生。 在下例中,由两个 SimpleButton 对象控制时间轴。prevBtn 按钮将播放头移动到前一场景,nextBtn 按钮将播放头移动到下一场景: import flash.events.MouseEvent; mc1.stop(); prevBtn.addEventListener(MouseEvent.CLICK, goBack); nextBtn.addEventListener(MouseEvent.CLICK, goForward); function goBack(event:MouseEvent):void { mc1.prevScene(); } function goForward(event:MouseEvent):void { mc1.nextScene(); } stop 停止影片剪辑中的播放头。 停止影片剪辑中的播放头。 currentFrameLabel MovieClip 实例的时间轴中当前帧上的标签。String MovieClip 实例的时间轴中当前帧上的标签。如果当前帧没有标签,则 currentLabelnullcurrentFrame 指定播放头在 MovieClip 实例的时间轴中所处的帧的编号。int 指定播放头在 MovieClip 实例的时间轴中所处的帧的编号。如果影片剪辑有多个场景,该值是当前场景中的帧编号。 下面的代码使用 gotoAndStop() 方法和 currentFrame 属性指示 mc1 影片剪辑的播放头从其当前位置前进 5 帧并停止: mc1.gotoAndStop(mc1.currentFrame + 5); currentLabel 在 MovieClip 实例的时间轴中播放头所在的当前标签。String 在 MovieClip 实例的时间轴中播放头所在的当前标签。如果当前帧没有标签,currentLabel 将被设置为包含标签的先前帧的名称。如果当前帧和先前帧都不包含标签,currentLabel 返回 null 以下代码说明如何访问名为 mc1 的 MovieClip 对象的 currentLabel 属性: trace(mc1.currentLabel); currentLabels 返回由当前场景的 FrameLabel 对象组成的数组。Array 返回由当前场景的 FrameLabel 对象组成的数组。如果 MovieClip 实例不使用场景,数组会包括整个 MovieClip 实例的所有帧标签。 以下代码说明如何使用名为 mc1 的 MovieClip 对象的 currentLabels 属性: import flash.display.FrameLabel; var labels:Array = mc1.currentLabels; for (var i:uint = 0; i < labels.length; i++) { var label:FrameLabel = labels[i]; trace("frame " + label.frame + ": " + label.name); } flash.display.FrameLabelcurrentScene 在 MovieClip 实例的时间轴中播放头所在的当前场景。flash.display:Scene 在 MovieClip 实例的时间轴中播放头所在的当前场景。 以下代码说明如何使用名为 mc1 的 MovieClip 对象的 currentScene 属性: import flash.display.Scene; var scene:Scene = mc1.currentScene; trace(scene.name + ": " + scene.numFrames + " frames"); Sceneenabled 一个布尔值,表示影片剪辑是否处于活动状态。Boolean 一个布尔值,表示影片剪辑是否处于活动状态。enabled 的默认值是 true。如果将 enabled 设置为 false,则会禁用影片剪辑的 Over、Down 和 Up 帧。影片剪辑会继续接收事件(例如 mouseDownmouseUpkeyDownkeyUp)。

enabled 属性仅控制影片剪辑的按钮式属性。可以随时更改 enabled 属性;修改后的影片剪辑将被立即启用或禁用。如果将 enabled 属性设置为 false,则该对象将不包含在 Tab 键的自动排序中。

以下代码说明如何使用 enabled 属性来禁用名为 mc1 的 MovieClip 对象的按钮式属性: mc1.enabled = false;
framesLoaded 从流式 SWF 文件加载的帧数。int 从流式 SWF 文件加载的帧数。可以使用 framesLoaded 属性来确定特定帧及其前面所有帧的内容是否已经加载,并且是否可在浏览器中供本地使用。可以使用它监视大 SWF 文件的下载。例如,可能需要向用户显示一条消息以表明在完成 SWF 文件中指定帧的加载前,SWF 文件将会一直进行加载。

如果影片剪辑包含多个场景,framesLoaded 属性会返回为影片剪辑中所有 场景加载的帧数。

以下代码说明如何使用 framesLoaded 属性和 totalFrames 属性来确定名为 mc1 的流式 MovieClip 对象是否已完全加载: if (mc1.framesLoaded == mc1.totalFrames) { trace("OK."); }
Loader 类
scenes 一个由 Scene 对象组成的数组,每个对象都列出了 MovieClip 实例中场景的名称、帧数和帧标签。Array 一个由 Scene 对象组成的数组,每个对象都列出了 MovieClip 实例中场景的名称、帧数和帧标签。 以下代码说明如何使用名为 mc1 的 MovieClip 对象的 scenes 属性: import flash.display.Scene; for (var i:uint = 0; i < mc1.scenes.length; i++) { var scene:Scene = mc1.scenes[i]; trace("scene " + scene.name + ": " + scene.numFrames + " frames"); } ScenetotalFrames MovieClip 实例中帧的总数。int MovieClip 实例中帧的总数。

如果影片剪辑包含多个帧,totalFrames 属性会返回影片剪辑中的所有 场景中的帧的总数。

以下代码说明如何使用名为 mc1 的 MovieClip 对象的 totalFrames 属性: trace(mc1.totalFrames);
trackAsMenu 表示属于 SimpleButton 或 MovieClip 对象的其他显示对象是否可以接收 mouse release 事件或其他 user input release 事件。Boolean 表示属于 SimpleButton 或 MovieClip 对象的其他显示对象是否可以接收 mouse release 事件或其他 user input release 事件。trackAsMenu 属性允许您创建菜单。可以对任何 SimpleButton 或 MovieClip 对象设置 trackAsMenu 属性。trackAsMenu 属性的默认值是 false

可以随时更改 trackAsMenu 属性;修改后的影片剪辑会立即使用新的行为。

以下代码说明如何使用 trackAsMenu 属性来启用名为 mc1 的 MovieClip 对象的鼠标释放事件: mc1.trackAsMenu = true;
SWFVersion SWFVersion 类是可表示已加载 SWF 文件的文件格式版本的常量值枚举。Object SWFVersion 类是可表示已加载 SWF 文件的文件格式版本的常量值枚举。提供的 SWFVersion 常量用于检查 flash.display.LoaderInfo 对象的 swfVersion 属性。 flash.display.LoaderInfo.swfVersionFLASH10 SWF 文件格式版本 10.0。10uint SWF 文件格式版本 10.0。 FLASH11 SWF 文件格式版本 11.0。11uint SWF 文件格式版本 11.0。 FLASH1 SWF 文件格式版本 1.0。1uint SWF 文件格式版本 1.0。 FLASH2 SWF 文件格式版本 2.0。2uint SWF 文件格式版本 2.0。 FLASH3 SWF 文件格式版本 3.0。3uint SWF 文件格式版本 3.0。 FLASH4 SWF 文件格式版本 4.0。4uint SWF 文件格式版本 4.0。 FLASH5 SWF 文件格式版本 5.0。5uint SWF 文件格式版本 5.0。 FLASH6 SWF 文件格式版本 6.0。6uint SWF 文件格式版本 6.0。 FLASH7 SWF 文件格式版本 7.0。7uint SWF 文件格式版本 7.0。 FLASH8 SWF 文件格式版本 8.0。8uint SWF 文件格式版本 8.0。 FLASH9 SWF 文件格式版本 9.0。9uint SWF 文件格式版本 9.0。 NativeWindowResize NativeWindowResize 类定义一些常量,它们表示 NativeWindow startResize() 方法的 edgeOrCorner 参数的可能值。定义为响应用户动作而调整窗口大小时使用的常量。 Object NativeWindowResize 类定义一些常量,它们表示 NativeWindow startResize() 方法的 edgeOrCorner 参数的可能值。

定义常量以命名窗口的每条边和每个角。

flash.display.NativeWindow.startResize()BOTTOM_LEFT 窗口的左下角。BLString 窗口的左下角。 BOTTOM_RIGHT 窗口的右下角。BRString 窗口的右下角。 BOTTOM 窗口的底边。BString 窗口的底边。 LEFT 窗口的左边。LString 窗口的左边。 NONE 用于在支持键盘调整大小的系统(例如 Windows)上通过键盘调整大小。String 用于在支持键盘调整大小的系统(例如 Windows)上通过键盘调整大小。在 Windows 上,这类似于从 Alt+Space 菜单中选择“大小”命令。调用 NativeWindow.startResize(NativeWindowResize.NONE) 时,Windows 用户可以使用键盘上的箭头键调整窗口的大小。 RIGHT 窗口的右边。RString 窗口的右边。 TOP_LEFT 窗口的左上角。TLString 窗口的左上角。 TOP_RIGHT 窗口的右上角。TRString 窗口的右上角。 TOP 窗口的顶边。TString 窗口的顶边。
BitmapDataChannel BitmapDataChannel 类是常数值枚举,表示要使用的通道:红色通道、蓝色通道、绿色通道或 Alpha 透明度通道。Object BitmapDataChannel 类是常数值枚举,表示要使用的通道:红色通道、蓝色通道、绿色通道或 Alpha 透明度通道。

调用某些方法时,您可以使用按位 OR (|) 运算符来合并 BitmapDataChannel 常数,从而表示多个颜色通道。

提供的 BitmapDataChannel 常数用作以下参数或属性的值:

  • flash.display.BitmapData.copyChannel() 方法的 sourceChanneldestChannel 参数
  • flash.display.BitmapData.noise() 方法的 channelOptions 参数
  • flash.filters.DisplacementMapFilter.componentXflash.filters.DisplacementMapFilter.componentY 属性
flash.display.BitmapData.copyChannel()flash.display.BitmapData.noise()flash.filters.DisplacementMapFilter.componentXflash.filters.DisplacementMapFilter.componentYALPHA Alpha 通道。8uint Alpha 通道。 BLUE 蓝色通道。4uint 蓝色通道。 GREEN 绿色通道。2uint 绿色通道。 RED 红色通道。1uint 红色通道。
GraphicsSolidFill 定义实心填充。flash.display:IGraphicsFillflash.display:IGraphicsDataObject 定义实心填充。

将 GraphicsSolidFill 对象与 Graphics.drawGraphicsData() 方法一起使用。绘制 GraphicsSolidFill 对象与调用 Graphics.beginFill() 方法是等效的。

flash.display.Graphics.beginFill()flash.display.Graphics.drawGraphicsData()GraphicsSolidFill 创建新的 GraphicsSolidFill 对象。coloruint0颜色值。有效值采用十六进制格式 0xRRGGBB。 alphaNumber1.0Alpha 透明度值。有效值为 0(完全透明)到 1(完全不透明)。 创建新的 GraphicsSolidFill 对象。 alpha 表示填充的 Alpha 透明度值。1.0Number 表示填充的 Alpha 透明度值。有效值为 0(完全透明)到 1(完全不透明)。默认值为 1。Alpha 设置为 0 的显示对象是活动对象,即使它们不可见。 color 填充的颜色。0uint 填充的颜色。有效值采用十六进制格式 0xRRGGBB。默认值为 0xFF0000(或 uint 0)。
IBitmapDrawable IBitmapDrawable 接口由可以作为 BitmapData 类 draw() 方法 source 参数传递的对象来实现。 IBitmapDrawable 接口由可作为 BitmapData 类 draw() 方法的 source 参数传递的对象来实现。这些对象的类型为 BitmapData 或 DisplayObject。 flash.display.BitmapData.draw()flash.display.BitmapDataflash.display.DisplayObjectCapsStyle CapsStyle 类是可指定在绘制线条中使用的端点样式的常量值枚举。Object CapsStyle 类是可指定在绘制线条中使用的端点样式的常量值枚举。常量可用作 flash.display.Graphics.lineStyle() 方法的 caps 参数中的值。可以指定以下三种类型的端点:

下例使用 CapsStyleExample 类绘制三条平行线,并且每条平行线具有不同的线条端点样式。
  1. 每条线的属性设置如下所示:
    • 将线条长度设置为 80 像素。
    • 将边框颜色设置为橙色。
    • 将边框大小设置为 30 像素。
    • 将加亮颜色设置为灰色。
    • 加亮大小设置为 0 像素。
    • 将 Alpha 设置为 1,使其成为实线。
    • 将像素提示设置为 false(不提示笔触采用全部像素)。
    • 将线条缩放模式设置为正常,这将缩放粗细。
    • 边框端点的联接点样式设置为 MITER
    • 尖角限制设置为 1,指示在接近线条处切断尖角。
  2. 类构造函数以 x = 0, y = 0 为起点创建三条垂直线,方法是使用三种不同的线条端点样式(无、圆头和方头)对 drawLine() 方法进行三次调用。drawLine() 方法的每次调用(共三次)都使用先前列出的端点样式和属性来绘制垂直线和相关线条加亮效果。这些调用首先创建一个新的 child Shape 对象,然后使用 Graphics 类的方法来设置线条样式并绘制线条及加亮效果。child 的每个实例添加到显示列表中并在舞台上进行绘制。
  3. 通过使用 refreshLayout() 方法,在 y = 80 像素处、从 x = 80 像素开始以 25 像素的线段间距重绘连接的线段。
package { import flash.display.CapsStyle; import flash.display.DisplayObject; import flash.display.Graphics; import flash.display.JointStyle; import flash.display.LineScaleMode; import flash.display.Shape; import flash.display.Sprite; public class CapsStyleExample extends Sprite { private var lineLength:uint = 80; private var borderColor:uint = 0xFFCC00; private var borderSize:uint = 30; private var highlightColor:uint = 0x666666; private var highlightSize:uint = 0; private var gutter:uint = 25; private var borderAlpha:uint = 1; private var borderPixelHinting:Boolean = false; private var borderScaleMode:String = LineScaleMode.NORMAL; private var borderJointStyle:String = JointStyle.MITER; private var borderMiterLimit:uint = 1; public function CapsStyleExample() { drawLine(CapsStyle.NONE); drawLine(CapsStyle.ROUND); drawLine(CapsStyle.SQUARE); refreshLayout(); } private function drawLine(capsStyle:String):void { var child:Shape = new Shape(); child.graphics.lineStyle(borderSize, borderColor, borderAlpha, borderPixelHinting, borderScaleMode, capsStyle, borderJointStyle, borderMiterLimit); child.graphics.lineTo(0, 0); child.graphics.lineTo(0, lineLength); child.graphics.endFill(); child.graphics.moveTo(0, 0); child.graphics.lineStyle(highlightSize, highlightColor); child.graphics.lineTo(0, 0); child.graphics.lineTo(0, lineLength); addChild(child); } private function refreshLayout():void { var ln:uint = numChildren; var child:DisplayObject; var lastChild:DisplayObject = getChildAt(0); lastChild.x = lineLength; lastChild.y = lineLength; for (var i:uint = 1; i < ln; i++) { child = getChildAt(i); child.x = gutter + lastChild.x + lastChild.width; child.y = lineLength; lastChild = child; } } } }
flash.display.Graphics.lineStyle()NONE 用于在 flash.display.Graphics.lineStyle() 方法的 caps 参数中指定没有端点。noneString 用于在 flash.display.Graphics.lineStyle() 方法的 caps 参数中指定没有端点。 ROUND 用于在 flash.display.Graphics.lineStyle() 方法的 caps 参数中指定圆头端点。roundString 用于在 flash.display.Graphics.lineStyle() 方法的 caps 参数中指定圆头端点。 SQUARE 用于在 flash.display.Graphics.lineStyle() 方法的 caps 参数中指定方头端点。squareString 用于在 flash.display.Graphics.lineStyle() 方法的 caps 参数中指定方头端点。
StageScaleMode StageScaleMode 类为 Stage.scaleMode 属性提供值。Object StageScaleMode 类为 Stage.scaleMode 属性提供值。 flash.display.Stage.scaleModeEXACT_FIT 指定整个应用程序在指定区域中可见,但不尝试保持原始高宽比。exactFitString 指定整个应用程序在指定区域中可见,但不尝试保持原始高宽比。可能会发生扭曲。 NO_BORDER 指定整个应用程序填满指定区域,不会发生扭曲,但有可能会进行一些裁切,同时保持应用程序的原始高宽比。noBorderString 指定整个应用程序填满指定区域,不会发生扭曲,但有可能会进行一些裁切,同时保持应用程序的原始高宽比。 NO_SCALE 指定应用程序的大小是固定的,因此,即使在更改播放器窗口大小时,它仍然保持不变。noScaleString 指定应用程序的大小是固定的,因此,即使在更改播放器窗口大小时,它仍然保持不变。如果播放器窗口比内容小,则可能进行一些裁切。 SHOW_ALL 指定整个应用程序在指定区域中可见,且不会发生扭曲,同时保持应用程序的原始高宽比。showAllString 指定整个应用程序在指定区域中可见,且不会发生扭曲,同时保持应用程序的原始高宽比。应用程序的两侧可能会显示边框。 SpreadMethod SpreadMethod 类为 Graphics 类的 beginGradientFill() 和 lineGradientStyle() 方法中的 spreadMethod 参数提供值。Object SpreadMethod 类为 Graphics 类的 beginGradientFill()lineGradientStyle() 方法中的 spreadMethod 参数提供值。

下例显示了使用各种 spread 方法的同一渐变填充:

SpreadMethod.PADSpreadMethod.REFLECTSpreadMethod.REPEAT
flash.display.Graphics.beginGradientFill()flash.display.Graphics.lineGradientStyle()PAD 指定渐变使用 pad spread 方法。padString 指定渐变使用 pad spread 方法。 REFLECT 指定渐变使用 reflect spread 方法。reflectString 指定渐变使用 reflect spread 方法。 REPEAT 指定渐变使用 repeat spread 方法。repeatString 指定渐变使用 repeat spread 方法。
FocusDirection FocusDirection 类枚举用于 Stage 对象的 assignFocus() 方法的 direction 参数以及 FocusEvent 对象的 direction 属性的值。Object FocusDirection 类枚举用于 Stage 对象的 assignFocus() 方法的 direction 参数以及 FocusEvent 对象的 direction 属性的值。 flash.events.FocusEvent.directionflash.display.Stage.assignFocus()BOTTOM 表示应使位于读取顺序结尾的对象获得焦点。bottomString 表示应使位于读取顺序结尾的对象获得焦点。 NONE 表示交互式对象内的焦点对象应不更改。noneString 表示交互式对象内的焦点对象应不更改。 TOP 表示应使位于读取顺序开头的对象获得焦点。topString 表示应使位于读取顺序开头的对象获得焦点。 StageAlign StageAlign 类提供了用于 Stage.align 属性的常量值。Object StageAlign 类提供了用于 Stage.align 属性的常量值。 flash.display.Stage.alignBOTTOM_LEFT 指定舞台靠左下角对齐。BLString 指定舞台靠左下角对齐。 BOTTOM_RIGHT 指定舞台靠右下角对齐。BRString 指定舞台靠右下角对齐。 BOTTOM 指定舞台靠底部对齐。BString 指定舞台靠底部对齐。 LEFT 指定舞台靠左对齐。LString 指定舞台靠左对齐。 RIGHT 指定舞台靠右对齐。RString 指定舞台靠右对齐。 TOP_LEFT 指定舞台靠左上角对齐。TLString 指定舞台靠左上角对齐。 TOP_RIGHT 指定舞台靠右上角对齐。TRString 指定舞台靠右上角对齐。 TOP 指定舞台靠顶部对齐。TString 指定舞台靠顶部对齐。 ColorCorrectionSupport ColorCorrectionSupport 类可为 flash.display.Stage.colorCorrectionSupport 属性提供值。Object ColorCorrectionSupport 类可为 flash.display.Stage.colorCorrectionSupport 属性提供值。 flash.display.Stage.colorCorrectionSupportDEFAULT_OFF 支持颜色校正,默认情况下为关闭状态。defaultOffString 支持颜色校正,默认情况下为关闭状态。 DEFAULT_ON 支持颜色校正,默认情况下为打开状态。defaultOnString 支持颜色校正,默认情况下为打开状态。 UNSUPPORTED 主机环境不支持颜色校正。unsupportedString 主机环境不支持颜色校正。 GraphicsShaderFill 定义着色器填充。flash.display:IGraphicsFillflash.display:IGraphicsDataObject 定义着色器填充。

将 GraphicsShaderFill 对象与 Graphics.drawGraphicsData() 方法一起使用。绘制 GraphicsShaderFill 对象与调用 Graphics.beginShaderFill() 方法是等效的。

flash.display.Graphics.beginShaderFill()flash.display.Graphics.drawGraphicsData()GraphicsShaderFill 创建新的 GraphicsShaderFill 对象。shaderflash.display:Shadernull要用于填充的着色器。此 Shader 实例无需指定图像输入。但是,如果在着色器中指定了图像输入,则必须手动提供输入,方法是设置 Shader.data 属性的对应 ShaderInput 属性的 input 属性。 matrixflash.geom:Matrixnull一个 matrix 对象(属于 flash.geom.Matrix 类),可用于对着色器定义转换。 创建新的 GraphicsShaderFill 对象。 flash.geom.Matrixflash.display.Shadermatrix 一个 matrix 对象(属于 flash.geom.Matrix 类),可用于对着色器定义转换。flash.geom:Matrix 一个 matrix 对象(属于 flash.geom.Matrix 类),可用于对着色器定义转换。例如,可以使用以下矩阵将着色器旋转 45 度(pi/4 弧度): matrix = new flash.geom.Matrix(); matrix.rotate(Math.PI / 4);

着色器中收到的坐标基于为 matrix 参数指定的矩阵。对于默认 (null) 矩阵,着色器中的坐标是可用于对输入采样的局部像素坐标。

flash.geom.Matrix
shader 要用于填充的着色器。flash.display:Shader 要用于填充的着色器。此 Shader 实例无需指定图像输入。但是,如果在着色器中指定了图像输入,则必须手动提供输入,方法是设置 Shader.data 属性的对应 ShaderInput 属性的 input 属性。

传递 Shader 实例作为参数时,将在内部复制着色器,并且绘制填充操作将使用该内部副本(而不是对原始着色器的引用)。对着色器进行的任何更改(比如更改参数值、输入或字节代码)不会应用于所复制的用于填充的着色器。

flash.display.Shader
Shape 此类用于使用 ActionScript 绘图应用程序编程接口 (API) 创建简单形状。用于形状的显示对象。 flash.display:DisplayObject 此类用于使用 ActionScript 绘图应用程序编程接口 (API) 创建简单形状。Shape 类包括 graphics 属性,该属性使您可以从 Graphics 类访问方法。

Sprite 类也包括 graphics 属性,并且它包括不可用于 Shape 类的其他功能。例如,Sprite 对象是显示对象容器,而 Shape 对象不是(并且不能包含子显示对象)。由于此原因,Shape 对象会比包含相同图形的 Sprite 对象消耗的内存少。但是,Sprite 对象支持用户输入事件,而 Shape 对象却不支持。

下例使用 ShapeExample 类绘制圆形、圆角矩形和正方形。执行下列步骤可完成该任务:
  1. 声明 size 属性以备日后在确定每个形状的大小时使用。
  2. 声明以下属性:将背景色设置为橙色、将边框颜色设置为深灰色、将边框大小设置为 0 个像素、将角半径设置为 9 个像素并将舞台边缘与其他对象之间的间距设置为 5 个像素。
  3. 使用在前一步骤中声明的属性以及 Graphics 类的内置方法在坐标(x = 0,y = 0)处绘制圆形、圆角矩形和正方形。
  4. 通过使用 refreshLayout() 方法,沿舞台顶部重新绘制每个形状,起点为 x = 5,y = 5,各形状之间的间隔为 5 个像素。
package { import flash.display.DisplayObject; import flash.display.Graphics; import flash.display.JointStyle; import flash.display.LineScaleMode; import flash.display.Shape; import flash.display.Sprite; public class ShapeExample extends Sprite { private var size:uint = 80; private var bgColor:uint = 0xFFCC00; private var borderColor:uint = 0x666666; private var borderSize:uint = 0; private var cornerRadius:uint = 9; private var gutter:uint = 5; public function ShapeExample() { doDrawCircle(); doDrawRoundRect(); doDrawRect(); refreshLayout(); } private function refreshLayout():void { var ln:uint = numChildren; var child:DisplayObject; var lastChild:DisplayObject = getChildAt(0); lastChild.x = gutter; lastChild.y = gutter; for (var i:uint = 1; i < ln; i++) { child = getChildAt(i); child.x = gutter + lastChild.x + lastChild.width; child.y = gutter; lastChild = child; } } private function doDrawCircle():void { var child:Shape = new Shape(); var halfSize:uint = Math.round(size/2); child.graphics.beginFill(bgColor); child.graphics.lineStyle(borderSize, borderColor); child.graphics.drawCircle(halfSize, halfSize, halfSize); child.graphics.endFill(); addChild(child); } private function doDrawRoundRect():void { var child:Shape = new Shape(); child.graphics.beginFill(bgColor); child.graphics.lineStyle(borderSize, borderColor); child.graphics.drawRoundRect(0, 0, size, size, cornerRadius); child.graphics.endFill(); addChild(child); } private function doDrawRect():void { var child:Shape = new Shape(); child.graphics.beginFill(bgColor); child.graphics.lineStyle(borderSize, borderColor); child.graphics.drawRect(0, 0, size, size); child.graphics.endFill(); addChild(child); } } }
flash.display.Graphicsflash.display.SpriteShape 创建新的 Shape 对象。 创建新的 Shape 对象。 graphics 指定属于该 Shape 对象的 Graphics 对象,可通过此对象执行矢量绘图命令。flash.display:Graphics为 Shape 对象指定 Graphics 对象。 指定属于该 Shape 对象的 Graphics 对象,可通过此对象执行矢量绘图命令。
ShaderParameterType 该类定义一些常量,它们表示 ShaderParameter 类的 type 属性的可能值。Object 该类定义一些常量,它们表示 ShaderParameter 类的 type 属性的可能值。每个常量都表示 Flash Player 内可用于 Pixel Bender 着色器语言中的参数的一种数据类型。 flash.display.ShaderParameter.typeBOOL2 表示将着色器参数定义为 bool2 值,等同于 ActionScript 中由 2 个 Boolean 实例组成的数组。bool2String 表示将着色器参数定义为 bool2 值,等同于 ActionScript 中由 2 个 Boolean 实例组成的数组。 BOOL3 表示将着色器参数定义为 bool3 值,等同于 ActionScript 中由 3 个 Boolean 实例组成的数组。bool3String 表示将着色器参数定义为 bool3 值,等同于 ActionScript 中由 3 个 Boolean 实例组成的数组。 BOOL4 表示将着色器参数定义为 bool4 值,等同于 ActionScript 中由 4 个 Boolean 实例组成的数组。bool4String 表示将着色器参数定义为 bool4 值,等同于 ActionScript 中由 4 个 Boolean 实例组成的数组。 BOOL 表示将着色器参数定义为 bool 值,等同于 ActionScript 中的单一 Boolean 实例。boolString 表示将着色器参数定义为 bool 值,等同于 ActionScript 中的单一 Boolean 实例。

请注意,即使参数只要求单一值,ShaderParameter.value 属性也是数组,因此该单一值必须是分配给 value 属性的数组的唯一元素,如下所示:

// assumes the shader has a parameter named "param" // whose data type is bool myShader.data.param.value = [true];
FLOAT2 表示将着色器参数定义为 float2 值,等同于 ActionScript 中由 2 个 Number 实例组成的数组。float2String 表示将着色器参数定义为 float2 值,等同于 ActionScript 中由 2 个 Number 实例组成的数组。 flash.display.ShaderParameter.typeFLOAT3 表示将着色器参数定义为 float3 值,等同于 ActionScript 中由 3 个 Number 实例组成的数组。float3String 表示将着色器参数定义为 float3 值,等同于 ActionScript 中由 3 个 Number 实例组成的数组。 FLOAT4 表示将着色器参数定义为 float4 值,等同于 ActionScript 中由 4 个 Number 实例组成的数组。float4String 表示将着色器参数定义为 float4 值,等同于 ActionScript 中由 4 个 Number 实例组成的数组。 FLOAT 表示将着色器参数定义为 float 值,等同于 ActionScript 中的单一 Number 实例。floatString 表示将着色器参数定义为 float 值,等同于 ActionScript 中的单一 Number 实例。

请注意,即使参数只要求单一值,ShaderParameter.value 属性也是数组,因此该单一值必须是分配给 value 属性的数组的唯一元素,如下所示:

// assumes the shader has a parameter named "param" // whose data type is float myShader.data.param.value = [22.5];
flash.display.ShaderParameter.type
INT2 表示将着色器参数定义为 int2 值,等同于 ActionScript 中由 2 个 int 或 uint 实例组成的数组。int2String 表示将着色器参数定义为 int2 值,等同于 ActionScript 中由 2 个 int 或 uint 实例组成的数组。 INT3 表示将着色器参数定义为 int3 值,等同于 ActionScript 中由 3 个 int 或 uint 实例组成的数组。int3String 表示将着色器参数定义为 int3 值,等同于 ActionScript 中由 3 个 int 或 uint 实例组成的数组。 INT4 表示将着色器参数定义为 int4 值,等同于 ActionScript 中由 4 个 int 或 uint 实例组成的数组。int4String 表示将着色器参数定义为 int4 值,等同于 ActionScript 中由 4 个 int 或 uint 实例组成的数组。 INT 表示将着色器参数定义为 int 值,等同于 ActionScript 中的单一 int 或 uint 实例。intString 表示将着色器参数定义为 int 值,等同于 ActionScript 中的单一 int 或 uint 实例。

请注意,即使参数只要求单一值,ShaderParameter.value 属性也是数组,因此该单一值必须是分配给 value 属性的数组的唯一元素,如下所示:

// assumes the shader has a parameter named "param" // whose data type is int myShader.data.param.value = [275];
MATRIX2X2 表示将着色器参数定义为 float2x2 值,等同于一个 2x2 的矩阵。matrix2x2String 表示将着色器参数定义为 float2x2 值,等同于一个 2x2 的矩阵。此矩阵表示为 ActionScript 中由 4 个 Number 实例组成的数组。 MATRIX3X3 表示将着色器参数定义为 float3x3 值,等同于一个 3x3 的矩阵。matrix3x3String 表示将着色器参数定义为 float3x3 值,等同于一个 3x3 的矩阵。此矩阵表示为 ActionScript 中由 9 个 Number 实例组成的数组。 MATRIX4X4 表示将着色器参数定义为 float4x4 值,等同于一个 4x4 的矩阵。matrix4x4String 表示将着色器参数定义为 float4x4 值,等同于一个 4x4 的矩阵。此矩阵表示为 ActionScript 中由 16 个 Number 实例组成的数组。
GraphicsPathWinding GraphicsPathWinding 类为 flash.display.GraphicsPath.winding 属性和 flash.display.Graphics.drawPath() 方法提供值,以确定绘制路径的方向。Object GraphicsPathWinding 类为 flash.display.GraphicsPath.winding 属性和 flash.display.Graphics.drawPath() 方法提供值,以确定绘制路径的方向。顺时针路径为正向缠绕,逆时针路径为反向缠绕:

当路径相交或重叠时,缠绕方向将确定由相交或重叠创建的区域的填充规则:

flash.display.GraphicsPath.windingflash.display.Graphics.drawPath()EVEN_ODD 建立奇偶缠绕类型。evenOddString 建立奇偶缠绕类型。奇偶缠绕类型是由所有原始的绘图 API 使用的规则,并且是 flash.display.Graphics.drawPath() 方法的默认类型。任何重叠的路径将在开放填充与闭合填充之间交替。如果使用相同的填充绘制的两个正方形相交,则将不会填充相交的区域。相邻的区域是不相同的(二者没有同时填充或同时不填充)。 NON_ZERO 建立非零缠绕类型。nonZeroString 建立非零缠绕类型。非零缠绕类型确定:当反向缠绕的路径相交时,将不填充相交区域(与奇偶缠绕类型一样)。对于相同缠绕的路径,将填充相交区域。
ActionScriptVersion ActionScriptVersion 类是表示已加载 SWF 文件的语言版本的常量值枚举。Object ActionScriptVersion 类是表示已加载 SWF 文件的语言版本的常量值枚举。语言版本常量用于检查 flash.display.LoaderInfo 对象的 actionScriptVersion 属性。 flash.display.LoaderInfo.actionScriptVersionACTIONSCRIPT2 ActionScript 语言版本 2.0 和更早版本。2uint ActionScript 语言版本 2.0 和更早版本。 ACTIONSCRIPT3 ActionScript 语言版本 3.0。3uint ActionScript 语言版本 3.0。 GraphicsPath 一组绘图命令及这些命令的坐标参数。flash.display:IGraphicsPathflash.display:IGraphicsDataObject 一组绘图命令及这些命令的坐标参数。

将 GraphicsPath 对象与 Graphics.drawGraphicsData() 方法一起使用。绘制 GraphicsPath 对象与调用 Graphics.drawPath() 方法是等效的。

GraphicsPath 还具有一组自己的方法(curveTo()lineTo()moveTo()wideLineTo()wideMoveTo()),这些方法与 Graphics 类中用于调整 GraphicsPath.commandsGraphicsPath.data 矢量数组的方法类似。

flash.display.Graphics.drawGraphicsData()flash.display.Graphics.drawPath()GraphicsPath 创建新的 GraphicsPath 对象。commandsnull一个由整数构成的矢量,表示由 GraphicsPathCommand 类定义的命令。 datanull由数字构成的矢量,其中的每一对数字将被视为一个点(一个 x, y 对)。 windingStringevenOdd使用 GraphicsPathWinding 类中定义的值指定缠绕规则。 创建新的 GraphicsPath 对象。 flash.display.GraphicsPathCommandflash.display.GraphicsPathWindingcurveTo 将新的“curveTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。controlXNumber一个数字,指定控制点相对于父显示对象注册点的水平位置。 controlYNumber一个数字,指定控制点相对于父显示对象注册点的垂直位置。 anchorXNumber一个数字,指定下一个锚点相对于父显示对象注册点的水平位置。 anchorYNumber一个数字,指定下一个锚点相对于父显示对象注册点的垂直位置。 将新的“curveTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。 flash.display.GraphicsPathCommand.CURVE_TOflash.display.Graphics.curveTo()lineTo 将新的“lineTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。xNumber直线目标点的 x 坐标。 yNumber直线目标点的 y 坐标。 将新的“lineTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。 flash.display.GraphicsPathCommand.LINE_TOflash.display.Graphics.lineTo()moveTo 将新的“moveTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。xNumber目标点的 x 坐标。 yNumber目标点的 y 坐标。 将新的“moveTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。 flash.display.GraphicsPathCommand.MOVE_TOflash.display.Graphics.moveTo()wideLineTo 将新的“wideLineTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。xNumber直线目标点的 x 坐标。 yNumber直线目标点的 y 坐标。 将新的“wideLineTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。 flash.display.GraphicsPathCommand.WIDE_LINE_TOwideMoveTo 将新的“wideMoveTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。xNumber目标点的 x 坐标。 yNumber目标点的 y 坐标。 将新的“wideMoveTo”命令添加到 commands 矢量,并将新坐标添加到 data 矢量。 flash.display.GraphicsPathCommand.WIDE_MOVE_TOcommands 由绘图命令构成的矢量,其中的整数表示路径。 由绘图命令构成的矢量,其中的整数表示路径。每个命令都可以是 GraphicsPathCommand 类定义的值之一。 flash.display.GraphicsPathCommanddata 由数字构成的矢量,其中包含与绘图命令一起使用的参数。 由数字构成的矢量,其中包含与绘图命令一起使用的参数。 winding 使用 GraphicsPathWinding 类中定义的值指定缠绕规则。String 使用 GraphicsPathWinding 类中定义的值指定缠绕规则。 flash.display.GraphicsPathWinding
MorphShape MorphShape 类表示显示列表上的 MorphShape 对象。flash.display:DisplayObject MorphShape 类表示显示列表上的 MorphShape 对象。无法在 ActionScript 中直接创建 MorphShape 对象;在 Flash 创作工具中创建补间形状时会创建这些对象。 PixelSnapping PixelSnapping 类是可使用 Bitmap 对象的 pixelSnapping 属性来设置像素贴紧选项的常量值枚举。Object PixelSnapping 类是可使用 Bitmap 对象的 pixelSnapping 属性来设置像素贴紧选项的常量值枚举。 flash.display.Bitmap.pixelSnappingALWAYS 一个在 Bitmap 对象的 pixelSnapping 属性中使用的常量值,用于指定位图图像始终与最近的像素贴紧,与任何变形无关。alwaysString 一个在 Bitmap 对象的 pixelSnapping 属性中使用的常量值,用于指定位图图像始终与最近的像素贴紧,与任何变形无关。 AUTO 一个在 Bitmap 对象的 pixelSnapping 属性中使用的常量值,用于指定如果位图图像是未经旋转或倾斜而绘制的,并且是以 99.9% 至 100.1% 的缩放系数绘制的,则该位图图像将与最近的像素贴紧。autoString 一个在 Bitmap 对象的 pixelSnapping 属性中使用的常量值,用于指定如果位图图像是未经旋转或倾斜而绘制的,并且是以 99.9% 至 100.1% 的缩放系数绘制的,则该位图图像将与最近的像素贴紧。如果满足这些条件,则图像以 100% 缩放比例绘制,并与最近的像素贴紧。在内部,此设置允许使用矢量渲染器以尽可能快的速度绘制图像。 NEVER 一个在 Bitmap 对象的 pixelSnapping 属性中使用的常量值,用于指定不发生任何像素贴紧。neverString 一个在 Bitmap 对象的 pixelSnapping 属性中使用的常量值,用于指定不发生任何像素贴紧。 GraphicsPathCommand 定义这些值以用于指定路径绘制命令。Object 定义这些值以用于指定路径绘制命令。

此类中的这些值由 Graphics.drawPath() 方法使用,或存储在 GraphicsPath 对象的 commands 矢量中。

flash.display.Graphics.drawPath()flash.display.GraphicsPath.commandsCURVE_TO 指定一个绘图命令,该命令使用控制点绘制一条从当前绘图位置开始,到数据矢量中指定的 x 和 y 坐标结束的曲线。3int 指定一个绘图命令,该命令使用控制点绘制一条从当前绘图位置开始,到数据矢量中指定的 x 和 y 坐标结束的曲线。此命令将产生与 Graphics.lineTo() 方法相同的效果,并使用数据矢量控制和锚记中的两个点:(cx, cy, ax, ay)。 flash.display.Graphics.curveTo()LINE_TO 指定一个绘图命令,该命令绘制一条从当前绘图位置开始,到数据矢量中指定的 x 和 y 坐标结束的直线。2int 指定一个绘图命令,该命令绘制一条从当前绘图位置开始,到数据矢量中指定的 x 和 y 坐标结束的直线。此命令将产生与 Graphics.lineTo() 方法相同的效果,并使用数据矢量中的一个点:(x,y)。 flash.display.Graphics.lineTo()MOVE_TO 指定一个绘图命令,该命令会将当前绘图位置移动到数据矢量中指定的 x 和 y 坐标。1int 指定一个绘图命令,该命令会将当前绘图位置移动到数据矢量中指定的 x 和 y 坐标。此命令将产生与 Graphics.moveTo() 方法相同的效果,并使用数据矢量中的一个点:(x,y)。 flash.display.Graphics.moveTo()NO_OP 表示默认的“不执行任何操作”命令。0int 表示默认的“不执行任何操作”命令。 WIDE_LINE_TO 指定一个“直线至”绘图命令,但使用两组坐标(四个值),而不是一组坐标。5int 指定一个“直线至”绘图命令,但使用两组坐标(四个值),而不是一组坐标。使用此命令可在“直线至”和“曲线至”命令之间切换,而无需更改每个命令使用的数据值的个数。此命令使用数据矢量中的两组坐标:一个虚拟位置和一个 (x,y) 位置。

WIDE_LINE_TOWIDE_MOVE_TO 命令变体与 CURVE_TO 命令假定使用相同数目的参数。

LINE_TOflash.display.Graphics.lineTo()
WIDE_MOVE_TO 指定一个“移至”绘图命令,但使用两组坐标(四个值),而不是一组坐标。4int 指定一个“移至”绘图命令,但使用两组坐标(四个值),而不是一组坐标。使用此命令可在“移至”和“曲线至”命令之间切换,而无需更改每个命令使用的数据值的个数。此命令使用数据矢量中的两组坐标:一个虚拟位置和一个 (x,y) 位置。

WIDE_LINE_TOWIDE_MOVE_TO 命令变体与 CURVE_TO 命令假定使用相同数目的参数。

MOVE_TOflash.display.Graphics.moveTo()