if (!dojo._hasResource["dojox.flash._common"]) { // _hasResource checks added
													// by build. Do not use
													// _hasResource directly in
													// your code.
	dojo._hasResource["dojox.flash._common"] = true;
	dojo.provide("dojox.flash._common");

	dojox.flash = function() {
		// summary:
		// The goal of dojox.flash is to make it easy to extend Flash's
		// capabilities
		// into an AJAX/DHTML environment.
		// description:
		// The goal of dojox.flash is to make it easy to extend Flash's
		// capabilities
		// into an AJAX/DHTML environment. Robust, performant, reliable
		// JavaScript/Flash communication is harder than most realize when they
		// delve into the topic, especially if you want it
		// to work on Internet Explorer, Firefox, and Safari, and to be able to
		// push around hundreds of K of information quickly. dojox.flash makes
		// it
		// possible to support these platforms; you have to jump through a few
		// hoops to get its capabilites, but if you are a library writer
		// who wants to bring Flash's storage or streaming sockets ability into
		// DHTML, for example, then dojox.flash is perfect for you.
		//  
		// dojox.flash provides an easy object for interacting with the Flash
		// plugin.
		// This object provides methods to determine the current version of the
		// Flash
		// plugin (dojox.flash.info); execute Flash instance methods
		// independent of the Flash version
		// being used (dojox.flash.comm); write out the necessary markup to
		// dynamically insert a Flash object into the page (dojox.flash.Embed;
		// and
		// do dynamic installation and upgrading of the current Flash plugin in
		// use (dojox.flash.Install).
		//		
		// To use dojox.flash, you must first wait until Flash is finished
		// loading
		// and initializing before you attempt communication or interaction.
		// To know when Flash is finished use dojo.connect:
		//		
		// dojo.connect(dojox.flash, "loaded", myInstance, "myCallback");
		//		
		// Then, while the page is still loading provide the file name
		// and the major version of Flash that will be used for Flash/JavaScript
		// communication (see "Flash Communication" below for information on the
		// different kinds of Flash/JavaScript communication supported and how
		// they
		// depend on the version of Flash installed):
		//		
		// dojox.flash.setSwf({flash6: dojo.moduleUrl("dojox",
		// "_storage/storage_flash6.swf"),
		// flash8: dojo.moduleUrl("dojox", "_storage/storage_flash8.swf")});
		//		
		// This will cause dojox.flash to pick the best way of communicating
		// between Flash and JavaScript based on the platform.
		//		
		// If no SWF files are specified, then Flash is not initialized.
		//		
		// Your Flash must use DojoExternalInterface to expose Flash methods and
		// to call JavaScript; see "Flash Communication" below for details.
		//		
		// setSwf can take an optional 'visible' attribute to control whether
		// the Flash object is visible or not on the page; the default is
		// visible:
		//		
		// dojox.flash.setSwf({flash6: dojo.moduleUrl("dojox",
		// "_storage/storage_flash6.swf"),
		// flash8: dojo.moduleUrl("dojox", "_storage/storage_flash8.swf"),
		// visible: false });
		//		
		// Once finished, you can query Flash version information:
		//		
		// dojox.flash.info.version
		//		
		// Or can communicate with Flash methods that were exposed:
		//		
		// var results = dojox.flash.comm.sayHello("Some Message");
		//		
		// Only string values are currently supported for both arguments and
		// for return results. Everything will be cast to a string on both
		// the JavaScript and Flash sides.
		//		
		// -------------------
		// Flash Communication
		// -------------------
		//		
		// dojox.flash allows Flash/JavaScript communication in
		// a way that can pass large amounts of data back and forth reliably and
		// very fast. The dojox.flash
		// framework encapsulates the specific way in which this communication
		// occurs,
		// presenting a common interface to JavaScript irrespective of the
		// underlying
		// Flash version.
		//		
		// There are currently three major ways to do Flash/JavaScript
		// communication
		// in the Flash community:
		//		
		// 1) Flash 6+ - Uses Flash methods, such as SetVariable and TCallLabel,
		// and the fscommand handler to do communication. Strengths: Very fast,
		// mature, and can send extremely large amounts of data; can do
		// synchronous method calls. Problems: Does not work on Safari; works on
		// Firefox/Mac OS X only if Flash 8 plugin is installed; cryptic to work
		// with.
		//		
		// 2) Flash 8+ - Uses ExternalInterface, which provides a way for Flash
		// methods to register themselves for callbacks from JavaScript, and a
		// way
		// for Flash to call JavaScript. Strengths: Works on Safari; elegant to
		// work with; can do synchronous method calls. Problems: Extremely buggy
		// (fails if there are new lines in the data, for example); performance
		// degrades drastically in O(n^2) time as data grows; locks up the
		// browser while
		// it is communicating; does not work in Internet Explorer if Flash
		// object is dynamically added to page with document.writeln, DOM
		// methods,
		// or innerHTML.
		//		
		// 3) Flash 6+ - Uses two seperate Flash applets, one that we
		// create over and over, passing input data into it using the PARAM tag,
		// which then uses a Flash LocalConnection to pass the data to the main
		// Flash
		// applet; communication back to Flash is accomplished using a getURL
		// call with a javascript protocol handler, such as
		// "javascript:myMethod()".
		// Strengths: the most cross browser, cross platform pre-Flash 8 method
		// of Flash communication known; works on Safari. Problems: Timing
		// issues;
		// clunky and complicated; slow; can only send very small amounts of
		// data (several K); all method calls are asynchronous.
		//		
		// dojox.flash.comm uses only the first two methods. This framework
		// was created primarily for dojox.storage, which needs to pass very
		// large
		// amounts of data synchronously and reliably across the
		// Flash/JavaScript
		// boundary. We use the first method, the Flash 6 method, on all
		// platforms
		// that support it, while using the Flash 8 ExternalInterface method
		// only on Safari with some special code to help correct
		// ExternalInterface's
		// bugs.
		//		
		// Since dojox.flash needs to have two versions of the Flash
		// file it wants to generate, a Flash 6 and a Flash 8 version to gain
		// true cross-browser compatibility, several tools are provided to ease
		// development on the Flash side.
		//		
		// In your Flash file, if you want to expose Flash methods that can be
		// called, use the DojoExternalInterface class to register methods. This
		// class is an exact API clone of the standard ExternalInterface class,
		// but
		// can work in Flash 6+ browsers. Under the covers it uses the best
		// mechanism to do communication:
		//		
		// class HelloWorld{
		// function HelloWorld(){
		// // Initialize the DojoExternalInterface class
		// DojoExternalInterface.initialize();
		//			
		// // Expose your methods
		// DojoExternalInterface.addCallback("sayHello", this, this.sayHello);
		//				
		// // Tell JavaScript that you are ready to have method calls
		// DojoExternalInterface.loaded();
		//				
		// // Call some JavaScript
		// var resultsReady = function(results){
		// trace("Received the following results from JavaScript: " + results);
		// }
		// DojoExternalInterface.call("someJavaScriptMethod", resultsReady,
		// someParameter);
		// }
		//			
		// function sayHello(){ ... }
		//			
		// static main(){ ... }
		// }
		//		
		// DojoExternalInterface adds two new functions to the ExternalInterface
		// API: initialize() and loaded(). initialize() must be called before
		// any addCallback() or call() methods are run, and loaded() must be
		// called after you are finished adding your callbacks. Calling loaded()
		// will fire the dojox.flash.loaded() event, so that JavaScript can know
		// that
		// Flash has finished loading and adding its callbacks, and can begin to
		// interact with the Flash file.
		//		
		// To generate your SWF files, use the ant task
		// "buildFlash". You must have the open source Motion Twin ActionScript
		// compiler (mtasc) installed and in your path to use the "buildFlash"
		// ant task; download and install mtasc from http://www.mtasc.org/.
		//		
		//		
		//		
		// buildFlash usage:
		//		
		// // FIXME: this is not correct in the 0.9 world!
		// ant buildFlash -Ddojox.flash.file=../tests/flash/HelloWorld.as
		//		
		// where "dojox.flash.file" is the relative path to your Flash
		// ActionScript file.
		//		
		// This will generate two SWF files, one ending in _flash6.swf and the
		// other
		// ending in _flash8.swf in the same directory as your ActionScript
		// method:
		//		
		// HelloWorld_flash6.swf
		// HelloWorld_flash8.swf
		//		
		// Initialize dojox.flash with the filename and Flash communication
		// version to
		// use during page load; see the documentation for dojox.flash for
		// details:
		//		
		// dojox.flash.setSwf({flash6: dojo.moduleUrl("dojox",
		// "flash/tests/flash/HelloWorld_flash6.swf"),
		// flash8: dojo.moduleUrl("dojox",
		// "flash/tests/flash/HelloWorld_flash8.swf")});
		//		
		// Now, your Flash methods can be called from JavaScript as if they are
		// native
		// Flash methods, mirrored exactly on the JavaScript side:
		//		
		// dojox.flash.comm.sayHello();
		//		
		// Only Strings are supported being passed back and forth currently.
		//		
		// JavaScript to Flash communication is synchronous; i.e., results are
		// returned
		// directly from the method call:
		//		
		// var results = dojox.flash.comm.sayHello();
		//		
		// Flash to JavaScript communication is asynchronous due to limitations
		// in
		// the underlying technologies; you must use a results callback to
		// handle
		// results returned by JavaScript in your Flash AS files:
		//		
		// var resultsReady = function(results){
		// trace("Received the following results from JavaScript: " + results);
		// }
		// DojoExternalInterface.call("someJavaScriptMethod", resultsReady);
		//		
		//		
		//		
		// -------------------
		// Notes
		// -------------------
		//		
		// If you have both Flash 6 and Flash 8 versions of your file:
		//		
		// dojox.flash.setSwf({flash6: dojo.moduleUrl("dojox",
		// "flash/tests/flash/HelloWorld_flash6.swf"),
		// flash8: dojo.moduleUrl("dojox",
		// "flash/tests/flash/HelloWorld_flash8.swf")});
		//											 
		// but want to force the browser to use a certain version of Flash for
		// all platforms (for testing, for example), use the djConfig
		// variable 'forceFlashComm' with the version number to force:
		//		
		// var djConfig = { forceFlashComm: 6 };
		//		
		// Two values are currently supported, 6 and 8, for the two styles of
		// communication described above. Just because you force dojox.flash
		// to use a particular communication style is no guarantee that it will
		// work; for example, Flash 8 communication doesn't work in Internet
		// Explorer due to bugs in Flash, and Flash 6 communication does not
		// work
		// in Safari. It is best to let dojox.flash determine the best
		// communication
		// mechanism, and to use the value above only for debugging the
		// dojox.flash
		// framework itself.
		//		
		// Also note that dojox.flash can currently only work with one Flash
		// object
		// on the page; it and the API do not yet support multiple Flash objects
		// on
		// the same page.
		//		
		// We use some special tricks to get decent, linear performance
		// out of Flash 8's ExternalInterface on Safari; see the blog
		// post
		// http://codinginparadise.org/weblog/2006/02/how-to-speed-up-flash-8s.html
		// for details.
		//		
		// Your code can detect whether the Flash player is installing or having
		// its version revved in two ways. First, if dojox.flash detects that
		// Flash installation needs to occur, it sets
		// dojox.flash.info.installing
		// to true. Second, you can detect if installation is necessary with the
		// following callback:
		//		
		// dojo.connect(dojox.flash, "installing", myInstance, "myCallback");
		//		
		// You can use this callback to delay further actions that might need
		// Flash;
		// when installation is finished the full page will be refreshed and the
		// user will be placed back on your page with Flash installed.
		//		
		// -------------------
		// Todo/Known Issues
		// -------------------
		//
		// There are several tasks I was not able to do, or did not need to fix
		// to get dojo.storage out:
		//		
		// * When using Flash 8 communication, Flash method calls to JavaScript
		// are not working properly; serialization might also be broken for
		// certain
		// invalid characters when it is Flash invoking JavaScript methods.
		// The Flash side needs to have more sophisticated serialization/
		// deserialization mechanisms like JavaScript currently has. The
		// test_flash2.html unit tests should also be updated to have much more
		// sophisticated Flash to JavaScript unit tests, including large
		// amounts of data.
		//		
		// * On Internet Explorer, after doing a basic install, the page is
		// not refreshed or does not detect that Flash is now available. The way
		// to fix this is to create a custom small Flash file that is pointed to
		// during installation; when it is finished loading, it does a callback
		// that says that Flash installation is complete on IE, and we can
		// proceed
		// to initialize the dojox.flash subsystem.
		//		
		// Author- Brad Neuberg, bkn3@columbia.edu
	}

	dojox.flash = {
		flash6_version : null,
		flash8_version : null,
		ready : false,
		_visible : true,
		_loadedListeners : new Array(),
		_installingListeners : new Array(),

		setSwf : function(/* Object */fileInfo) {
			// summary: Sets the SWF files and versions we are using.
			// fileInfo: Object
			// An object that contains two attributes, 'flash6' and 'flash8',
			// each of which contains the path to our Flash 6 and Flash 8
			// versions of the file we want to script.
			// example:
			// var swfloc6 = dojo.moduleUrl("dojox.storage",
			// "Storage_version6.swf").toString();
			// var swfloc8 = dojo.moduleUrl("dojox.storage",
			// "Storage_version8.swf").toString();
			// dojox.flash.setSwf({flash6: swfloc6, flash8: swfloc8, visible:
			// false});

			if (!fileInfo) {
				return;
			}

			if (fileInfo["flash6"]) {
				this.flash6_version = fileInfo.flash6;
			}

			if (fileInfo["flash8"]) {
				this.flash8_version = fileInfo.flash8;
			}

			if (fileInfo["visible"]) {
				this._visible = fileInfo.visible;
			}

			// initialize ourselves
			this._initialize();
		},

		useFlash6 : function() { /* Boolean */
			// summary: Returns whether we are using Flash 6 for communication
			// on this platform.

			if (this.flash6_version == null) {
				return false;
			} else if (this.flash6_version != null
					&& dojox.flash.info.commVersion == 6) {
				// if we have a flash 6 version of this SWF, and this browser
				// supports
				// communicating using Flash 6 features...
				return true;
			} else {
				return false;
			}
		},

		useFlash8 : function() { /* Boolean */
			// summary: Returns whether we are using Flash 8 for communication
			// on this platform.

			if (this.flash8_version == null) {
				return false;
			} else if (this.flash8_version != null
					&& dojox.flash.info.commVersion == 8) {
				// if we have a flash 8 version of this SWF, and this browser
				// supports
				// communicating using Flash 8 features...
				return true;
			} else {
				return false;
			}
		},

		addLoadedListener : function(/* Function */listener) {
			// summary:
			// Adds a listener to know when Flash is finished loading.
			// Useful if you don't want a dependency on dojo.event.
			// listener: Function
			// A function that will be called when Flash is done loading.

			this._loadedListeners.push(listener);
		},

		addInstallingListener : function(/* Function */listener) {
			// summary:
			// Adds a listener to know if Flash is being installed.
			// Useful if you don't want a dependency on dojo.event.
			// listener: Function
			// A function that will be called if Flash is being
			// installed

			this._installingListeners.push(listener);
		},

		loaded : function() {
			// summary: Called back when the Flash subsystem is finished
			// loading.
			// description:
			// A callback when the Flash subsystem is finished loading and can
			// be
			// worked with. To be notified when Flash is finished loading,
			// connect
			// your callback to this method using the following:
			//	
			// dojo.event.connect(dojox.flash, "loaded", myInstance,
			// "myCallback");

			// dojo.debug("dojox.flash.loaded");
			dojox.flash.ready = true;
			if (dojox.flash._loadedListeners.length > 0) {
				for (var i = 0; i < dojox.flash._loadedListeners.length; i++) {
					dojox.flash._loadedListeners[i].call(null);
				}
			}
		},

		installing : function() {
			// summary: Called if Flash is being installed.
			// description:
			// A callback to know if Flash is currently being installed or
			// having its version revved. To be notified if Flash is installing,
			// connect
			// your callback to this method using the following:
			//	
			// dojo.event.connect(dojox.flash, "installing", myInstance,
			// "myCallback");

			// dojo.debug("installing");
			if (dojox.flash._installingListeners.length > 0) {
				for (var i = 0; i < dojox.flash._installingListeners.length; i++) {
					dojox.flash._installingListeners[i].call(null);
				}
			}
		},

		// Initializes dojox.flash.
		_initialize : function() {
			// dojo.debug("dojox.flash._initialize");
			// see if we need to rev or install Flash on this platform
			var installer = new dojox.flash.Install();
			dojox.flash.installer = installer;

			if (installer.needed() == true) {
				installer.install();
			} else {
				// dojo.debug("Writing object out");
				// write the flash object into the page
				dojox.flash.obj = new dojox.flash.Embed(this._visible);
				dojox.flash.obj.write(dojox.flash.info.commVersion);

				// initialize the way we do Flash/JavaScript communication
				dojox.flash.comm = new dojox.flash.Communicator();
			}
		}
	};

	dojox.flash.Info = function() {
		// summary: A class that helps us determine whether Flash is available.
		// description:
		// A class that helps us determine whether Flash is available,
		// it's major and minor versions, and what Flash version features should
		// be used for Flash/JavaScript communication. Parts of this code
		// are adapted from the automatic Flash plugin detection code
		// autogenerated
		// by the Macromedia Flash 8 authoring environment.
		//	
		// An instance of this class can be accessed on dojox.flash.info after
		// the page is finished loading.
		//	
		// This constructor must be called before the page is finished loading.

		// Visual basic helper required to detect Flash Player ActiveX control
		// version information on Internet Explorer
		if (dojo.isIE) {
			document
					.write([
							'<script language="VBScript" type="text/vbscript"\>',
							'Function VBGetSwfVer(i)',
							'  on error resume next',
							'  Dim swControl, swVersion',
							'  swVersion = 0',
							'  set swControl = CreateObject("ShockwaveFlash.ShockwaveFlash." + CStr(i))',
							'  if (IsObject(swControl)) then',
							'    swVersion = swControl.GetVariable("$version")',
							'  end if', '  VBGetSwfVer = swVersion',
							'End Function', '</script\>'].join("\r\n"));
		}

		this._detectVersion();
		this._detectCommunicationVersion();
	}

	dojox.flash.Info.prototype = {
		// version: String
		// The full version string, such as "8r22".
		version : -1,

		// versionMajor, versionMinor, versionRevision: String
		// The major, minor, and revisions of the plugin. For example, if the
		// plugin is 8r22, then the major version is 8, the minor version is 0,
		// and the revision is 22.
		versionMajor : -1,
		versionMinor : -1,
		versionRevision : -1,

		// capable: Boolean
		// Whether this platform has Flash already installed.
		capable : false,

		// commVersion: int
		// The major version number for how our Flash and JavaScript
		// communicate.
		// This can currently be the following values:
		// 6 - We use a combination of the Flash plugin methods, such as
		// SetVariable
		// and TCallLabel, along with fscommands, to do communication.
		// 8 - We use the ExternalInterface API.
		// -1 - For some reason neither method is supported, and no
		// communication
		// is possible.
		commVersion : 6,

		// installing: Boolean
		// Set if we are in the middle of a Flash installation session.
		installing : false,

		isVersionOrAbove : function(
				/* int */reqMajorVer,
				/* int */reqMinorVer,
				/* int */reqVer) { /* Boolean */
			// summary:
			// Asserts that this environment has the given major, minor, and
			// revision
			// numbers for the Flash player.
			// description:
			// Asserts that this environment has the given major, minor, and
			// revision
			// numbers for the Flash player.
			//	
			// Example- To test for Flash Player 7r14:
			//	
			// dojox.flash.info.isVersionOrAbove(7, 0, 14)
			// returns:
			// Returns true if the player is equal
			// or above the given version, false otherwise.

			// make the revision a decimal (i.e. transform revision 14 into
			// 0.14
			reqVer = parseFloat("." + reqVer);

			if (this.versionMajor >= reqMajorVer
					&& this.versionMinor >= reqMinorVer
					&& this.versionRevision >= reqVer) {
				return true;
			} else {
				return false;
			}
		},

		getResourceList : function(/* string */swfloc6, /* String */swfloc8) { /* String[] */
			// summary:
			// Returns all resources required for embedding.
			// description:
			// This is a convenience method for Dojo Offline, meant to
			// encapsulate us from the specific resources necessary for
			// embedding. Dojo Offline requires that we sync our offline
			// resources for offline availability; this method will return all
			// offline resources, including any possible query parameters that
			// might be used since caches treat resources with query
			// parameters as different than ones that have query parameters.
			// If offline and we request a resource with a query parameter
			// that was not cached with a query parameter, then we will have a
			// cache miss and not be able to work offline
			var results = [];

			// flash 6
			var swfloc = swfloc6;
			results.push(swfloc);
			swfloc = swfloc + "?baseRelativePath=" + escape(dojo.baseUrl); // FIXME:
																			// should
																			// this
																			// be
																			// encodeURIComponent?
			results.push(swfloc);
			// Safari has a strange bug where it appends '%20'%20quality=
			// to the end of Flash movies taken through XHR while offline;
			// append this so we don't get a cache miss
			swfloc += "'%20'%20quality=";
			results.push(swfloc);

			// flash 8
			swfloc = swfloc8;
			results.push(swfloc);
			swfloc += "?baseRelativePath=" + escape(dojo.baseUrl); // FIXME:
																	// should
																	// this be
																	// encodeURIComponent?
			results.push(swfloc);
			// Safari has a strange bug where it appends '%20'%20quality=
			// to the end of Flash movies taken through XHR while offline;
			// append this so we don't get a cache miss
			swfloc += "'%20'%20quality=";
			results.push(swfloc);

			// flash 6 gateway
			results.push(dojo.moduleUrl("dojox",
					"flash/flash6/flash6_gateway.swf")
					+ "");

			return results;
		},

		_detectVersion : function() {
			var versionStr;

			// loop backwards through the versions until we find the newest
			// version
			for (var testVersion = 25; testVersion > 0; testVersion--) {
				if (dojo.isIE) {
					versionStr = VBGetSwfVer(testVersion);
				} else {
					versionStr = this._JSFlashInfo(testVersion);
				}

				if (versionStr == -1) {
					this.capable = false;
					return;
				} else if (versionStr != 0) {
					var versionArray;
					if (dojo.isIE) {
						var tempArray = versionStr.split(" ");
						var tempString = tempArray[1];
						versionArray = tempString.split(",");
					} else {
						versionArray = versionStr.split(".");
					}

					this.versionMajor = versionArray[0];
					this.versionMinor = versionArray[1];
					this.versionRevision = versionArray[2];

					// 7.0r24 == 7.24
					var versionString = this.versionMajor + "."
							+ this.versionRevision;
					this.version = parseFloat(versionString);

					this.capable = true;

					break;
				}
			}
		},

		// JavaScript helper required to detect Flash Player PlugIn version
		// information. Internet Explorer uses a corresponding Visual Basic
		// version to interact with the Flash ActiveX control.
		_JSFlashInfo : function(testVersion) {
			// NS/Opera version >= 3 check for Flash plugin in plugin array
			if (navigator.plugins != null && navigator.plugins.length > 0) {
				if (navigator.plugins["Shockwave Flash 2.0"]
						|| navigator.plugins["Shockwave Flash"]) {
					var swVer2 = navigator.plugins["Shockwave Flash 2.0"]
							? " 2.0"
							: "";
					var flashDescription = navigator.plugins["Shockwave Flash"
							+ swVer2].description;
					var descArray = flashDescription.split(" ");
					var tempArrayMajor = descArray[2].split(".");
					var versionMajor = tempArrayMajor[0];
					var versionMinor = tempArrayMajor[1];
					if (descArray[3] != "") {
						var tempArrayMinor = descArray[3].split("r");
					} else {
						var tempArrayMinor = descArray[4].split("r");
					}
					var versionRevision = tempArrayMinor[1] > 0
							? tempArrayMinor[1]
							: 0;
					var version = versionMajor + "." + versionMinor + "."
							+ versionRevision;

					return version;
				}
			}

			return -1;
		},

		// Detects the mechanisms that should be used for Flash/JavaScript
		// communication, setting 'commVersion' to either 6 or 8. If the value
		// is
		// 6, we use Flash Plugin 6+ features, such as GetVariable, TCallLabel,
		// and fscommand, to do Flash/JavaScript communication; if the value is
		// 8, we use the ExternalInterface API for communication.
		_detectCommunicationVersion : function() {
			if (this.capable == false) {
				this.commVersion = null;
				return;
			}

			// detect if the user has over-ridden the default flash version
			if (typeof djConfig["forceFlashComm"] != "undefined"
					&& typeof djConfig["forceFlashComm"] != null) {
				this.commVersion = djConfig["forceFlashComm"];
				return;
			}

			// we prefer Flash 6 features over Flash 8, because they are much
			// faster
			// and much less buggy

			// at this point, we don't have a flash file to detect features on,
			// so we need to instead look at the browser environment we are in
			if (dojo.isSafari || dojo.isOpera) {
				this.commVersion = 8;
			} else {
				this.commVersion = 6;
			}
		}
	};

	dojox.flash.Embed = function(visible) {
		// summary: A class that is used to write out the Flash object into the
		// page.

		this._visible = visible;
	}

	dojox.flash.Embed.prototype = {
		// width: int
		// The width of this Flash applet. The default is the minimal width
		// necessary to show the Flash settings dialog. Current value is
		// 215 pixels.
		width : 215,

		// height: int
		// The height of this Flash applet. The default is the minimal height
		// necessary to show the Flash settings dialog. Current value is
		// 138 pixels.
		height : 138,

		// id: String
		// The id of the Flash object. Current value is 'flashObject'.
		id : "flashObject",

		// Controls whether this is a visible Flash applet or not.
		_visible : true,

		protocol : function() {
			switch (window.location.protocol) {
				case "https:" :
					return "https";
					break;
				default :
					return "http";
					break;
			}
		},

		write : function(/* String */flashVer, /* Boolean? */doExpressInstall) {
			// summary: Writes the Flash into the page.
			// description:
			// This must be called before the page
			// is finished loading.
			// flashVer: String
			// The Flash version to write.
			// doExpressInstall: Boolean
			// Whether to write out Express Install
			// information. Optional value; defaults to false.

			// dojo.debug("write");
			doExpressInstall = !!doExpressInstall;

			// determine our container div's styling
			var containerStyle = "";
			containerStyle += ("width: " + this.width + "px; ");
			containerStyle += ("height: " + this.height + "px; ");
			if (this._visible == false) {
				containerStyle += "position: absolute; z-index: 10000; top: -1000px; left: -1000px; ";
			}

			// figure out the SWF file to get and how to write out the correct
			// HTML
			// for this Flash version
			var objectHTML;
			var swfloc;
			// Flash 6
			if (flashVer == 6) {
				swfloc = dojox.flash.flash6_version;
				var dojoPath = djConfig.baseRelativePath;
				swfloc = swfloc + "?baseRelativePath=" + escape(dojoPath);
				objectHTML = '<embed id="'
						+ this.id
						+ '" src="'
						+ swfloc
						+ '" '
						+ '    quality="high" bgcolor="#ffffff" '
						+ '    width="'
						+ this.width
						+ '" height="'
						+ this.height
						+ '" '
						+ '    name="'
						+ this.id
						+ '" '
						+ '    align="middle" allowScriptAccess="sameDomain" '
						+ '    type="application/x-shockwave-flash" swLiveConnect="true" '
						+ '    pluginspage="' + this.protocol()
						+ '://www.macromedia.com/go/getflashplayer">';
			} else { // Flash 8
				swfloc = dojox.flash.flash8_version;
				var swflocObject = swfloc;
				var swflocEmbed = swfloc;
				var dojoPath = djConfig.baseRelativePath;
				if (doExpressInstall) {
					// the location to redirect to after installing
					var redirectURL = escape(window.location);
					document.title = document.title.slice(0, 47)
							+ " - Flash Player Installation";
					var docTitle = escape(document.title);
					swflocObject += "?MMredirectURL=" + redirectURL
							+ "&MMplayerType=ActiveX" + "&MMdoctitle="
							+ docTitle + "&baseRelativePath="
							+ escape(dojoPath);
					swflocEmbed += "?MMredirectURL=" + redirectURL
							+ "&MMplayerType=PlugIn" + "&baseRelativePath="
							+ escape(dojoPath);
				}

				if (swflocEmbed.indexOf("?") == -1) {
					swflocEmbed += "?baseRelativePath=" + escape(dojoPath)
							+ "' ";
				}

				objectHTML = '<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" '
						+ 'codebase="'
						+ this.protocol()
						+ '://fpdownload.macromedia.com/pub/shockwave/cabs/flash/'
						+ 'swflash.cab#version=8,0,0,0" '
						+ 'width="'
						+ this.width
						+ '" '
						+ 'height="'
						+ this.height
						+ '" '
						+ 'id="'
						+ this.id
						+ '" '
						+ 'align="middle"> '
						+ '<param name="allowScriptAccess" value="sameDomain" /> '
						+ '<param name="movie" value="'
						+ swflocObject
						+ '" /> '
						+ '<param name="quality" value="high" /> '
						+ '<param name="bgcolor" value="#ffffff" /> '
						+ '<embed src="'
						+ swflocEmbed
						+ "' "
						+ 'quality="high" '
						+ 'bgcolor="#ffffff" '
						+ 'width="'
						+ this.width
						+ '" '
						+ 'height="'
						+ this.height
						+ '" '
						+ 'id="'
						+ this.id
						+ '" '
						+ 'name="'
						+ this.id
						+ '" '
						+ 'swLiveConnect="true" '
						+ 'align="middle" '
						+ 'allowScriptAccess="sameDomain" '
						+ 'type="application/x-shockwave-flash" '
						+ 'pluginspage="'
						+ this.protocol()
						+ '://www.macromedia.com/go/getflashplayer" />'
						+ '</object>';
			}

			// now write everything out
			objectHTML = '<div id="' + this.id + 'Container" style="'
					+ containerStyle + '"> ' + objectHTML + '</div>';
			document.writeln(objectHTML);
		},

		get : function() { /* Object */
			// summary: Gets the Flash object DOM node.

			// return (dojo.render.html.ie) ? window[this.id] :
			// document[this.id];

			// more robust way to get Flash object; version above can break
			// communication on IE sometimes
			return document.getElementById(this.id);
		},

		setVisible : function(/* Boolean */visible) {
			// summary: Sets the visibility of this Flash object.

			var container = dojo.byId(this.id + "Container");
			if (visible == true) {
				container.style.visibility = "visible";
			} else {
				container.style.position = "absolute";
				container.style.x = "-1000px";
				container.style.y = "-1000px";
				container.style.visibility = "hidden";
			}
		},

		center : function() {
			// summary: Centers the flash applet on the page.

			/*
			 * var elementWidth = this.width; var elementHeight = this.height;
			 * 
			 * var scroll_offset = dojo._docScroll(); var viewport_size =
			 * dojo.html.getViewport();
			 *  // compute the centered position var x = scroll_offset.x +
			 * (viewport_size.width - elementWidth) / 2; var y = scroll_offset.y +
			 * (viewport_size.height - elementHeight) / 2;
			 */
			var x = 100;
			var y = 100;

			// set the centered position
			var container = dojo.byId(this.id + "Container");
			container.style.top = y + "px";
			container.style.left = x + "px";
		}
	};

	dojox.flash.Communicator = function() {
		// summary:
		// A class that is used to communicate between Flash and JavaScript in
		// a way that can pass large amounts of data back and forth reliably,
		// very fast, and with synchronous method calls.
		// description:
		// A class that is used to communicate between Flash and JavaScript in
		// a way that can pass large amounts of data back and forth reliably,
		// very fast, and with synchronous method calls. This class encapsulates
		// the
		// specific way in which this communication occurs,
		// presenting a common interface to JavaScript irrespective of the
		// underlying
		// Flash version.

		if (dojox.flash.useFlash6()) {
			this._writeFlash6();
		} else if (dojox.flash.useFlash8()) {
			this._writeFlash8();
		}
	}

	dojox.flash.Communicator.prototype = {
		_writeFlash6 : function() {
			var id = dojox.flash.obj.id;

			// global function needed for Flash 6 callback;
			// we write it out as a script tag because the VBScript hook for IE
			// callbacks does not work properly if this function is evalled()
			// from
			// within the Dojo system
			document.writeln('<script language="JavaScript">');
			document.writeln('  function ' + id
					+ '_DoFSCommand(command, args){ ');
			document
					.writeln('    dojox.flash.comm._handleFSCommand(command, args); ');
			document.writeln('}');
			document.writeln('</script>');

			// hook for Internet Explorer to receive FSCommands from Flash
			if (dojo.isIE) {
				document.writeln('<SCRIPT LANGUAGE=VBScript\> ');
				document.writeln('on error resume next ');
				document.writeln('Sub ' + id
						+ '_FSCommand(ByVal command, ByVal args)');
				document.writeln(' call ' + id + '_DoFSCommand(command, args)');
				document.writeln('end sub');
				document.writeln('</SCRIPT\> ');
			}
		},

		_writeFlash8 : function() {
			// nothing needs to be written out for Flash 8 communication;
			// happens automatically
		},

		// Flash 6 communication.

		// Handles fscommand's from Flash to JavaScript. Flash 6 communication.
		_handleFSCommand : function(command, args) {
			// console.debug("fscommand, command="+command+", args="+args);
			// Flash 8 on Mac/Firefox precedes all commands with the string
			// "FSCommand:";
			// strip it off if it is present
			if ((command) && dojo.isString(command)
					&& (/^FSCommand:(.*)/.test(command) == true)) {
				command = command.match(/^FSCommand:(.*)/)[1];
			}

			if (command == "addCallback") { // add Flash method for JavaScript
											// callback
				this._fscommandAddCallback(command, args);
			} else if (command == "call") { // Flash to JavaScript method call
				this._fscommandCall(command, args);
			} else if (command == "fscommandReady") { // see if fscommands are
														// ready
				this._fscommandReady();
			}
		},

		// Handles registering a callable Flash function. Flash 6 communication.
		_fscommandAddCallback : function(command, args) {
			var functionName = args;

			// do a trick, where we link this function name to our wrapper
			// function, _call, that does the actual JavaScript to Flash call
			var callFunc = function() {
				return dojox.flash.comm._call(functionName, arguments);
			};
			dojox.flash.comm[functionName] = callFunc;

			// indicate that the call was successful
			dojox.flash.obj.get().SetVariable("_succeeded", true);
		},

		// Handles Flash calling a JavaScript function. Flash 6 communication.
		_fscommandCall : function(command, args) {
			var plugin = dojox.flash.obj.get();
			var functionName = args;

			// get the number of arguments to this method call and build them up
			var numArgs = parseInt(plugin.GetVariable("_numArgs"));
			var flashArgs = new Array();
			for (var i = 0; i < numArgs; i++) {
				var currentArg = plugin.GetVariable("_" + i);
				flashArgs.push(currentArg);
			}

			// get the function instance; we technically support more
			// capabilities
			// than ExternalInterface, which can only call global functions; if
			// the method name has a dot in it, such as "dojox.flash.loaded", we
			// eval it so that the method gets run against an instance
			var runMe;
			if (functionName.indexOf(".") == -1) { // global function
				runMe = window[functionName];
			} else {
				// instance function
				runMe = eval(functionName);
			}

			// make the call and get the results
			var results = null;
			if (dojo.isFunction(runMe)) {
				results = runMe.apply(null, flashArgs);
			}

			// return the results to flash
			plugin.SetVariable("_returnResult", results);
		},

		// Reports that fscommands are ready to run if executed from Flash.
		_fscommandReady : function() {
			var plugin = dojox.flash.obj.get();
			plugin.SetVariable("fscommandReady", "true");
		},

		// The actual function that will execute a JavaScript to Flash call;
		// used
		// by the Flash 6 communication method.
		_call : function(functionName, args) {
			// we do JavaScript to Flash method calls by setting a Flash
			// variable
			// "_functionName" with the function name; "_numArgs" with the
			// number
			// of arguments; and "_0", "_1", etc for each numbered argument.
			// Flash
			// reads these, executes the function call, and returns the result
			// in "_returnResult"
			var plugin = dojox.flash.obj.get();
			plugin.SetVariable("_functionName", functionName);
			plugin.SetVariable("_numArgs", args.length);
			for (var i = 0; i < args.length; i++) {
				// unlike Flash 8's ExternalInterface, Flash 6 has no problem
				// with
				// any special characters _except_ for the null character \0;
				// double
				// encode this so the Flash side never sees it, but we can get
				// it
				// back if the value comes back to JavaScript
				var value = args[i];
				value = value.replace(/\0/g, "\\0");

				plugin.SetVariable("_" + i, value);
			}

			// now tell Flash to execute this method using the Flash Runner
			plugin.TCallLabel("/_flashRunner", "execute");

			// get the results
			var results = plugin.GetVariable("_returnResult");

			// we double encoded all null characters as //0 because Flash breaks
			// if they are present; turn the //0 back into /0
			results = results.replace(/\\0/g, "\0");

			return results;
		},

		// Flash 8 communication.

		// Registers the existence of a Flash method that we can call with
		// JavaScript, using Flash 8's ExternalInterface.
		_addExternalInterfaceCallback : function(methodName) {
			var wrapperCall = function() {
				// some browsers don't like us changing values in the
				// 'arguments' array, so
				// make a fresh copy of it
				var methodArgs = new Array(arguments.length);
				for (var i = 0; i < arguments.length; i++) {
					methodArgs[i] = arguments[i];
				}
				return dojox.flash.comm._execFlash(methodName, methodArgs);
			};

			dojox.flash.comm[methodName] = wrapperCall;
		},

		// Encodes our data to get around ExternalInterface bugs.
		// Flash 8 communication.
		_encodeData : function(data) {
			// double encode all entity values, or they will be mis-decoded
			// by Flash when returned
			var entityRE = /\&([^;]*)\;/g;
			data = data.replace(entityRE, "&amp;$1;");

			// entity encode XML-ish characters, or Flash's broken XML
			// serializer
			// breaks
			data = data.replace(/</g, "&lt;");
			data = data.replace(/>/g, "&gt;");

			// transforming \ into \\ doesn't work; just use a custom encoding
			data = data.replace("\\", "&custom_backslash;&custom_backslash;");

			data = data.replace(/\n/g, "\\n");
			data = data.replace(/\r/g, "\\r");
			data = data.replace(/\f/g, "\\f");
			data = data.replace(/\0/g, "\\0"); // null character
			data = data.replace(/\'/g, "\\\'");
			data = data.replace(/\"/g, '\\\"');

			return data;
		},

		// Decodes our data to get around ExternalInterface bugs.
		// Flash 8 communication.
		_decodeData : function(data) {
			if (data == null || typeof data == "undefined") {
				return data;
			}

			// certain XMLish characters break Flash's wire serialization for
			// ExternalInterface; these are encoded on the
			// DojoExternalInterface side into a custom encoding, rather than
			// the standard entity encoding, because otherwise we won't be able
			// to
			// differentiate between our own encoding and any entity characters
			// that are being used in the string itself
			data = data.replace(/\&custom_lt\;/g, "<");
			data = data.replace(/\&custom_gt\;/g, ">");

			// Unfortunately, Flash returns us our String with special
			// characters
			// like newlines broken into seperate characters. So if \n
			// represents
			// a new line, Flash returns it as "\" and "n". This means the
			// character
			// is _not_ a newline. This forces us to eval() the string to cause
			// escaped characters to turn into their real special character
			// values.
			data = eval('"' + data + '"');

			return data;
		},

		// Sends our method arguments over to Flash in chunks in order to
		// have ExternalInterface's performance not be O(n^2).
		// Flash 8 communication.
		_chunkArgumentData : function(value, argIndex) {
			var plugin = dojox.flash.obj.get();

			// cut up the string into pieces, and push over each piece one
			// at a time
			var numSegments = Math.ceil(value.length / 1024);
			for (var i = 0; i < numSegments; i++) {
				var startCut = i * 1024;
				var endCut = i * 1024 + 1024;
				if (i == (numSegments - 1)) {
					endCut = i * 1024 + value.length;
				}

				var piece = value.substring(startCut, endCut);

				// encode each piece seperately, rather than the entire
				// argument data, because ocassionally a special
				// character, such as an entity like &foobar;, will fall between
				// piece boundaries, and we _don't_ want to encode that value if
				// it falls between boundaries, or else we will end up with
				// incorrect
				// data when we patch the pieces back together on the other side
				piece = this._encodeData(piece);

				// directly use the underlying CallFunction method used by
				// ExternalInterface, which is vastly faster for large strings
				// and lets us bypass some Flash serialization bugs
				plugin
						.CallFunction('<invoke name="chunkArgumentData" '
								+ 'returntype="javascript">' + '<arguments>'
								+ '<string>' + piece + '</string>' + '<number>'
								+ argIndex + '</number>' + '</arguments>'
								+ '</invoke>');
			}
		},

		// Gets our method return data in chunks for better performance.
		// Flash 8 communication.
		_chunkReturnData : function() {
			var plugin = dojox.flash.obj.get();

			var numSegments = plugin.getReturnLength();
			var resultsArray = new Array();
			for (var i = 0; i < numSegments; i++) {
				// directly use the underlying CallFunction method used by
				// ExternalInterface, which is vastly faster for large strings
				var piece = plugin
						.CallFunction('<invoke name="chunkReturnData" '
								+ 'returntype="javascript">' + '<arguments>'
								+ '<number>' + i + '</number>' + '</arguments>'
								+ '</invoke>');

				// remove any leading or trailing JavaScript delimiters, which
				// surround
				// our String when it comes back from Flash since we bypass
				// Flash's
				// deserialization routines by directly calling CallFunction on
				// the
				// plugin
				if (piece == '""' || piece == "''") {
					piece = "";
				} else {
					piece = piece.substring(1, piece.length - 1);
				}

				resultsArray.push(piece);
			}
			var results = resultsArray.join("");

			return results;
		},

		// Executes a Flash method; called from the JavaScript wrapper proxy we
		// create on dojox.flash.comm.
		// Flash 8 communication.
		_execFlash : function(methodName, methodArgs) {
			var plugin = dojox.flash.obj.get();

			// begin Flash method execution
			plugin.startExec();

			// set the number of arguments
			plugin.setNumberArguments(methodArgs.length);

			// chunk and send over each argument
			for (var i = 0; i < methodArgs.length; i++) {
				this._chunkArgumentData(methodArgs[i], i);
			}

			// execute the method
			plugin.exec(methodName);

			// get the return result
			var results = this._chunkReturnData();

			// decode the results
			results = this._decodeData(results);

			// reset everything
			plugin.endExec();

			return results;
		}
	}

	// FIXME: dojo.declare()-ify this

	dojox.flash.Install = function() {
		// summary: Helps install Flash plugin if needed.
		// description:
		// Figures out the best way to automatically install the Flash plugin
		// for this browser and platform. Also determines if installation or
		// revving of the current plugin is needed on this platform.
	}

	dojox.flash.Install.prototype = {
		needed : function() { /* Boolean */
			// summary:
			// Determines if installation or revving of the current plugin is
			// needed.

			// do we even have flash?
			if (dojox.flash.info.capable == false) {
				return true;
			}

			var isMac = (navigator.appVersion.indexOf("Macintosh") >= 0);

			// are we on the Mac? Safari needs Flash version 8 to do Flash 8
			// communication, while Firefox/Mac needs Flash 8 to fix bugs it has
			// with Flash 6 communication
			if (isMac && (!dojox.flash.info.isVersionOrAbove(8, 0, 0))) {
				return true;
			}

			// other platforms need at least Flash 6 or above
			if (!dojox.flash.info.isVersionOrAbove(6, 0, 0)) {
				return true;
			}

			// otherwise we don't need installation
			return false;
		},

		install : function() {
			// summary: Performs installation or revving of the Flash plugin.

			// dojo.debug("install");
			// indicate that we are installing
			dojox.flash.info.installing = true;
			dojox.flash.installing();

			if (dojox.flash.info.capable == false) { // we have no Flash at
														// all
				// dojo.debug("Completely new install");
				// write out a simple Flash object to force the browser to
				// prompt
				// the user to install things
				var installObj = new dojox.flash.Embed(false);
				installObj.write(8); // write out HTML for Flash 8 version+
			} else if (dojox.flash.info.isVersionOrAbove(6, 0, 65)) { // Express
																		// Install
				// dojo.debug("Express install");
				var installObj = new dojox.flash.Embed(false);
				installObj.write(8, true); // write out HTML for Flash 8
											// version+
				installObj.setVisible(true);
				installObj.center();
			} else { // older Flash install than version 6r65
				alert("This content requires a more recent version of the Macromedia "
						+ " Flash Player.");
				window.location.href = +dojox.flash.Embed.protocol()
						+ "://www.macromedia.com/go/getflashplayer";
			}
		},

		// Called when the Express Install is either finished, failed, or was
		// rejected by the user.
		_onInstallStatus : function(msg) {
			if (msg == "Download.Complete") {
				// Installation is complete.
				dojox.flash._initialize();
			} else if (msg == "Download.Cancelled") {
				alert("This content requires a more recent version of the Macromedia "
						+ " Flash Player.");
				window.location.href = dojox.flash.Embed.protocol()
						+ "://www.macromedia.com/go/getflashplayer";
			} else if (msg == "Download.Failed") {
				// The end user failed to download the installer due to a
				// network failure
				alert("There was an error downloading the Flash Player update. "
						+ "Please try again later, or visit macromedia.com to download "
						+ "the latest version of the Flash plugin.");
			}
		}
	}

	// find out if Flash is installed
	dojox.flash.info = new dojox.flash.Info();

	// vim:ts=4:noet:tw=0:

}