package com.devahead.utils
{
	import flash.display.DisplayObjectContainer;
	import flash.events.Event;
	import flash.events.EventDispatcher;

	import mx.collections.ArrayCollection;
	import mx.containers.Canvas;
	import mx.core.Application;
	import mx.core.IChildList;
	import mx.core.UIComponent;

	public class UserInteractionManager extends EventDispatcher
	{
		protected var _blocker: Canvas = null;

		protected var _managedApp: Application = null;

		/**
		 * Application managed by this UserInteractionManager instance.
		 */
		public function get managedApp(): Application
		{
			return _managedApp;
		}

		protected var _focusState: Object = null;

		/**
		 * Data about the focused components before disabling the
		 * user interaction.
		 */
		protected function get focusState(): Object
		{
			return _focusState;
		}

		protected function set focusState(value: Object): void
		{
			_focusState = value;

			dispatchEvent(new Event("isInteractionEnabledChanged"));
		}

		/**
		 * Tells if the user interaction is currently enabled.
		 */
		[Bindable("isInteractionEnabledChanged")]
		public function get isInteractionEnabled(): Boolean
		{
			return (_focusState == null);
		}

		/**
		 * Constructor.
		 *
		 * @param managedApp
		 *   Application instance managed by UserInteractionManager.
		 */
		public function UserInteractionManager(managedApp: Application)
		{
			_managedApp = managedApp;

			// Create the blocker component to avoid mouse clicks.
			// We set a backgroundColor to actually allow the clicks to be blocked
			// (it doesn't work if the blocker is totally transparent) and we set
			// the backgroundAlpha to a very small number so the blocker is not
			// transparent for the Flash player but it is actually invisible for the
			// human eye.
			_blocker = new Canvas();
			_blocker.setStyle("backgroundColor", 0xffffff);
			_blocker.setStyle("backgroundAlpha", 0.01);
		}

		/**
		 * Disable the user interaction with the application.
		 */
		public function disableUserInteraction(): void
		{
			// Check if interaction is already disabled
			if (!isInteractionEnabled) return;

			// Save the information about the current focused component
			focusState = new Object();

			if (_managedApp.focusManager != null)
			{
				focusState.focusedComponent = _managedApp.focusManager.getFocus();

				if (focusState.focusedComponent != null &&
					focusState.focusedComponent.hasOwnProperty("selectionBeginIndex") &&
					focusState.focusedComponent.hasOwnProperty("selectionEndIndex"))
				{
					// Save the selection information about the focused component (useful for text
					// selection inside a TextInput for example).
					focusState.focusedCompSelectionBeginIndex = focusState.focusedComponent.selectionBeginIndex;
					focusState.focusedCompSelectionEndIndex = focusState.focusedComponent.selectionEndIndex;
				}
			}

			// Set the size of the blocker
			_blocker.width = _managedApp.width;
			_blocker.height = _managedApp.height;

			// Make the blocker the topmost component in the display list
			var rawChildren: IChildList = _managedApp.systemManager.rawChildren;

			if (rawChildren.contains(_blocker))
			{
				rawChildren.removeChild(_blocker);
			}

			rawChildren.addChild(_blocker);

			if (_managedApp.stage != null)
			{
				// Remove the focus from the current focused component
				_managedApp.stage.focus = null;
			}

			if (_managedApp.systemManager is DisplayObjectContainer)
			{
				// Disable tabbing so the user cannot use the tab key to cycle
				// among the components.
				focusState.sysManTabChildren = (_managedApp.systemManager as DisplayObjectContainer).tabChildren;
				(_managedApp.systemManager as DisplayObjectContainer).tabChildren = false;
			}
		}

		/**
		 * Restore the user interaction with the application.
		 */
		public function restoreUserInteraction(): void
		{
			// Check if the interaction is already enabled
			if (isInteractionEnabled) return;

			if (_managedApp.systemManager is DisplayObjectContainer)
			{
				// Restore the tabbing state saved before disabling the user interaction
				(_managedApp.systemManager as DisplayObjectContainer).tabChildren = focusState.sysManTabChildren;
			}

			// Remove the blocker from the display list
			var rawChildren: IChildList = _managedApp.systemManager.rawChildren;

			if (rawChildren.contains(_blocker))
			{
				rawChildren.removeChild(_blocker);
			}

			if (focusState.hasOwnProperty("focusedComponent") &&
				focusState.focusedComponent != null &&
				_managedApp.focusManager != null)
			{
				// Check if I can restore the focus or not depending on whether or not there
				// are modal popups over the previously focused component.
				var canRestoreFocus: Boolean = false;

				if (_managedApp.systemManager.numModalWindows > 0)
				{
					// Get the list of all the active popups
					var popupList: ArrayCollection = PopUpUtils.getAllPopups(_managedApp, true);

					if (popupList.length == 0)
					{
						// There are no popups, so I can restore the focus
						canRestoreFocus = true;
					}
					else
					{
						if (focusState.focusedComponent is UIComponent)
						{
							// Get the topmost popup
							var topmostPopup: Object = popupList.getItemAt(popupList.length - 1);

							var currParent: Object = (focusState.focusedComponent as UIComponent).parent;

							// Go through all the parents hierarchy for the component that should be
							// focused to check if it belongs to the topmost popup.
							while (currParent != null)
							{
								if (currParent == topmostPopup)
								{
									// The component that should be focused belongs to the topmost popup,
									// so I can restore the focus.
									canRestoreFocus = true;
									break;
								}

								if (currParent == currParent.parent)
								{
									break;
								}

								currParent = currParent.parent;
							}
						}
						else
						{
							canRestoreFocus = true;
						}
					}
				}
				else
				{
					// There are no modal popups, so I can always restore the focus
					canRestoreFocus = true;
				}

				if (canRestoreFocus)
				{
					// Restore the focus on the component that was focused before disabling the
					// user interaction.
					_managedApp.focusManager.setFocus(focusState.focusedComponent);

					if (focusState.focusedComponent.hasOwnProperty("selectionBeginIndex") &&
						focusState.focusedComponent.hasOwnProperty("selectionEndIndex"))
					{
						// Restore the selection inside the focused component (useful for TextInput
						// for example).
						focusState.focusedComponent.selectionBeginIndex = focusState.focusedCompSelectionBeginIndex;
						focusState.focusedComponent.selectionEndIndex = focusState.focusedCompSelectionEndIndex;
					}
				}
			}

			focusState = null;
		}
	}
}

