jasu's blog

myDisplayObject.addEventListener(MouseEvent.CLICK, clickHandler);

package flash.events
{
        public class Event
        {
                // 클래스 정수
                public static const ACTIVATE:String = "activate";
                public static const ADDED:String    = "added";
                // 그 외의 정수는 생략
        }
}

myDisplayObject.addEventListener(MouseEvent.CLICK, clickHandler);

myDisplayObject.addEventListener("click", clickHandler);

package flash.events
{
        public final class EventPhase
        {
                public static const CAPTURING_PHASE:uint = 1;
                public static const AT_TARGET:uint       = 2;
                public static const BUBBLING_PHASE:uint  = 3;
        }
}

if (e.eventPhase == EventPhase.AT_TARGET) {
        myFunc();
}

parent_mc.child_mc.addEventListener(MouseEvent.CLICK, childClickHandler);
parent_mc.addEventListener(MouseEvent.CLICK, parentClickHandler);

parent_mc.child_mc.buttonMode = parent_mc.buttonMode = true;

function childClickHandler(evt:Event):void{
        trace(evt.target.name +" is a child");
}
function parentClickHandler(evt:Event):void{
        trace(evt.target.name +" is a parent");
}

parent_mc.child_mc.addEventListener(MouseEvent.CLICK, childClickHandler);
parent_mc.addEventListener(MouseEvent.CLICK, parentClickHandler);

parent_mc.child_mc.buttonMode = parent_mc.buttonMode = true;

function childClickHandler(evt:Event):void{
        trace(evt.currentTarget.name +" is a child");
}
function parentClickHandler(evt:Event):void{
        trace(evt.currentTarget.name +" is a parent");
}

trace(myXML.item[0].menuName);      // 출력 : burger
trace(myXML.item.(@id==2).menuName);  // 출력 : fries
trace(myXML.item.(menuName=="burger").price);  // 출력 : 3.95

myXML.appendChild(newItem);

myXML.item[0].menuName="regular burger";
myXML.item[1].menuName="small fries";
myXML.item[2].menuName="medium cola";

myXML.item.(menuName=="regular burger").@quantity = "2";
myXML.item.(menuName=="small fries").@quantity = "2";
myXML.item.(menuName=="medium cola").@quantity = "2";

var total:Number = 0;
for each (var property:XML in myXML.item) {
      var q:int = Number(property.@quantity);
      var p:Number = Number(property.price);
      var itemTotal:Number = q * p;
      total += itemTotal;
      trace(q + " " + property.menuName + " $" + itemTotal.toFixed(2))
}
trace ("Total: $", total.toFixed(2));

var request:URLRequest = new URLRequest("url.xml");
var loader:URLLoader = new URLLoader();
loader.load(request);

loader.addEventListener(Event.COMPLETE, xmlLoaded);

function xmlLoaded(event:Event):void {
        var myXML:XML = new XML(loader.data);
        trace(myXML.item[0].title);
        trace(myXML.item.(@id==2).title);
        trace(myXML.item.(title == "item 1").title);
}

import flash.utils.ByteArray;

function clone(source:Object):*{
        var myBA:ByteArray = new ByteArray();
        myBA.writeObject(source);
        myBA.position = 0;
        return(myBA.readObject());
}

package {
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.TimerEvent;
        import flash.utils.Timer;

        public class ShortTimer extends Sprite {
                public function ShortTimer() {
                        // 5 초의 Timer를 신규 작성한다
                        var minuteTimer:Timer = new Timer(1000, 5);

                        // 시간 간격 이벤트 및 완료 이벤트용의 청취자를 지정한다
                        minuteTimer.addEventListener(TimerEvent.TIMER, onTick);
                        minuteTimer.addEventListener(TimerEvent.TIMER_COMPLETE, onTimerComplete);

                        // 타이머의 카운트를 시작한다.
                        minuteTimer.start();
                }

                public function onTick(evt:TimerEvent):void {
                        // 현재의 카운트를 표시한다
                        // 이 이벤트의 target이며 Timer 인스턴스 자체를 나타낸다
                        trace("tick " + evt.target.currentCount);
                }

                public function onTimerComplete(evt:Event):void {
                        trace("Time's Up!");
                }
        }
}

