var boz = {
      thing: function(val) { alert(val); }
}

ExternalInterface.call("boz.thing", "what the shit!?");

ExternalInterface.call("function (foo) { alert(foo); return true; }","test");

package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.text.TextField;
        import flash.net.*;
        import flash.events.*;
        import flash.display.MovieClip;
	import flash.utils.ByteArray;
 
	// We'll be sending a ByteArray encoded as Base64, and then decoding it on the .NET side.
	// http://dynamicflash.com/goodies/base64/
	import com.dynamicflash.util.Base64;
 
	// be.wellconsidered classes give us an easy means to communicate with webservices.
	// The extension needs to be installed and the component then dropped into your .FLA.
	// You'll see a component called "Service" in the library of the example .FLA.
	// http://www.wellconsidered.be/blog/as3-webservice-component/
	import be.wellconsidered.services.WebService;
	import be.wellconsidered.services.Operation;
	import be.wellconsidered.services.events.OperationEvent;
	import be.wellconsidered.services.events.WebServiceEvent;
 
	// com.pfp includes classes for the Asynchronous JPEG encoder.  There is also a JPEG encoder
	// in Adobe's CoreLib (http://code.google.com/p/as3corelib/), but because this one is asynchronous it allows to 
	// monitor the rendering of the jpeg and therefore create a progress bar.  It is also essential when rendering larger
	// bitmaps, otherwise Flash could time out during the processing.
	import com.pfp.events.*;
	import com.pfp.utils.*;
 
    public class FlashBitmapSave extends MovieClip
    {
	// we create our WebService object.  Remember to include "?wsdl" in the URL.
	private var wsMainService:WebService = new WebService("/Service.asmx?wsdl");
 
                public function FlashBitmapSave()
                {
                        mcDrawingBoard.addEventListener(MouseEvent.MOUSE_DOWN, mcDrawingBoard_MouseDown);
			btnSaveToServer.addEventListener(MouseEvent.CLICK, btnSaveToServer_Click);
 
			// the listener on our webservice will let us know if there's a problem with the webservice,
			// if the url is wrong, if the service is down, etc.
			wsMainService.addEventListener(WebServiceEvent.INITFAILED, wsMainService_InitFailed);
                }
 
		// **** functions for the drawing pad **** //
 
		private function mcDrawingBoard_MouseDown(e:MouseEvent):void
		{
			mcDrawingBoard.addEventListener(MouseEvent.MOUSE_MOVE, mcDrawingBoard_MouseMove);
			stage.addEventListener(MouseEvent.MOUSE_UP, stage_MouseUp);
			mcDrawingBoard.graphics.moveTo(mcDrawingBoard.mouseX, mcDrawingBoard.mouseY);
		}
 
		private function mcDrawingBoard_MouseMove(e:MouseEvent):void
		{
			mcDrawingBoard.graphics.lineStyle(1, 0x000000);
			mcDrawingBoard.graphics.lineTo(mcDrawingBoard.mouseX, mcDrawingBoard.mouseY);
		}
 
		private function stage_MouseUp(e:MouseEvent):void
		{
			mcDrawingBoard.removeEventListener(MouseEvent.MOUSE_MOVE, mcDrawingBoard_MouseMove);
		}
 
		// ************************************** //
 
		private function btnSaveToServer_Click(e:MouseEvent):void
		{
			var bmdSnapshot:BitmapData = new BitmapData(mcDrawingBoard.width, mcDrawingBoard.height);
			// take a snapshot of what was drawn in "mcDrawingBoard"
			bmdSnapshot.draw(mcDrawingBoard);
 
			saveImage(bmdSnapshot);
		}
 
		private function wsMainService_InitFailed(e:WebServiceEvent):void
		{
			log("Webservice failed to initialize.");
		}
 
		private function saveImage(bmdSend:BitmapData):void
		{
			// create a new JPEGAsyncEncoder.  80 is the JPEG quality.
			var jpgEncoder:JPEGAsyncEncoder = new JPEGAsyncEncoder(80);
 
			// encodes 400 pixels before sending out a ProgressEvent.  That means every 400 pixels the CPU has a chance to "breath"
			// and process some other code.  
			jpgEncoder.PixelsPerIteration = 400;
 
			jpgEncoder.addEventListener(JPEGAsyncCompleteEvent.JPEGASYNC_COMPLETE, jpgEncoder_Complete);
			jpgEncoder.addEventListener(ProgressEvent.PROGRESS, jpgEncoder_Progress);
 
			jpgEncoder.encode(bmdSend);			
		}
 
		private function jpgEncoder_Complete(e:JPEGAsyncCompleteEvent):void
		{
			var jpgByteArray:ByteArray = new ByteArray();
			// put the raw image data we got back from the encoder into our ByteArray
			jpgByteArray = e.ImageData;
 
			sendToServer(jpgByteArray);
		}
 
		private function jpgEncoder_Progress(e:ProgressEvent):void
		{
			log("encoding... " + Math.round(e.bytesLoaded / e.bytesTotal * 100).toString());
		}
 
		private function sendToServer(byteArray:ByteArray):void
		{
			var opJPEGSaver:Operation = new Operation(wsMainService);
 
			// unfortunately, I don't think the WebService class we're using has a working ProgressEvent.
			// if I'm wrong, please let me know!
			opJPEGSaver.addEventListener(OperationEvent.COMPLETE, opJPEGSaver_Complete);
			opJPEGSaver.addEventListener(OperationEvent.FAILED, opJPEGSaver_Failed);	
 
			var strEncodedString:String = new String();
			// the Base64 class is static, so we can just call it using Base64.<whatever>
			strEncodedString = Base64.encodeByteArray(byteArray);
 
			// send the encoded bytes to our webservice function we called "SaveJPEG".
			opJPEGSaver.SaveJPEG(strEncodedString);
		}
 
		private function opJPEGSaver_Complete(e:OperationEvent):void
		{
			log("ByteArray successfully sent to server.");
		}
 
		private function opJPEGSaver_Failed(e:OperationEvent):void
		{
			log("Error sending ByteArray to server.");
		}
 
		private function log(strLog:String):void
		{
			// my own way of tracing to the textfield txtTrace -- as you can see.
			// not an important part of anything going on here.
			txtTrace.appendText(strLog + "\n");
			traceScrollBar.scrollTarget = txtTrace;
			txtTrace.scrollV = txtTrace.numLines;
		}
    }
}

