var circle:Sprite = new Sprite();
circle.graphics.beginFill(0x4080A0);
circle.graphics.drawCircle(50, 50, 25);
addChild(circle);

circle.addEventListener(MouseEvent.CLICK, clickCircle1);
circle.addEventListener(MouseEvent.CLICK, clickCircle2);
stage.addEventListener(MouseEvent.CLICK, clickStage);

function clickCircle1(evt:MouseEvent):void {
    evt.stopPropagation();
    // evt.stopImmediatePropagation();
    trace("clickCircle1");
}
function clickCircle2(evt:MouseEvent):void {
    trace("clickCircle2");
}
function clickStage(evt:MouseEvent):void {
    trace("clickStage");
}

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0x4080A0);
circle.graphics.drawCircle(50, 50, 25);
addChild(circle);

// using stage for a global mouse up
stage.addEventListener(MouseEvent.MOUSE_UP, mouseUp);
stage.addEventListener(MouseEvent.MOUSE_UP, mouseUp, true);
function mouseUp(evt:MouseEvent):void {
    // only care about capturing and at target phases
    if (evt.eventPhase == EventPhase.BUBBLING_PHASE) return;
    
    trace("global mouseUp");
}

// circle stops propagation in its mouse up
circle.addEventListener(MouseEvent.MOUSE_UP, mouseUpCircle);
function mouseUpCircle(evt:MouseEvent):void {
    trace("mouseUpCircle");
    evt.stopPropagation();
}

// variable to determine which instance was clicked
var clicked:DisplayObject;

var circle:Sprite = new Sprite();
circle.graphics.beginFill(0x4080A0);
circle.graphics.drawCircle(50, 50, 25);
addChild(circle);

function mouseDown(evt:MouseEvent):void {
    trace("mouseDown");
    clicked = circle;
}
function mouseUp(evt:MouseEvent):void {
    trace("mouseUp");
}
function mouseUpOutside(evt:MouseEvent):void {
    trace("mouseUpOutside");
}

// listeners for circle when pressed and stage for global release
circle.addEventListener(MouseEvent.MOUSE_DOWN, mouseDown);
stage.addEventListener(MouseEvent.MOUSE_UP, captureMouseUp);
stage.addEventListener(MouseEvent.MOUSE_UP, captureMouseUp, true);

function captureMouseUp(evt:MouseEvent):void {
    if (evt.eventPhase == EventPhase.BUBBLING_PHASE) return;
    
    // make sure the circle was clicked
    if (clicked == circle) {
        clicked = null; // remove reference for subsequent clicks
        
        var target:Sprite = evt.target as Sprite;
        // if circle is target, mouse released over circle
        if (target == circle) {
            mouseUp(evt);
        }else{
            // mouse released outside circle
            mouseUpOutside(evt);
        }
    }
}

package {

    import flash.events.Event;
    import flash.display.MovieClip;
    
    public class CustomDocument extends MovieClip {
        
        public function CustomDocument() {
            addEventListener(Event.ADDED, checkChildren);
            checkChildren(new Event("initialize"));
        }
        
        private function checkChildren(evt:Event):void {
            
            // only allow one child in root
            if (numChildren > 1) {
                throw (new Error("This movie can have only one child instance"));
            }
        }
    }
}

var targetClass:Class = target["constructor"];

package {
    
    import flash.display.Stage;

    public class CustomObject {
    
        private var stage:Stage;
    
        public function CustomObject(stageRef:Stage) {
        
            // stage access through
            // constructor argument
            stage = stageRef;
        }
    }
}

package {
    
    import flash.display.Sprite;
    import flash.events.Event;

    public class CustomDisplayObject extends Sprite {
    
        public function CustomObject() {
        
            // stage not acessible until
            // added to stage or display
            // list on the stage
            trace(stage); // null
        }
    }
}

package {
    
    import flash.display.DisplayObject;
    import flash.display.MovieClip;
    import flash.display.Stage;
    
    public class TopLevel extends MovieClip {
        
        public static var stage:Stage;
        public static var root:DisplayObject;
            
        public function TopLevel() {
            TopLevel.stage = this.stage;
            TopLevel.root = this;
        }
    }
}

package {
        
    public class MyDocumentClass extends TopLevel {
            
        public function MyDocumentClass() {
            // code
        }
    }
}

package {
        
    public class RandomClass {
            
        public function RandomClass() {
            trace(TopLevel.stage); // [object Stage]
        }
    }
}