import flash.display.Sprite;
import flash.net.*;
import flash.media.Video;

public class VideoTest extends Sprite {
        private var videoUrl:String = "http://example.com/test.flv";

        public function VideoTest() {

                var connection:NetConnection = new NetConnection();
                connection.connect(null);

                var stream:NetStream = new NetStream(connection);
                stream.publish(false);

                var myVideo:Video = new Video(360, 240);
                myVideo.attachNetStream(stream);
                stream.play(videoUrl);

                addChild(myVideo);
        }
}

import flash.display.*;
import flash.events.*;
public class TextButton extends SimpleButton {
        public var selected:Boolean = false;
        public function TextButton(txt:String) {
                upState = new TextButtonState(0xFFFFFF, txt);
                downState = new TextButtonState(0xCCCCCC, txt);
                hitTestState = upState;
                overState = upState;
                addEventListener(MouseEvent.CLICK, buttonClicked);
        }
        public function buttonClicked(e:Event) {
                trace("Button clicked.");
        }
}

import flash.display.*;
import flash.text.TextFormat;
import flash.text.TextField;
class TextButtonState extends Sprite {
        public var label:TextField;
        public function TextButtonState(color:uint, labelText:String) {
                label = new TextField();
                label.text = labelText;
                label.x = 2;
                var format:TextFormat = new TextFormat("Verdana");
                label.setTextFormat(format);
                var buttonWidth:Number = label.textWidth + 10;
                var background:Shape = new Shape();
                background.graphics.beginFill(color);
                background.graphics.lineStyle(1, 0x000000);
                background.graphics.drawRoundRect(0, 0, buttonWidth, 18, 4);
                addChild(background);
                addChild(label);
        }
}

var bdWidth:Number = 100;
var bdHeight:Number = 100;
var bdTransparent:Boolean = true;
var bdFillColorARGB:uint = 0xFF007090;
var myBitmapData:BitmapData = new BitmapData(bdWidth,
	bdHeight,
	bdTransparent,
	bdFillColorARGB);
var myBitmap:Bitmap = new Bitmap(myBitmapData);
addChild(myBitmap);

var pictLdr:Loader = new Loader();
var pictURL:String = "banana.jpg"
var pictURLReq:URLRequest = new URLRequest(pictURL);
pictLdr.load(pictURLReq);
this.addChild(pictLdr);

import flash.display.*;
import flash.net.URLRequest;
import flash.events.Event;
var container:Sprite = new Sprite();
addChild(container);
var pictLdr:Loader = new Loader();
var pictURL:String = "banana.jpg"
var pictURLReq:URLRequest = new URLRequest(pictURL);
pictLdr.load(pictURLReq);
pictLdr.contentLoaderInfo.addEventListener(Event.COMPLETE, imgLoaded);
function imgLoaded(e:Event):void {
        container.addChild(pictLdr.content);
}

import flash.display.Loader;
import flash.display.Sprite;
import flash.events.Event;

var ldr:Loader = new Loader();
var urlReq:URLRequest = new URLRequest("eventDispatcher.swf");
ldr.load(urlReq);
ldr.contentLoaderInfo.addEventListener(Event.COMPLETE, loaded);
addChild(ldr);

function loaded(event:Event):void {
        trace("loaded");
}

var loaderContext:LoaderContext = new LoaderContext();
loaderContext.checkPolicyFile = true;
var urlReq:URLRequest = new URLRequest("photo11.jpg");
var ldr:Loader = new Loader();
ldr.load(urlReq, loaderContext);