Imports System.Web
Imports System.Web.Services
Imports System.Web.Services.Protocols
Imports System.IO
 
' To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.
' <System.Web.Script.Services.ScriptService()> _
<WebService(Namespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class Service
     Inherits System.Web.Services.WebService
 
 
    <WebMethod()> _
    Public Function SaveJPEG(ByVal strJPEG As String) As String
 
        'saves an uploaded photo and returns a unique name reference
 
        Dim BinaryContent As Byte() = Convert.FromBase64String(strJPEG)
 
        Try
            'generate a unique name (GUID) for the filename
            Dim strFileName As String = System.Guid.NewGuid.ToString("n")
            'MAKE SURE to change the save path!
            Dim fStream As New FileStream("C:\" + strFileName + ".jpg", FileMode.CreateNew)
            Dim bw As New BinaryWriter(fStream)
 
            bw.Write(BinaryContent)
            bw.Close()
            fStream.Close()
 
            'return the filename for use in Flash
            Return strFileName
 
        Catch ex As Exception
 
            Return ex.Message
 
        End Try
 
    End Function
 
End Class

private function scaleFromCenter(ob:*, sx:Number, sy:Number, ptScalePoint:Point) { 
	var m:Matrix=ob.transform.matrix;
	m.tx -= ptScalePoint.x;
	m.ty -= ptScalePoint.y;
	m.scale(sx, sy);
	m.tx += ptScalePoint.x;
	m.ty += ptScalePoint.y;
	ob.transform.matrix = m;
}

//this will create a point object at the center of the display object
ptRotationPoint = new Point(mcPhoto.x + mcPhoto.width/2, mcPhoto.y + mcPhoto.height/2);
//call the function and pass in the object to be rotated, the amount to scale X and Y (sx, sy), and the point object we created
scaleFromCenter(mcPhoto, 2, 2, ptScalePoint);

/**
 * Corrects errors caused by floating point math.
 */
public function correctFloatingPointError(number:Number, precision:int = 5):Number
{
	//default returns (10000 * number) / 10000
	//should correct very small floating point errors
	var correction:Number = Math.pow(10, precision);
	return Math.round(correction * number) / correction;
}
/**
 * Tests if two numbers are <em>almost</em> equal.
 */
public function fuzzyEquals(number1:Number, number2:Number, precision:int = 5):Boolean
{
	var difference:Number = number1 - number2;
	var range:Number = Math.pow(10, -precision);
	//default check:
	//0.00001 <difference> -0.00001
	return difference <range && difference> -range;
}
/*
Copyright (c) 2007 Josh Tynjala
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
*/

 private function rotateAroundCenter (ob:*, angleDegrees:Number, ptRotationPoint:Point) {
      var m:Matrix=ob.transform.matrix;
      m.tx -= ptRotationPoint.x;
      m.ty -= ptRotationPoint.y;
      m.rotate (angleDegrees*(Math.PI/180));
      m.tx += ptRotationPoint.x;
      m.ty += ptRotationPoint.y;
      ob.transform.matrix=m;
 }

//this will create a point object at the center of the display object
ptRotationPoint = new Point(mcPhoto.x + mcPhoto.width/2, mcPhoto.y+mcPhoto.height/2);
//call the function and pass in the object to be rotated, the amount in degrees, and the point object we created
rotateAroundCenter(mcPhoto, 90, ptRotationPoint);

blockLeft.addEventListener(MouseEvent.CLICK, clickBlock);
blockLeft.buttonMode = true;
blockLeft.mouseChildren = true;
 
blockRight.addEventListener(MouseEvent.CLICK, clickBlock);
blockRight.buttonMode = true;
blockRight.mouseChildren = false;
 
function clickBlock(e:Event):void
{
	txtTarget.text = "e.target.name: " + e.target.name;
}

var mediaLoader:Loader = new Loader();
var bmFullsize:Bitmap;
var bmHalfsize:Bitmap;
var bmThumbsize:Bitmap;
 
mediaLoader.load(new URLRequest("ostrich.jpg"));
mediaLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, resizeImages);
 
function resizeImages(e:Event):void
{
	bmFullsize = new Bitmap(e.target.content.bitmapData.clone());
	bmHalfsize = new Bitmap(e.target.content.bitmapData.clone());
	bmThumbsize = new Bitmap(e.target.content.bitmapData.clone());
	bmFullsize.width = 300;
	bmFullsize.height = 300;
	bmFullsize.smoothing = true;
	bmHalfsize.width = 150;
	bmHalfsize.height = 150;
	bmHalfsize.x = bmFullsize.width;
	bmHalfsize.smoothing = true;
	bmThumbsize.width = 75;
	bmThumbsize.height = 75;
	bmThumbsize.x = (bmFullsize.width + bmHalfsize.width);
	bmThumbsize.smoothing = true;
	showImages();
}
 
function showImages():void
{
	addChild(bmFullsize);
	addChild(bmHalfsize);
	addChild(bmThumbsize);
}