package {
   
    public namespace company = "http://www.example.com/company";
    public namespace individual = "http://www.example.com/individual";
        
    public class UsingNameSpaces {
       
        use namespace individual;
        
        company var value:int = 10;
        individual var value:int = 2;
       
        public function UsingNameSpaces(){
            showValue(); // traces individual::2
            company::showValue(); // traces company::2;
        }
       
        company function showValue() {
            trace("company::" + value);
        }
       
        individual function showValue() {
            trace("individual::" + value);
        }
    }
}

// creates a red square
var square:Shape = new Shape();
square.graphics.beginFill(0x000000);
square.graphics.drawRect(0, 0, 100, 100);

var colorTransform:ColorTransform = square.transform.colorTransform;
colorTransform.color = 0xFF0000;
square.transform.colorTransform = colorTransform;

addChild(square);

var value:* = new Array();
trace(value.getChildAt(0));

try {
     // statements
} catch (error:Error) {
     // statements
} finally {
     // statements
}

try {
    var value:* = new Array();
    trace(value.getChildAt(0));
    
} catch(error:IOErrorEvent) {
    trace("IOErrorEvent catch: " + error);
    
} catch(error:TypeError) {
    trace("TypeError catch: " + error);
    
} catch(error:Error) {
    trace("Error catch: " + error);
    
} finally {
    trace("Finally!");
}

trace("Continuing with script...");

try {
    var value:* = new Array();
    trace(value.getChildAt(0));
    
} catch(error:IOErrorEvent) {
    trace("IOErrorEvent catch: " + error);
    
} finally {
    trace("Finally!");
}

trace("Continuing with script...");

var loader:URLLoader = new URLLoader();
loader.load(new URLRequest("Invalid XML URL"));
trace("Continuing with script...");

var loader:URLLoader = new URLLoader();

loader.addEventListener(IOErrorEvent.IO_ERROR, catchIOError);
function catchIOError(event:IOErrorEvent){
    trace("Error caught: "+event.type);
}

loader.load(new URLRequest("Invalid XML URL"));
trace("Continuing with script...");

var myXML:XML = 
    <foo>
        <bar />
        <bar />
        <bar />
    </foo>;
    
trace(myXML.bar.toXMLString());

trace(myXML.elements("bar").toXMLString());

var myXML:XML = 
    <note>
        <replying-to>
            <note>
                <author>Julie</author>
                <title>Reminder</title>
                <body>Take out the trash</body>
            </note>
        </replying-to>
        <author>Kevin</author>
        <title>Re: Reminder</title>
        <body>I will.</body>
    </note>;
    
trace("Children:");
trace(myXML.author.toXMLString());
trace("Decendants:");
trace(myXML..author.toXMLString());

trace(myXML.descendants("author").toXMLString());

var sprite:Sprite = new Sprite();
var object:Object = new Object();
var boolean:Boolean = true;
var number:Number = 10;

var array:Array = new Array(sprite, object, number);
trace(array.indexOf(sprite)); // 0
trace(array.indexOf(number)); // 2
trace(array.indexOf(boolean)); // -1 
 

var linkText:TextField = new TextField();
linkText.htmlText = 'Link: <a href="event:Link Clicked">Click</a>';
addChild(linkText);

linkText.addEventListener(TextEvent.LINK, linkEvent);

function linkEvent(event:TextEvent):void {
    trace(event.text); // Link Clicked
}

for (var prop:String in proxy) {
    trace(prop);
}

package {
    
    import flash.utils.Proxy;
    import flash.utils.flash_proxy;
    
    public class ProxyEnum extends Proxy {
        
        private var props:Array = ["x", "y", "visible"]; // properties array
        
        // nextNameIndex called when the loop starts
        override flash_proxy function nextNameIndex (index:int):int {
            if (index < props.length) {
                // first call is 0, return 1 + index the index
                // starts with 1, then 2, then 3... etc.
                return index + 1;
            } else {
                // after outside of props bounds,
                // stop the loop returning 0
                return 0;
            }
        }
        
        // nextName called after nextNameIndex returns non-zero
        override flash_proxy function nextName(index:int):String {
            // return the array item in index - 1
            // this relates to a property name in a for..in
            return props[index - 1];
        }
    }
}

var proxy:ProxyEnum = new ProxyEnum();
for (var prop in proxy) {
    trace(prop);
}
/* output:
x
y
visible
*/

package {
    
    import flash.display.DisplayObject;
    import flash.utils.Proxy;
    import flash.utils.flash_proxy;
    
    public class ProxyEnum extends Proxy {
        
        private var props:Array = ["x", "y", "visible"]; // properties array
        private var