var myObject: Object = new Object();
myObject.prop1 = "prop1Value";
myObject.prop2 = new Object();
myObject.prop2.prop21 = "subValue1";
myObject.prop2.prop22 = "subValue2";

<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
	pageTitle="Sending ActionScript objects through BlazeDS with ASObject - devahead BLOG"
	layout="vertical" horizontalAlign="left">

	<mx:Script>
		<![CDATA[
			import mx.rpc.events.FaultEvent;
			import mx.rpc.events.ResultEvent;
			import mx.controls.Alert;
			import mx.rpc.AsyncToken;

			protected static const ENDPOINT: String = "messagebroker/amf";

			protected function getRemoteObject(): void
			{
				// Create a generic ActionScript object to send to the server
				var sentGenericObj: Object = new Object();
				sentGenericObj.prop1 = 123;
				sentGenericObj.composite = new Object();
				sentGenericObj.composite.sub1 = "subValue1";
				sentGenericObj.composite.sub2 = 0.57;

				var call: AsyncToken = testService.getSentGenericObject(sentGenericObj);
				call.addResponder(new mx.rpc.Responder(
					onGetRemoteObjectOK, onGetRemoteObjectFault));
			}

			protected function onGetRemoteObjectOK(event: ResultEvent): void
			{
				var result: Object = event.result;

				Alert.show("Returned object:\n\n" +
					"prop1 = " + result.prop1 + "\n" +
					"composite.sub1 = " + result.composite.sub1 + "\n" +
					"composite.sub2 = " + result.composite.sub2);
			}

			protected function onGetRemoteObjectFault(event: FaultEvent): void
			{
				Alert.show("Error retrieving remote object.\n\n" +
					"faultString: " + event.fault.faultString + "\n" +
					"faultDetail: " + event.fault.faultDetail + "\n" +
					"faultCode: " + event.fault.faultCode, "Error");
			}
		]]>
	</mx:Script>

	<mx:RemoteObject id="testService" destination="testService" endpoint="{ENDPOINT}"
		showBusyCursor="true"/>

	<mx:Button label="Get remote object" click="{getRemoteObject()}"/>

</mx:Application>

public class SingletonClass
{
	protected static var _instance: SingletonClass = null;

	public static function getInstance(): SingletonClass
	{
		if (_instance == null)
		{
			_instance = new SingletonClass();
		}

		return _instance;
	}
}

var theInstance: SingletonClass = SingletonClass.getInstance();

<mx:Image source="@Embed(source='assets/myimage.png')"/>

<mx:Image source="{ModulesManager.getInstance().assets.myimage}"/>