var loaderContext:LoaderContext = new LoaderContext();
loaderContext.securityDomain = SecurityDomain.currentDomain;
loaderContext.applicationDomain = ApplicationDomain.currentDomain;
var urlReq:URLRequest = new URLRequest("library.swf");
var ldr:Loader = new Loader();
ldr.load(urlReq, loaderContext);

var tf:TextField = new TextField();
tf.text = "Hello Hello";

var format1:TextFormat = new TextFormat();
format1.color = 0xFF0000;

var format2:TextFormat = new TextFormat();
format2.font = "Courier";

tf.setTextFormat(format1);
var startRange:uint = 6;
tf.setTextFormat(format2, startRange);

addChild(tf);

var style:StyleSheet = new StyleSheet();

var styleObj:Object = new Object();
styleObj.fontSize = "bold";
styleObj.color = "#FF0000";
style.setStyle(".darkRed", styleObj);

var tf:TextField = new TextField();
tf.text ="Hello Hello";
tf.styleSheet = style;
tf.htmlText = "<span class = 'darkRed'>Red</span> apple";

addChild(tf);

import flash.display.*;
var circle:Shape = new Shape()
var xPos:Number = 100;
var yPos:Number = 100;
var radius:Number = 50;
circle.graphics.beginFill(0xFF8800);
circle.graphics.drawCircle(xPos, yPos, radius);
this.addChild(circle);

var mySprite:Sprite = new Sprite();
mySprite.graphics.beginFill(0xFFCC00);
mySprite.graphics.drawCircle(30, 30, 30);
var label:TextField = new TextField();
label.text = "hello";
label.x = 20;
label.y = 20;
mySprite.addChild(label);
this.addChild(mySprite);

package {
        import flash.display.MovieClip;
        public class StaticExample extends MovieClip {
                public function StaticExample() {
                        var myExt:Extender = new Extender();
                }
        }
}

class Base {
        public static var test:String = "static";
}

class Extender extends Base {
        public function Extender () {
                trace(test); //
        }
}

출력 : static

package {
        import flash.display.MovieClip;
        public class StaticExample extends MovieClip {
                public function StaticExample() {
                        var myExt:Extender = new Extender();
                }
        }
}

class Base {
        public static var test:String = "static";
}

class Extender extends Base {
        public var test:String = "instance";
        public function Extender () {
                trace(test); //
        }
}

출력 : instance

parent_mc.child_mc.addEventListener(MouseEvent.CLICK, childClickHandler);
parent_mc.addEventListener(MouseEvent.CLICK, parentClickHandler);

function childClickHandler(evt:Event):void{
        trace(evt.target.name +" is a child");
}
function parentClickHandler(evt:Event):void{
        trace(evt.target.name +" is a parent");
}
출력 :
child_mc is a child
child_mc is a parent

trace(evt.target.parent.name +" is a parent");

class ThisTest {
        private var num:Number = 3;
        function foo () {                 // 정의된 Bound methods
                trace ("foo's this: " + this);
                trace ("num: " + num);
        }
        function bar () {
                return foo;              // 돌려주는 Bound methods
        }
}

var myTest:ThisTest = new ThisTest();
var myFunc:Function = myTest.bar();
trace(this);
myFunc();

I've been playing around with ActionScript 3.0 for a while now, and I'm really excited by its capabilities. The raw execution speed by itself provides so many possibilities. Toss in E4X, sockets, byte arrays, the new display list model, RegEx methods, a formalized event and error model, and a few dozen other features for flavor, and you have a pretty heady brew.

With great power comes great responsibility, and this is very true for ActionScript 3.0. A side effect of all this new control is that the garbage collector is no longer able to make as many assumptions about what it should automatically tidy up for you. This means that Flash developers moving to ActionScript 3.0 will need to develop a very strong understanding of how the garbage collector operates, and how to work with it effectively. Building even seemingly simple games or applications without this knowledge could result in SWFs that leak like a sieve, hogging all of a system's resources (CPU/RAM) and causing the user's system to hang—potentially even forcing them to hard reboot their computer.

To understand how to optimize your code for ActionScript 3.0, you'll first need an understanding of how the garbage collector works in Flash Player 9. Flash has two processes for finding objects that are not in active use and removing them. This article looks at both techniques and describes how they are relevant to your code.

At the end of this article you can find a simulation of the garbage collector in Flash Player 9 that visually demonstrates the concepts explained herein.

About the garbage collector

The garbage collector is a behind-the-scenes process that is responsible for deallocating the memory used by objects that are no longer in use by the application. An inactive object is one that no longer has any references to it from other active objects. In order to understand this, it is very important to realize that when working with non-primitive types (anything other than Boolean, String, Number, uint, int), you are always passing around a reference to the object, not the object itself. When you delete a variable you remove the reference, not the object itself.

This is easily demonstrated in the code below:

// create a new object, and put a reference to it in a:
var a:Object = {foo:"bar"}
// copy the reference to the object into b:
var b:Object = a;
// delete the reference to the object in a:
delete(a);
// check to see that the object is still referenced by b:
trace(b.foo); // traces "bar", so the object still exists.

If I were to update the code in the example above and delete "b" as well, it would leave my object with no active references and free it for garbage collection. The ActionScript 3.0 garbage collector uses two methods for locating objects with no active references: reference counting and mark sweeping.

Reference counting

Reference counting is one of the simplest methods for keeping track of active objects, and has been used in Flash since ActionScript 1.0. When you create a reference to an object, its reference count is incremented. When you delete a reference, its reference count is decremented. If the reference count of an object reaches zero, it is marked for deletion by the garbage collector.

Here's an example:

var a:Object = {foo:"bar"}
// the object now has a reference count of 1 (a)
var b:Object = a;
// now it has a reference count of 2 (a & b)
delete(a);
// back to 1 (b)
delete(b);
// the reference count down is now 0
// the object can now be deallocated by the garbage collector

Reference counting is simple, it doesn't carry a huge CPU overhead, and it works well in most situations. Unfortunately, the reference counting method for garbage collection is not optimal when it comes to circular referencing. Circular referencing is the situation when objects cross-reference each other (directly, or indirectly via other objects). Even if the application is no longer actively using the objects, their reference counts remain above zero, so the garbage collector never removes them. The code below illustrates how this works:

var a:Object = {}
// create a second object, and reference the first object:
var b:Object = {foo:a};
// make the first object reference the second as well:
a.foo = b;
// delete both active application references:
delete(a);
delete(b);

In the code shown above, both of the active application references have been deleted. I no longer have any way of accessing the two objects from my application, but the reference counts of both objects are 1 because they reference each other. This situation can become much more complex (a references c, which references b, which references a, etc.) and can be difficult to deal with in code. Flash Player 6 and 7 had issues relating to circular referencing in XML objects: each XML node referenced both its children and its parent, so they were never deallocated. Fortunately, Flash Player 8 added a new garbage collection technique called mark and sweep.

Mark sweeping

The second strategy employed by the ActionScript 3.0 (and Flash Player 8) garbage collector to find inactive objects is a method called mark and sweep. Flash Player starts at the root object of your application (which is conveniently called the "root" in ActionScript 3.0) and walks through every reference in it, marking each object it finds.

Next, Flash Player iterates through each of the marked objects. It continues this behavior recursively until it has traversed the entire object tree of your application, marking everything it can reach through an active reference. At the end of this process, Flash Player can safely assume that any objects in memory that are not marked no longer have any active references to them and can be safely deallocated. Figure 1 illustrates how this works: The green references were followed by Flash Player during marking, the green objects are marked, and the white objects will be deallocated.

Figure 1. Objects that no longer have active references are identified by Flash Player using the mark and sweep method