package com.devahead.utils
{
	import mx.collections.ArrayCollection;
	import mx.core.Container;

	public class MiscUtils
	{
		/**
		 * Filters all the children of a container.
		 *
		 * @param container
		 *         Container of the children that have to be filtered.
		 * @param childrenClasses
		 *         Array of the classes that have to be kept while
		 *         filtering the children. If not specified, the type
		 *         of the children is not considered while filtering.
		 * @param excludedClasses
		 *         Array of the classes that have to be excluded.
		 *         The children must not belong to these types.
		 * @param excludedInstances
		 *         Array of the instances that have to be excluded.
		 *         The children must not be one of these instances.
		 * @param deepSearch
		 *         If true, specifies that the children must be
		 *         searched throughout the entire hierarchy util
		 *         there are no more children available for a
		 *         component. If false, only the children of the
		 *         container are considered and not their children.
		 * @param forceDeepSearchOnExcludedClasses
		 *         If true and also deepSearch is true, then the children
		 *         are searched also within the components that have been
		 *         excluded from the results because their type is among
		 *         the excludedClasses. If false, the children are never
		 *         searched within the excluded components. If a component
		 *         has been excluded because it's in excludedInstances, then
		 *         a deep search is never executed on it, even if it belongs
		 *         to an excluded class and forceDeepSearchOnExcludedClasses
		 *         is true.
		 * @param forceDeepSearchOnExcludedInstances
		 *         If true and also deepSearch is true, then the children
		 *         are searched also within the components that have been
		 *         excluded from the results because they are among
		 *         the excludedInstances. If false, the children are never
		 *         searched within the excluded components.
		 * @param resultArray
		 *         Array used to store the children found in the recursive
		 *         calls. It should be left null when the function is called
		 *         externally (not recursively).
		 * @return Array of the container's children filtered according
		 *         to the specified parameters.
		 */
		public static function getContainerChildren(container: Container,
			childrenClasses: Array = null, excludedClasses: Array = null,
			excludedInstances: Array = null, deepSearch: Boolean = false,
			forceDeepSearchOnExcludedClasses: Boolean = false,
			forceDeepSearchOnExcludedInstances: Boolean = false,
			resultArray: ArrayCollection = null): ArrayCollection
		{
			var componentsArray: ArrayCollection = (resultArray != null ?
				resultArray : new ArrayCollection());

			if (container != null)
			{
				// Check all the container's children
				for (var i: int = 0; i < container.numChildren; i++)
				{
					var currChild: Object = container.getChildAt(i);

					var isCorrectComponent: Boolean = false;

					// Check if the type of the current child is correct
					if (childrenClasses == null || childrenClasses.length == 0)
					{
						isCorrectComponent = true;
					}
					else
					{
						for each (var currClass: Class in childrenClasses)
						{
							if (currChild is currClass)
							{
								isCorrectComponent = true;
								break;
							}
						}
					}

					// Check if the current child is an instance that has to be excluded
					var excludedAsInstance: Boolean = false;

					if (excludedInstances != null && excludedInstances.length > 0)
					{
						for each (var currExcInst: Object in excludedInstances)
						{
							if (currChild == currExcInst)
							{
								isCorrectComponent = false;
								excludedAsInstance = true;
								break;
							}
						}
					}

					// Check if the current child's type has to be excluded
					var excludedAsClass: Boolean = false;

					if (excludedClasses != null && excludedClasses.length > 0)
					{
						for each (var currExcClass: Class in excludedClasses)
						{
							if (currChild is currExcClass)
							{
								isCorrectComponent = false;
								excludedAsClass = true;
								break;
							}
						}
					}

					// Check if I must use a deep search
					var mustGoDeeper: Boolean = (
						(excludedAsInstance && forceDeepSearchOnExcludedInstances) ||
						(!excludedAsInstance && excludedAsClass && forceDeepSearchOnExcludedClasses));

					if (deepSearch && (currChild is Container) &&
						((!excludedAsInstance && !excludedAsClass) || mustGoDeeper))
					{
						// Get all the children of the current child through a recursive call.
						//
						// NOTE: I don't need to care about the result value of the recursive
						//       call because the children found are directly inserted into the
						//       componentsArray variable.
						getContainerChildren(currChild as Container, childrenClasses,
							excludedClasses, excludedInstances, deepSearch,
							forceDeepSearchOnExcludedClasses, forceDeepSearchOnExcludedInstances,
							componentsArray);
					}

					if (isCorrectComponent)
					{
						// Add the child to the result list
						componentsArray.addItem(currChild);
					}
				}
			}

			return componentsArray;
		}
	}
}

// MyClass contains the property "prop1"
var myClassInstance: MyClass = new MyClass();
myClassInstance.prop1 = "The value";

var myProxy: ObjectProxy = new ObjectProxy(myClassInstance);

trace(myProxy.prop1); // Outputs "The value"

trace(myProxy.prop2); // ERROR! "prop2" doesn't exist in MyClass

var myProxy: ObjectProxy = new ObjectProxy();
myProxy.prop2 = "The property value";

trace(myProxy.prop2); // Outputs "The property value"