Mark and sweep is very accurate. However, because Flash Player has to traverse your entire object structure, the process is costly in terms of CPU usage. Flash Player 9 reduces this cost by carrying out iterative mark and sweep—the process occurs over a number of frames, instead of all at once—and by running this process only occasionally.

Deferred garbage collector and indeterminacy

In Flash Player 9, the garbage collector's operations are deferred. This is a very important thing to understand. Your objects will not be removed immediately when all active references are deleted. Rather, they will be removed at some indeterminate time in the future (from a developer standpoint). The garbage collector uses a set of heuristics that look at the RAM allocation and the size of the memory stack, among other things, to determine when to run. As a developer, you must accept the fact that you will have no way of knowing when, or even if, your inactive objects will get deallocated. You must also be aware that inactive objects will continue to execute indefinitely, until the garbage collector deallocates them, so your code will keep running (enterFrame events will continue), sounds will keep playing, loads will keep happening, other events will keep firing, and so on.

It's very important to remember that you have no control over when the garbage collector in Flash Player will deallocate your objects. As a developer, you will want to make the objects in your games and applications as inert as possible when you are finished with them. Strategies to manage this process will be the focus of my companion article, Resource management strategies in Flash Player 9.

Notice the sawtooth pattern of the total memory in the following garbage collection simulation (click Figure 2 or the link below it). The dips are caused when the collector carries out a sweep. Click on the chart to focus it, then press Spacebar to pause or restart, and hold the up/down arrows to change the memory usage trend as it runs.

Figure 2. Garbage collection simulation

• Garbage collection simulation

As shown in the following simulation (click Figure 3 or the link below it), drag out objects (round rectangles) and references to those objects. Then run reference counts or mark and sweep to see which objects would be collected. The number in an object indicates the number of references to that object.

Figure 3. Garbage collection simulation: mark and sweep

• Garbage collection simulation: mark and sweep

Where to go from here

Understanding garbage collection is going to be one of the most important steps for writing optimized code that ensures that your Flash project runs with minimal impact on the user's computer. Read my companion article, Resource management strategies in Flash Player 9, and visit the Flash Developer Center and Flash Player Developer Center.

Also check out my blog at gskinner.com to read more about weak references and download helper classes that I've written.

About the author

1. 06-19-06: Change the frame rate of your movie
2. 06-20-06: Class scope is now bound to class methods
3. 06-21-06: Graphics Object and the Drawing API
4. 06-22-06: New Variable Types
5. 06-23-06: Display Objects
6. 06-24-06: New Import Directive
7. 06-25-06: Type Casting and the as Operator
8. 06-26-06: Unique Class Variables
9. 06-27-06: New MouseMove Behavior
10. 06-28-06: The delete Keyword and Class Members
11. 06-29-06: The Dictionary Class
12. 06-30-06: Label Statements
13. 07-01-06: Detecting When the Mouse Leaves the Movie
14. 07-02-06: SimpleButton Instances
15. 07-03-06: Commas in Shorthand Array Definitions
16. 07-04-06: Package Block
17. 07-05-06: Same-file Helper Classes
18. 07-06-06: Access Attributes
19. 07-07-06: Abstract Classes
20. 07-08-06: The override Keyword
21. 07-09-06: Using prototype
22. 07-10-06: Regular Expression (RegExp) Support
23. 07-11-06: Approach to Depth Sorting
24. 07-12-06: Deep Object Copies with ByteArray
25. 07-13-06: Similarly Named Instance and Static Properties
26. 07-14-06: EventDispatcher
27. 07-15-06: Events and Event Types
28. 07-16-06: Writing Inline XML
29. 07-17-06: Determine Instance Class or Superclass
30. 07-18-06: super() Placement (Now Anywhere)
31. 07-19-06: Determining Current Frame Label
32. 07-20-06: Multiple Arguments in trace()
33. 07-21-06: Calling Event Handlers without Events
34. 07-22-06: URLRequest for URL Strings
35. 07-23-06: XML vs. XMLDocument
36. 07-24-06: Loading Text and XML with URLLoader
37. 07-25-06: is Operator (vs instanceof)
38. 07-26-06: Flash 9: Timelines as Classes
39. 07-27-06: RegExp: Email Validation
40. 07-28-06: Render Event
41. 07-29-06: XML: @ Operator for Attributes
42. 07-30-06: Event Propagation Support
43. 07-31-06: Get Sound Spectrum Information
44. 08-01-06: Number() Conversion No Longer Interprets Octals
45. 08-02-06: Garbage Collection: Reference Counting & Mark and Sweep
46. 08-03-06: Weak References
47. 08-04-06: Flash 9: BitmapData and Bitmaps from the Library
48. 08-05-06: Changes in typeof
49. 08-06-06: getBounds() vs getRect()
50. 08-07-06: for..in and for each..in
51. 08-08-06: Default Values for Function Parameters
52. 08-09-06: Undetermined Number of Arguments With ...(rest)
53. 08-10-06: arguments
54. 08-11-06: Support for Namespaces
55. 08-12-06: Namespaces: Name Qualifier Operator (::)
56. 08-13-06: dynamic is Not Inherited
57. 08-14-06: Creating a mouseWithin Event
58. 08-15-06: Prevent Overriding and Subclassing with final
59. 08-16-06: MXMLC: SWF Metadata Tag
60. 08-17-06: Proxy Class
61. 08-18-06: in Operator
62. 08-19-06: Proxy: getProperty and setProperty
63. 08-20-06: Flash 9: Display Object Variables and Instance Names
64. 08-21-06: XML: XML and XMLList
65. 08-22-06: Constants
66. 08-23-06: duplicateMovieClip Replacement
67. 08-24-06: Proxy: callProperty
68. 08-25-06: Creating graphics Copies
69. 08-26-06: TextField.appendText()
70. 08-27-06: include Directive
71. 08-28-06: Duplicate Variable Definitions
72. 08-29-06: mouseEnabled and Event Blocking
73. 08-30-06: mouseChildren with Event Propagation
74. 08-31-06: rollOver and rollOut vs. mouseOver and mouseOut
75. 09-01-06: DisplayObjectContainer contains()
76. 09-02-06: Cleaning Up Event Listeners
77. 09-03-06: Detecting Addition to or Removal from Stage
78. 09-04-06: Event Phases and Event Capturing
79. 09-05-06: Determining Event Phase
80. 09-06-06: Preventing Event Propagation
81. 09-07-06: Global Events
82. 09-08-06: Detecting a mouseUp Outside
83. 09-09-06: Flash 9: Document Class
84. 09-10-06: Access to stage and root
85. 09-11-06: Namespaces: use namespace Directive
86. 09-12-06: No More Color Class; Use ColorTransform
87. 09-13-06: Runtime Errors; Error Class
88. 09-14-06: Errors: try..catch..finally and Exception Handling
89. 09-15-06: Errors: Asynchronous Exception Handling
90. 09-16-06: XML: Children (.) and Decendants (..)
91. 09-17-06: Array.indexOf (Array.lastIndexOf())
92. 09-18-06: asfunction: Now event:
93. 09-19-06: Proxy: Property Enumeration (nextName(), nextValue(), and nextNameIndex())
94. 09-20-06: Event Capturing and mouseEnabled
95. 09-21-06: Flash 9: Strict Mode
96. 09-22-06: System.totalMemory
97. 09-23-06: Closing Net Connections
98. 09-24-06: Timer Class
99. 09-25-06: AVM2 (AS3) to AVM1 (AS2/AS1) Communication via LocalConnection
100. 09-26-06: ByteArray Class

100 AS3 tips! After tip 100, no longer will they be added daily