////////////////////////////////////////////////////////////////////////////////
//
//  Licensed to the Apache Software Foundation (ASF) under one or more
//  contributor license agreements.  See the NOTICE file distributed with
//  this work for additional information regarding copyright ownership.
//  The ASF licenses this file to You under the Apache License, Version 2.0
//  (the "License"); you may not use this file except in compliance with
//  the License.  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////

package mx.automation
{
	import flash.display.DisplayObject;
	import flash.display.DisplayObjectContainer;
	import flash.display.Stage;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.FocusEvent;
	import flash.events.IEventDispatcher;
	import flash.events.KeyboardEvent;
	import flash.events.MouseEvent;
	import flash.geom.Point;
	import flash.system.ApplicationDomain;
	import flash.utils.Dictionary;
	import flash.utils.clearTimeout;
	import flash.utils.getDefinitionByName;
	import flash.utils.getQualifiedClassName;
	import flash.utils.getQualifiedSuperclassName;
	import flash.utils.setTimeout;
	
	import mx.automation.delegates.DragManagerAutomationImpl;
	import mx.automation.events.AutomationAirEvent;
	import mx.automation.events.AutomationEvent;
	import mx.automation.events.AutomationRecordEvent;
	import mx.automation.events.AutomationReplayEvent;
	import mx.automation.events.EventDetails;
	import mx.automation.events.MarshalledAutomationEvent;
	import mx.controls.Alert;
	import mx.core.Application;
	import mx.core.Container;
	import mx.core.EventPriority;
	import mx.core.IChildList;
	import mx.core.IDeferredInstantiationUIComponent;
	import mx.core.IFlexModuleFactory;
	import mx.core.IRawChildrenContainer;
	import mx.core.ISWFBridgeProvider;
	import mx.core.IUIComponent;
	import mx.core.UIComponent;
	import mx.core.mx_internal;
	import mx.events.DragEvent;
	import mx.events.FlexChangeEvent;
	import mx.events.FlexEvent;
	import mx.events.InterManagerRequest;
	import mx.events.SandboxMouseEvent;
	import mx.managers.IMarshalSystemManager;
	import mx.managers.ISystemManager;
	import mx.managers.SystemManager;
	import mx.managers.SystemManagerProxy;
	import mx.modules.ModuleManager;
	import mx.resources.IResourceManager;
	import mx.resources.ResourceManager;
	import mx.styles.IStyleClient;

	use namespace mx_internal;
	[Mixin]
 
[ResourceBundle("automation_agent")]
			
/**
 *  Provides the interface for manipulating the automation hierarchy,
 *  and for recording and replaying events.
 *  
 *  @langversion 3.0
 *  @playerversion Flash 9
 *  @playerversion AIR 1.1
 *  @productversion Flex 3
 */         
public class AutomationManager extends EventDispatcher
	   implements IAutomationManager2, IAutomationObjectHelper, 
	   IAutomationMouseSimulator, IAutomationDebugTracer
{
    include "../core/Version.as";
 

	//--------------------------------------------------------------------------
	//
	//  Class constants
	//
	//--------------------------------------------------------------------------

    /**
     *  @private
     */
	private static const MOUSE_CLICK_TYPES:Array = [ MouseEvent.MOUSE_OVER,
                                                     MouseEvent.MOUSE_DOWN,
                                                     MouseEvent.MOUSE_UP,
                                                     MouseEvent.CLICK ];

    /**
     *  @private
     */
	private static const KEY_CLICK_TYPES:Array = [ KeyboardEvent.KEY_DOWN,
                                                   KeyboardEvent.KEY_UP ];

	//--------------------------------------------------------------------------
	//
	//  Class variables
	//
	//--------------------------------------------------------------------------

    /**
     *  @private
     *  Dictionary of all app domains/systemManagers
     */
	private static var allSystemManagers:Dictionary = new Dictionary(true);
	
	/**
	 *  @private
	 *  The highest place we can listen for events in our DOM
	 */
	private static var _mainListenerObj:IEventDispatcher; 
	
	
	/**
	 *  @private
	 *  The uniqueAppID of this applicaiton as decided by the 
	 *  root AutomationManager
	 *  This field will be the applicaiton.id for the root appliction
	 */
	private static var _uniqueApplicationId:String; 
	
	/**
	 *  @private
	 *  The start point of this application in screen coordinates
	 */
	private static var _appStartPoint:Point; 
	
	/**
	 *  @private
	 *  the system manager of the current applicaiton domain
	 */
	 
	private static var sm1:ISystemManager;
	private static var _sm1MSm:IMarshalSystemManager;
	
	
	/**
	 *  @private
	 *  The popup's of the current appliation domain
	 */
	 
	private static var popUpObjects:Array;
	
	/**
	 *  @private
	 *  The daragProxy from the sub application
	 */
	 
	private static var currentDragProxyHolder:Array;
	
	
	private static var allAirWindowsToIdDictionary:Dictionary = new Dictionary(true);
	private static var allAirIdToWindowsDictionary:Dictionary = new Dictionary(true);
	private static var allAirWindowList:Array = new Array();
	private static var lastRegisteredWindowCount:int = 0;
	private static const airWindowIdFixedString:String = "_AIRWindow_";
	public static const airWindowIndicatorPropertyName:String = "isAIRWindow";
	//--------------------------------------------------------------------------
	//
	//  Class methods
	//
	//--------------------------------------------------------------------------

	private static function get mainListenerObj():IEventDispatcher
	{
		if(!_mainListenerObj)
			initMainListeners();
		
		return _mainListenerObj;
		
	}
	
	
	private static function get sm1MSm():IMarshalSystemManager
	{
		if(!_sm1MSm)
			initMainListeners();
		
		return _sm1MSm;
		
	}
    /**
     *  @private
     *  Function invoked by the SystemManager. Creates AutomationManager singleton.
     */
	public static function init(root:DisplayObject):void
	{ 
		if(!Automation.initialized)
		{
				
			sm1 = root as ISystemManager;
			var sysMgr:SystemManager = root as SystemManager;
			var tempOj:Object = sysMgr.topLevelSystemManager.getImplementation("mx.managers::IMarshalSystemManager");
			_sm1MSm = IMarshalSystemManager(sysMgr.topLevelSystemManager.getImplementation("mx.managers::IMarshalSystemManager") );
			//sm1MSm = root as IMarshalSystemManager;
			// add event listener for the new sand_box_bridge event.
			// whenver we get the new bridge
			//mainListenerObj = getMainListenerObject(sm1);
				
			Automation.automationManager = new AutomationManager;
			AutomationHelper.registerSystemManager(sm1);
					
		}
	}
	
    /**
     *  @private
     */
    private static function isChild(parent:DisplayObject,
									child:DisplayObject):Boolean
    {
        while (child != null)
        {
            if (parent == child)
                return true;
            
			child = child.parent;
        }

        return false;
    }

    /**
     *  @private
     */
    private static function comparePropertyValues(lhs:Object, rhs:Object):Boolean
    {
        //we should probably be use the DefaultPropertyCodec to transcoding help here
        //parts coming in from the testing tool should be properly typed, but they aren't
        //so pretty much lhs will always be a String or RegExp
        if (lhs == null && rhs == null)
            return true;

	   if ((lhs is String || lhs is Array) && 
            lhs.length == 0 && rhs == null)
            return true;
	   
	   /* Commenting the trimming part below because XMLList is now retruning non-trimmed strings*/
	   //For strings we are trimming because otherwise, it returns false when compared with XML.toString()
	   //because it returns trimmed strings 
	   /*if(rhs is String)
	   		rhs = trim(rhs as String);
	   if(lhs is String)
		   lhs = trim(lhs as String);*/
	   
		if ((lhs is XML ) && 
			(lhs as XML).toXMLString.length == 0 && rhs == null)
			return true;

		if(rhs == null)
		{
			if ((lhs is XMLList ) && 
				((lhs as XMLList).length() == 1))
			{
				var currentVar:XML = lhs[0];
				if(currentVar.toXMLString().length == 0)
					return true;
			}
		}
		
        if (rhs == null)
            return false;

		if(rhs is Boolean)
			return (rhs == Boolean(Number(lhs)));
				
        if (lhs is Array)
        {
            if (!(rhs is Array))
                return false;

            if (lhs.length != rhs.length)
                return false;

            for (var no:int = 0; no < lhs.length; ++no)
            {
                if (!comparePropertyValues(lhs[no], rhs[no]))
                    return false;
            }
            
            return true;
        }
        else if (lhs is RegExp)
            return lhs.test(rhs.toString());
        else if (lhs is String)
            return lhs == rhs.toString();
        else
            return lhs == rhs;
    }

    /**
     * Applies [f] to each item in [list] by calling f(list[i])
     * for i=0..[list].length.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    private static function map(f:Function, list:Array):void
    {
    	for (var i:int = 0; i < list.length; i++)
        {
    		f(list[i]);
        }
    }
	
	private static function isWhitespace( ch:String ):Boolean {
		return ch == '\r' || 
			ch == '\n' ||
			ch == '\f' || 
			ch == '\t' ||
			ch == ' '; 
	}
	
	private static function trim(string:String):String 
	{
		var n:int = string.length;
		var i:int;
		while(n>0)
		{
			if(isWhitespace(string.charAt(0)))
			{
				string = string.substring(1,n);
				n--;
			}
			else
				break;
		}
		n = string.length;
		while(n>0)
		{
			if(isWhitespace(string.charAt(n-1)))
			{
				string = string.substring(0,n-1);
				n--;
			}
			else
				break;
		}
		return string;
	}
    
	/**
	 *  @private
	 */
	private  function childAddedHandler(event:Event):void
	{
		if (!Automation.delegateDictionary)
			return;

		var object:DisplayObject = event.target as DisplayObject;
		
		if (object && object.root && object.root is DisplayObject && !allSystemManagers[object.root])
			allSystemManagers[object.root] = object.root;

		
		var delegateCreated:Boolean = createDelegate(event.target as DisplayObject);
		addDelegates(event.target as DisplayObject);
		
		if(delegateCreated == false)
		{
			var component:IAutomationObject = event.target as IAutomationObject;
			if(!component) // the obejct is not an IAutomationObject of the main applicaiton 
			{
				
				if(object.parent )
				{
					// try to get the parents classname.
					var className:String = getQualifiedClassName(object.parent);
					
					// when we get Alerts which are part of the another application
					// we cannot create the delegate here. Here we should send the details
					// to the other application and let them handle the same.
					if((className == "mx.managers::SystemManagerProxy")||
					 ((object.hasOwnProperty("className")&&	(object["className"] == "DragProxy")))||
						(className =="mx.managers.dragClasses::DragProxy"))
					
					//if(className == "mx.managers::SystemManagerProxy")
					{
						
						var tempEventObj:MarshalledAutomationEvent = new MarshalledAutomationEvent(
								MarshalledAutomationEvent.POPUP_HANDLER_REQUEST);
						var tempArr:Array = new Array();
						tempArr.push(object);
						tempEventObj.interAppDataToSubApp = tempArr;
						dispatchMarshalledEventToSubApplications(tempEventObj);
					}
				}
			}
	
		}
	}
	
		
	/**
	 *  @private
     *  Given a object returns the SystemManager object which contains
     *  the applicationDomain containing the object class.
	 */
	private static function getSWFRoot(object:DisplayObject):DisplayObject
	{
		var className:String = getQualifiedClassName(object);

		var domain:ApplicationDomain;
		var compClass:Class;
		for (var p:* in allSystemManagers)
		{
			domain = p.loaderInfo.applicationDomain;
			try
			{
				compClass = Class(domain.getDefinition(className));
				if (object is compClass)
					return p as DisplayObject;
			}
			catch(e:Error)
			{
                 //exception means that the application domain 
                 //doesn't contain the object class.
			}
		}
		
        //we have failed to find the application domain in the dictionary.
        //try the nearest systemManager instance.
		var sm:DisplayObject = object;
		while(sm && !(sm is ISystemManager))
		{
			sm = sm.parent;
		}
		if(sm)
		{
			
			domain = sm.loaderInfo.applicationDomain;
			try	
			{
				compClass = Class(domain.getDefinition(className));
				if (object is compClass)
					return sm;
			}
			catch(e:Error)
			{
				// we didnt get the current object in any of the system manager's domain 
				// and we got this exception. It is quite possible that the class 
				// is an internal class. so let us rerutn the last parent's system manager.
				// FLEXENT-1088, 1090, we should not return the parent's sm as this will prevent
				// the module's app domain getting tried out.
				//return sm;
			}
		}
		
		return null;
	}
	
	/**
	 *  @private
	 */	 
	private static function createDelegate(obj:DisplayObject):Boolean
	{
		var component:IAutomationObject = obj as IAutomationObject;
		//if(!(obj is IAutomationObject || component == null || component.automationDelegate))
		// the above looks to be wrong as we were adding the delegate for the same object more than once
		// so change as follows
		if((component == null)||(component.automationDelegate))
		{
			return false;
		}
		
		var retValue:Boolean = false;
		var appDomain:ApplicationDomain;
		var className:String = getQualifiedClassName(obj);
		var message:String;
		if(!className)
		{
			message = "class name for the object could not be obtained " + obj.toString();
			Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",message);
			return false;
		}
			
		var sm:DisplayObject = getSWFRoot(obj);
		
		if(!sm)
		{
	        var factory:IFlexModuleFactory = ModuleManager.getAssociatedFactory(obj);
	        if (factory != null)
    	    {
        	    appDomain = ApplicationDomain(factory.info()["currentDomain"]);
	        }
	        else
	        {
	        	message = "Factory module failure";
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",message);
	        }
		}
		else
		{
			appDomain = (sm.loaderInfo) ? sm.loaderInfo.applicationDomain :
											ApplicationDomain.currentDomain;
		}
		
		var delegateClass:Class = null;
		var compClass:Class = null;
		var mainComponentClass:Class = null;
		try
		{
			if(appDomain)
			{
				compClass = appDomain.getDefinition(className) as Class;
				mainComponentClass = compClass;
				delegateClass = Automation.delegateDictionary[compClass] as Class;
			}
			else
			{
				message = "Failed in getting the definition or the class or getting the delegate. " + 
					"Automation will not work for this component. " + className;
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",message);
			}
		}
		catch(e:Error)
		{
			message = "Failed in getting the definition or the class or getting the delegate. " + 
					"Automation will not work for this component. " + className;
			Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",message);
			Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",e.message);
			//return false;
		}
		
		if(!delegateClass && appDomain)
		{
			var componentClass:String = className;
			do 
			{
				try 
				{
					className = getQualifiedSuperclassName(appDomain.getDefinition(className));
					if(className)
					{
						compClass = appDomain.getDefinition(className) as Class;
						delegateClass = Automation.delegateDictionary[compClass] as Class;
					}
				}
				catch(e:Error)
				{
					Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",e.message);
					break;
				}
			}
			while(!delegateClass && className);
			
			Automation.delegateDictionary[mainComponentClass] = delegateClass; 
			//trace("Added mapping for : " + componentClass);
			
			if(!className)
			{
				message = "super class name for the object could not be obtained "+ componentClass;
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",message);
				return false;
			}

		}
		

		var c:Class = delegateClass;
		if (c)
		{
			try
			{
				var delegate:Object = new c (obj);
			}
			catch(e:Error)
			{
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",e.message);
				message = "Delegate object couldnot be created";
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",message);
			}
			
			try
			{
				component.automationDelegate = delegate;
				retValue = true;
			}
			catch(e:Error)
			{
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",e.message);
				message = "object created but delegates not set";
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",message);
			}
		}
		else{
			message = "Unable to find definition for class : " + className;
			Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegate()",message);
		}
			
		return retValue;
	}

	/**
	 *  @private
	 *  Do a tree walk and add all children you can find.
	 */
	private static function addDelegates(o:DisplayObject):void
	{
		var child:DisplayObject ;
		var i:int;
		
		if (o is DisplayObjectContainer)
		{
			var doc:DisplayObjectContainer = DisplayObjectContainer(o);

			if (o is IRawChildrenContainer)
			{
				// trace("using view rawChildren");
				var rawChildren:IChildList = IRawChildrenContainer(o).rawChildren;
				// recursively visit and add children of components
				// we don't do this for containers because we get individual
				// adds for the individual children
				for (i = 0; i < rawChildren.numChildren; i++)
				{
					try
					{
						child = rawChildren.getChildAt(i);
						createDelegate(child);
						addDelegates(child);
					}
					catch(error:SecurityError)
					{
						// Ignore this child if we can't access it
					}
				}

			}
			else
			{
				// trace("using container's children");
				// recursively visit and add children of components
				// we don't do this for containers because we get individual
				// adds for the individual children
				for (i = 0; i < doc.numChildren; i++)
				{
					try
					{
						child = doc.getChildAt(i);
						createDelegate(child);
						addDelegates(child);
					}
					catch(error:SecurityError)
					{
						// Ignore this child if we can't access it
					}
				}
			}
		}
		
		// do special creation of repeater delegates as they do not
		// get added as children of Containers
		var container:Container;
		var repeaters:Array;
		var count:int;
		if(o is Container)
		{
			container = o as Container;
			repeaters = container.childRepeaters;
			// change for https://bugs.adobe.com/jira/browse/FLEXENT-1044
			//if(!repeaters)
			//	return;
			count = repeaters?repeaters.length:0;
			for(i = 0; i < count; ++i)
			{
				createDelegate(repeaters[i]);
			}
		}

		// do special creation of repeater delegates as they do not
		// get added as children of Containers
		if(o.parent is Container)
		{
			container = o.parent as Container;
			repeaters = container.childRepeaters;
			// change for https://bugs.adobe.com/jira/browse/FLEXENT-1044
			//if(!repeaters)
			//	return;
			count = repeaters?repeaters.length:0;
			for(i = 0; i < count; ++i)
			{
				var repeater:IAutomationObject = repeaters[i] as IAutomationObject;
				if(repeater && !repeater.automationDelegate)
					createDelegate(repeaters[i]);
			}
		}
		
		// let us add one more level of check for the repeaters.
		// change for https://bugs.adobe.com/jira/browse/FLEXENT-1044
		
		if(o is UIComponent)
		{
			var uiComp:UIComponent = o as UIComponent;
			repeaters = uiComp.repeaters;
			count = repeaters? repeaters.length : 0;
			for(i = 0; i < count; ++i)
			{
				var repeater1:IAutomationObject = repeaters[i] as IAutomationObject;
				if(repeater1 && !repeater1.automationDelegate)
					createDelegate(repeaters[i]);
			}
		}
		
	}

    //--------------------------------------------------------------------------
    //
    //  Constructor
    //
    //--------------------------------------------------------------------------    
    
    /**
	 *  @private
	 *  Constructor
	 */ 
	public function AutomationManager()
    { 
		super();
		
		//if(mainListenerObj)
		{
			// when the application is completed we need to add listener to the existing bridge
			sm1.addEventListener(FlexEvent.APPLICATION_COMPLETE, applicationCompleteHandler,false,EventPriority.DEFAULT);
			sm1.addEventListener(FlexChangeEvent.ADD_CHILD_BRIDGE , childBridgeHandler);

			sm1.addEventListener(Event.ADDED, childAddedHandler, false, 0, true);
			// FLEXENT-894 or 895 it was observerd that popupmenubutton menu popup object is
			// creatd before application completion. So we need to listen to the event
			// from the main app before the application completion. 
			// this event is removed lated when we listen to the after application completion
			//mainListenerObj.addEventListener(MarshalledAutomationEvent.POPUP_HANDLER_REQUEST , popupHandlerBeforeApplicationCompletion, false, 0, true);
			// FLEXENT-1002
			// when the sdk changes happened with the IMarshaledSystemManager, since the mainListenerObj was not available here
			// we moved the following line to the applicaiton completion handler. But we need this handled before the application completion
			// the popups of the application domain is added to the sandbox root application, we can depend on the sanbox to add to the listener for this
			// event.
			sm1.getSandboxRoot().addEventListener(MarshalledAutomationEvent.POPUP_HANDLER_REQUEST , popupHandlerBeforeApplicationCompletion, false, 0, true);
	
		}
    }
    
    //--------------------------------------------------------------------------
    //
    //  Variables
    //
    //--------------------------------------------------------------------------    
    
    /**
	 *  @private
	 */
	private var lastMouseTarget:IEventDispatcher = null;
    
    /**
	 *  @private
	 */
    private var hierarchyCacheCounter:int = 0;
    
    /**
	 *  @private
	 */
	private var rebuildPartCache:Boolean = true;
    
    /**
	 *  @private
	 *  Holds automationIDPart objects for reuse.
	 *  The IDParts are cached for the duration of one recording/function call.
	 */
	private var cachedParts:Dictionary = null;
    
    /**
	 *  @private
	 *  Holds the array of automation children for a container.
	 *  The children are cached for the duration of one recording/function call.
	 */
	private var cachedChildren:Dictionary = null;
	
    /**
	 *  @private
	 */
	private var cachedCompositor:Dictionary = null;

    /**
	 *  @private
	 */
    private var cachingEvents:Boolean = false;
    
    /**
	 *  @private
	 */
	private var cachedTargetOriginator:EventDispatcher = null;
    
    /**
	 *  @private
	 */
	private var eventCache:Array = [];
    
    /**
	 *  @private
	 */
	private var flushCacheTimeoutID:int = -1;
    
    /**
	 *  @private
	 */
	private var recordedEventInCurrentMouseSequence:Boolean = false;
    
    /**
	 *  @private
	 */
	private var inMouseSequence:Boolean = false;
    
    /**
	 *  @private
	 */
	private var synchronization:Array = [];

    /**
	 *  @private
	 */
	private var _currentMousePositions:Array = [];
    
    /**
	 *  @private
	 */
	private var _prevMouseTargets:Array = [];
    
	/**
	 *  @private
	 *  Used for accessing localized Error messages.
	 */
	private var resourceManager:IResourceManager =
									ResourceManager.getInstance();

    //--------------------------------------------------------------------------
    //
    //  Properties
    //
    //--------------------------------------------------------------------------    

	//----------------------------------
	//  automationEnvironment
	//----------------------------------

    /**
	 *  @private
	 *  Storage for the automationEnvironment property.
	 */
    private  static var _automationEnvironment:IAutomationEnvironment;
     private static var _automationEnvironmentString:String;
     private static var _automationEnvironmentHandlingClassName:String;

    /**
     *  @private
     */
    public  function get automationEnvironment():Object
    {
    	//For AIR apps it is possible that environment details for main app are set
    	//after the child apps request handlers are handled. So it can be null for child apps
    	//intially. We need a way to get the environment details for AIR apps when actually needed
    	if(!_automationEnvironment)	//happens only for AIR apps
    	{
    		// we will listen to the initial details from our parent.
    		var initialStatusRequest:MarshalledAutomationEvent = 
    			new MarshalledAutomationEvent(MarshalledAutomationEvent.INITIAL_DETAILS_REQUEST);
    		_inInitialDetailsRequestProcessing = true;
    		dispatchToParent(initialStatusRequest);
    	}
        return _automationEnvironment;
    }

    /**
     *  @private
     */
    public  function set automationEnvironment(value:Object):void
    {
        _automationEnvironment = value as IAutomationEnvironment;
        // we expect this method to be called only on the top root applicaiton
    }

 /**
     *  @private
     */
    public function get automationEnvironmentString():String
    {
        return _automationEnvironmentString;
    }

    /**
     *  @private
     */
    public function set automationEnvironmentString(value:String):void
    {
        _automationEnvironmentString = value;
       
    }
    
     
    public function getUniqueApplicationID():String
    {
    	if (_uniqueApplicationId == null)
    	{
	    	if(sm1.isTopLevelRoot() == false)
	    	{
	    		// we should the following approach only for the sub
	    		// applicaiton in the main security domain
	    		// applications across security domain cannot access the
	    		// parents of the system manager
	    		if(sm1.isTopLevel() && (sm1.topLevelSystemManager.getSandboxRoot() == sm1.getSandboxRoot()) )
	 			{
		    		// we need to get the id of the current application from the parent
		    		dispatchUniqueAppIdRequestEvent();
		    			
		    		var currentApplicationId:String = Automation.getMainApplication().className; 
					_uniqueApplicationId = currentApplicationId + "_"+ _uniqueApplicationId;
					//trace(_uniqueApplicationId + "   -   "+ classNameArray.join("|"));

	   			 }
	   			 else
	   			 {
	   			 	// we expect this loop to reach for the sub applicaiton is 
	   			 	// different security domain
	   			 	var temp:int = 0;
	   			 }
	    		
	    	}
	    	else
	    	{
	    		 	if(Automation.getMainApplication().hasOwnProperty("applicationID"))// this should work for AIR app's
					{
						_uniqueApplicationId = Automation.getMainApplication().applicationID;
					}
					else
	    				_uniqueApplicationId = Automation.getMainApplication().id;
	    				
	    			if(!_uniqueApplicationId)
	    				_uniqueApplicationId = AutomationHelper.getAppTitle();
	    			
	    	}
	    }
	    		
    	return _uniqueApplicationId;
    }
    
    //This method is used only by Flex apps which are loaded from air apps
    // to get the start point of their main air app in screen coordinates
    public function getStartPointInScreenCoordinates(windowId:String):Point
    {
    	var startPointRequest:MarshalledAutomationEvent = 
    			new MarshalledAutomationEvent(MarshalledAutomationEvent.START_POINT_REQUEST);
    	_inStartPointRequestProcessing = true;
    	var tempArray:Array = [];
    	tempArray.push(windowId);
    	startPointRequest.interAppDataToMainApp = tempArray;
    	dispatchToParent(startPointRequest);
    	//reply handler for the above event (startPointReplyHandler) would store the 
    	//start point in the variable _appStartPoint
    	
    	return _appStartPoint;
    }
    
    private function dispatchStartPointRequestEvent(windowId:String):void
    {
    	var startPointRequest:MarshalledAutomationEvent = 
    			new MarshalledAutomationEvent(MarshalledAutomationEvent.START_POINT_REQUEST);
    	_inStartPointRequestProcessing = true;
    	var tempArray:Array = [];
    	tempArray.push(windowId);
    	startPointRequest.interAppDataToMainApp = tempArray;
    	dispatchToBridgeParent(startPointRequest);
    }
    
    private static function getChildIndex1(parent:DisplayObjectContainer, child:DisplayObject):int
    {
        try 
        {
            return parent.getChildIndex(child);
        }
        catch(e:Error)
        {
            if (parent is IRawChildrenContainer)
                return IRawChildrenContainer(parent).rawChildren.getChildIndex(child);
            throw e;
        }
        throw new Error("FocusManager.getChildIndex failed");   // shouldn't ever get here
    }

    
     /**
     *  @private
     */
	public function set automationEnvironmentHandlingClassName(className:String):void
	{
		 _automationEnvironmentHandlingClassName = className;
	}
	
	/**
     *  @private
     */
    public function get automationEnvironmentHandlingClassName():String
    {
        return _automationEnvironmentHandlingClassName;
    }
	//----------------------------------
	//  recording
	//----------------------------------

    /**
	 *  @private
	 *  Storage for the recording property.
	 */
	private var _recording:Boolean = false;
    /**
     *  @private
     */
	public function get recording():Boolean
	{
		return _recording;
	}

	//----------------------------------
	//  replaying
	//----------------------------------

    /**
	 *  @private
	 *  Storage for the replaying property.
	 */
    private var _replaying:Boolean = false;
    
    /**
     *  @private
     */
    public function get replaying():Boolean
    {
        return _replaying;
    }
	
    //--------------------------------------------------------------------------
    //
    //  Methods
    //
    //--------------------------------------------------------------------------    

    /**
     *  @private
     */
    public function getParent(
					   obj:IAutomationObject, 
                       parentToStopAt:IAutomationObject = null,
                       ignoreShowInHierarchy:Boolean = false):IAutomationObject
    {
        while (obj)
        {
			var parent:IAutomationObject;
			if(obj is IAutomationObject)
				parent = (obj as IAutomationObject).automationOwner as IAutomationObject;
			
            if (!parent && (obj is IUIComponent ) &&(IUIComponent(obj).systemManager != null) && 
				(IUIComponent(obj).systemManager.document != null) && (obj != IUIComponent(obj).systemManager.document))
			{
				var doc:Object = IUIComponent(obj).systemManager.document;
				parent = (doc as IAutomationObject);
			}
			else 
			{
				var parentObj:DisplayObject;
				if(obj is IAutomationObject)
					parentObj = (obj as IAutomationObject).automationOwner as DisplayObject;
				
				var parentClassName:String = getQualifiedClassName(parentObj);
				if(parentClassName == "mx.managers::SystemManagerProxy")
				{
					parent = (Automation.getMainApplication() as IAutomationObject);
				}
				
			}
			
			if (parent && (parent == parentToStopAt || 
                           ignoreShowInHierarchy ||
                           showInHierarchy(parent)))
			{
				return parent;
			}
			else
			{			
				obj = parent;
			}
        }

        return null;
    }

    /**
     *  @private
     */
    public function getChildrenFromIDPart(
						obj:IAutomationObject,
    					part:AutomationIDPart = null,
                        ignoreShowInHierarchy:Boolean = false):Array
    {
		if (part == null)
		{
			return getChildren(obj, ignoreShowInHierarchy);
		}
		else
		{
			// important to do this check and not rely on it being checked
			// when getChildren is eventually called by resolveIDPart because
			// resolving always ignores the show in hierarchy and automation
			// composite flags because resolving can be delegated to children
			// that are not visible in the hieararchy (see comment in scoreChild)
	        if (!obj || 
	            !(obj is IAutomationObject) || 
	            !(ignoreShowInHierarchy || showInHierarchy(obj)))
			{
	            return [];
			}
		
	    	return resolveIDPart(obj, part);
		}
    }
    
    private function getApplicationChildren(obj:IAutomationObject):Array
    {
    	var result:Array = [];
        if ( (obj is IUIComponent) && (IUIComponent(obj).systemManager != null)&&(obj == IUIComponent(obj).systemManager.document))
        {
			var sm:IChildList = null;
			if(IUIComponent(obj).systemManager is IChildList)
				sm =  IChildList(IUIComponent(obj).systemManager);
                
            var x:DisplayObject;
            var delegate:IAutomationObject;

			var count:int = sm?sm.numChildren:0;
            for (var i:int = 0; i < count; i++)
            {
                //check that the automationParent is null because
                //popup menus will all be children of SM but only one
                //is the root, the rest are automation children of other menus
                x = sm.getChildAt(i);
				
				delegate = (x as IAutomationObject);
				if (delegate && 
                        delegate != obj && 
                        (!(delegate.automationOwner is IAutomationObject) ||
                        delegate.automationOwner == obj))
				{
                    result.push(delegate);
				}
            }
            
			var popupChildren:IChildList = null;
			
			if(IUIComponent(obj).systemManager && 
				(IUIComponent(obj).systemManager.popUpChildren) is IChildList )
				popupChildren=  IChildList(IUIComponent(obj).systemManager.popUpChildren);
			
			var count1:int = popupChildren? popupChildren.numChildren:0;
			
            for (i = 0; i < count1; i++)
            {
                //check that the automationParent is null because
                //popup menus will all be children of SM but only one
                //is the root, the rest are automation children of other menus
                x = popupChildren.getChildAt(i);
				
				delegate = (x as IAutomationObject);
				if (delegate && 
                        delegate != obj && 
                        (!(delegate.automationOwner is IAutomationObject) ||
                        delegate.automationOwner == obj))
				{
                    result.push(delegate);
				}
            }
        }
        return result;
    }

    /**
     *  @private
     */
    public function getChildren(obj:IAutomationObject,
                                ignoreShowInHierarchy:Boolean = false):Array
    {
        if (!obj || 
            !(obj is IAutomationObject) || 
            !(ignoreShowInHierarchy || showInHierarchy(obj)))
		{
            return [];
		}

        var result:Array = cachedChildren != null ? cachedChildren[obj] : null;

        if (result == null)
        {
            result = getChildrenRecursively(obj);
            
            if( (obj is IUIComponent) && (IUIComponent(obj).systemManager != null) && (obj == IUIComponent(obj).systemManager.document))
	        {
	        	 var children:Array = getApplicationChildren(obj);
	        	 result = result ? result.concat(children) : children;
	        }

            result = result || [];
            
            if (hierarchyCacheCounter > 0)
                cachedChildren[obj] = result;
        }

        return result;
    }

    /**
     *  @private
     */
    private function getChildrenRecursively(
							aoc:IAutomationObject):Array
    {
        var result:Array = null;
		// code modified below to avoid the usage of numAutomationChildren and
		// getAutomationChildAt in a loop
		//var childList:Array = aoc.getAutomationChildren();
		var childList:Array = getAutomationChildrenArray(aoc);
		var numAutomationChildren:int = childList?childList.length:0;
		
        //var numAutomationChildren:int = aoc.numAutomationChildren;
        for (var i:int = 0; i < numAutomationChildren; i++)
        {
            //var ao:IAutomationObject = aoc.getAutomationChildAt(i);
			var ao:IAutomationObject = childList[i] as IAutomationObject;
			if(ao)
			{
	            if (isAutomationComposite(ao))
	                continue;
	            
				if (! result)
	                result = [];
	            result.push(ao);
	            
				if (showInHierarchy(ao))
	                continue;
	            
				// we dont need this check as this check itself needs to
				// calculate all its children
				//if (ao.numAutomationChildren > 0)
	            {
	                var x:Array =
						getChildrenRecursively(ao)
	
	                if (x && x.length)
	                    result = result ? result.concat(x) : x;
	            }
			}
        }

        return result;
    }

    /**
     *  @private
     */
    public function getAutomationName(obj:IAutomationObject):String
    {
        if (!obj)
            return null;

        var result:Object = createIDPart(obj);
        return result.automationName;
    }

    /**
     *  @private
     */
    public function getAutomationClassName(obj:IAutomationObject):String
    {
        if (!obj)
            return null;
       
  	   if(automationEnvironment)
        {
			var automationClass:IAutomationClass = 
            	automationEnvironment.getAutomationClassByInstance(obj);
        
			return automationClass ? automationClass.name : null;
        }
        else
        	return null;
    }

    /**
     *  @private
     */
    public function getProperties(obj:IAutomationObject, 
                                  names:Array = null, 
                                  forVerification:Boolean = true, 
                                  forDescription:Boolean = true):Array
    {
        if (!obj)
            return null;

        try
        {
            incrementCacheCounter();

			// in the marshalle application if the tool libraries have not
			// handled the requriemetns all applications will not be getting the 
			// env details.
			if(!automationEnvironment)
				return null;
			
            var automationClass:IAutomationClass =
                automationEnvironment.getAutomationClassByInstance(obj);
            var propertMap:Object = automationClass.propertyNameMap;
            var i:int;
            var result:Array = [];
            if (!names)
            {
	            var propertyDescriptors:Array = 
	                automationClass.getPropertyDescriptors(obj, 
	                                                    forVerification, 
	                                                    forDescription);
                names = [];
                for (i = 0; i < propertyDescriptors.length; i++)
                {
                    names[i] = propertyDescriptors[i].name;
                }
            }
            var part:Object = createIDPartForSpecifiedProperties(names,obj as IAutomationObject);
            for (i = 0; i < names.length; i++)
            {
                var propertyDescriptor:IAutomationPropertyDescriptor = 
                    propertMap[ names[i] ];
                var value:Object = (propertyDescriptor 
                                    ? getPropertyValueFromPart(part,obj, propertyDescriptor)
                                    : null);
                //don't convert to String, testing tools want it 
                //delivered in the correct type
				
				
                result.push(value);
            }
            
            decrementCacheCounter();
        }
        catch(e:Error)
        {
            decrementCacheCounter();
            
            throw e;
        }

        return result;
    }

    /**
     *  @private
     */
    public function getTabularData(obj:IAutomationObject):IAutomationTabularData
    {
        return obj.automationTabularData as IAutomationTabularData;
    }

    /**
     *  @private
     */
    public function replayAutomatableEvent(event:AutomationReplayEvent):Boolean
    {
        var re:AutomationReplayEvent = event as AutomationReplayEvent;
        
       // check the recorded line count whether it is the max allowed limit 	
       var recordedLinesCount:Number=  Automation.incrementRecordedLinesCount();
       var licencePresent:Boolean = Automation.isLicensePresent();
       if((recordedLinesCount > Automation.recordReplayLimit ) && (licencePresent == false))
       {
       	 _replaying = false;
       	if(Automation.errorShown == false)
       	{
       		var warningMessage:String = resourceManager.getString(
					"automation_agent", "replayLimitReached");
					
          	Alert.show( warningMessage );
      		Automation.errorShown = true;
      	}
        return false;

       }
       
		// required to make MouseMove work
        if (re.replayableEvent is MouseEvent || 
            ("triggerEvent" in re.replayableEvent && 
            re.replayableEvent["triggerEvent"] is MouseEvent))
        {
            var evDispatcher:IEventDispatcher = re.automationObject as IEventDispatcher;
            var rollOver:MouseEvent = new MouseEvent(MouseEvent.ROLL_OVER, false);
            replayMouseEventInternal(evDispatcher, rollOver);
            var mouseOver:MouseEvent = new MouseEvent(MouseEvent.MOUSE_OVER);
            replayMouseEventInternal(evDispatcher, mouseOver);
        }
        
        if (! isVisible(re.automationObject as DisplayObject))
		{
            var message:String = resourceManager.getString(
				"automation_agent", "notVisible",
				[re.automationObject.automationName]);
			throw new AutomationError(message,
									  AutomationError.OBJECT_NOT_VISIBLE);
		}
        
        pushMouseSimulator(re.automationObject, 
                           re.replayableEvent);
        _replaying = true;
        var uiObject:IAutomationObject = re.automationObject as IAutomationObject;
        if (uiObject && !(uiObject.automationVisible && uiObject.automationEnabled))
        {
            re.succeeded = false;
        }    
        else
        { 
            re.succeeded = re.automationObject.replayAutomatableEvent(re.replayableEvent);
        }
        _replaying = false;
        popMouseSimulator();

        return dispatchEvent(re);
    }
	
    /**
     *  @private
     *
     */
     // commented out the sandbox mouse events as it was causing the event overflow when we have the air window
     // in the application. Found all the trial cases worked even without that. when we face an issue we need to
     // analyse the WindowedSystemManager -> System Manager otherSystemManagerMouseListener sequence to analyse the
     // event overflow reason.
    public  function beginRecording():void
    {   
        if (!recording)
        {
            _recording = true;
                     
            sm1.addEventListener(AutomationRecordEvent.RECORD,
            						recordHandler, false, EventPriority.DEFAULT_HANDLER, true);
            sm1.getSandboxRoot().addEventListener(MouseEvent.MOUSE_DOWN,
                                captureIDFromMouseDownEvent, true, 0, true);
                                
            //sm1.getSandboxRoot().addEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,
             //                   captureIDFromMouseDownEvent, true, 0, true);
            sm1.addEventListener(KeyboardEvent.KEY_DOWN,
                                captureIDFromKeyDownEvent, true, 0, true);
            //ideally we would listen in the bubble phase so
            //we'd get this last and all components have had a chance
            //to react and record events, but some components are stopping
            //the propagation so capture first and flush events
            //in a delayed manner
            sm1.getSandboxRoot().addEventListener(MouseEvent.CLICK,
                                onEndMouseSequence, true, 0, true);
            sm1.getSandboxRoot().addEventListener(MouseEvent.DOUBLE_CLICK,
                                onEndMouseSequence, true, 0, true);
                                
           	//sm1.getSandboxRoot().addEventListener(SandboxMouseEvent.CLICK_SOMEWHERE,
                               // onEndMouseSequence, true, 0, true);
           // sm1.getSandboxRoot().addEventListener(SandboxMouseEvent.DOUBLE_CLICK_SOMEWHERE,
                               // onEndMouseSequence, true, 0, true);
                                
            sm1.addEventListener(KeyboardEvent.KEY_UP,
                                onEndKeySequence, true, 0, true);
            //Ideally we'd flush events after the last click (or double click)
            //however the player has a bug where it doesn't always send click
            //events (and also there can be legitimate times when a click
            //event won't come through, souch as a mouse down, mouse move off 
            //the component then a mouse up), so do a timed flush after the
            //mouse up (it needs to be after any click events that might occur)
            sm1.getSandboxRoot().addEventListener(MouseEvent.MOUSE_UP,
                                onEndMouseSequence, true, 0, true);
            //sm1.getSandboxRoot().addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,
                                //onEndMouseSequence, true, 0, true);
			sm1.getSandboxRoot().addEventListener(FocusEvent.KEY_FOCUS_CHANGE, keyFocusChangeHandler, false, 0, true);
			
            dispatchEvent(new AutomationEvent);
            
            // if we are the top level automation Manager, we should have recieved this call.
            // we need to inform other managers about this record starting
           if(sm1.isTopLevelRoot())
           {
	        	var beginRecordMarshalledEvent:MarshalledAutomationEvent = new MarshalledAutomationEvent
	        		(MarshalledAutomationEvent.BEGIN_RECORDING);
	        	dispatchMarshalledEventToSubApplications(beginRecordMarshalledEvent);
           }
        }
    }
    
    /**
     *  @private
     */
    public function endRecording():void
    {
        if (recording)
        {
            _recording = false;
            
            dispatchEvent(new AutomationEvent(AutomationEvent.END_RECORD));
            
            sm1.removeEventListener(AutomationRecordEvent.RECORD,
            					   recordHandler);
            sm1.getSandboxRoot().removeEventListener(MouseEvent.MOUSE_DOWN,
                                   captureIDFromMouseDownEvent, true);
            sm1.getSandboxRoot().removeEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,
                                   captureIDFromMouseDownEvent, true);
            sm1.removeEventListener(KeyboardEvent.KEY_DOWN,
                                   captureIDFromKeyDownEvent, true);
            sm1.getSandboxRoot().removeEventListener(MouseEvent.CLICK,
                                   onEndMouseSequence, true);
            sm1.getSandboxRoot().removeEventListener(MouseEvent.DOUBLE_CLICK,
                                   onEndMouseSequence, true);
            sm1.getSandboxRoot().removeEventListener(MouseEvent.MOUSE_UP,
                                   onEndMouseSequence, true);
            sm1.getSandboxRoot().removeEventListener(SandboxMouseEvent.CLICK_SOMEWHERE,
                                   onEndMouseSequence, true);
            sm1.getSandboxRoot().removeEventListener(SandboxMouseEvent.DOUBLE_CLICK_SOMEWHERE,
                                   onEndMouseSequence, true);
            sm1.getSandboxRoot().removeEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,
                                   onEndMouseSequence, true);                       
            sm1.removeEventListener(KeyboardEvent.KEY_UP,
                                   onEndKeySequence, true);

            clearHierarchyCache();
            clearEventCache();

            recordedEventInCurrentMouseSequence = false;
            inMouseSequence = false;
        }
    }

	public function getElementFromPoint2(x:int, y:int,windowId:String ):IAutomationObject
	{
		var stage:Stage = getAIRWindow(windowId).stage;
		return getElementFromPointOnRequiredWindow(x,y,stage);
	}
	
	private function getElementFromPointOnRequiredWindow(x:int, y:int, requiredStage:Stage):IAutomationObject
	{
		var o:Array = requiredStage.getObjectsUnderPoint(new Point(x, y));
        for (var i:int = o.length - 1; i >= 0; i--)
        {
            var displayObject:DisplayObject = o[i];
            while (displayObject != null)
            {
                // don't use showInHierarchy because that would prevent
                // checkpoints on things like boxes
                var delegate:IAutomationObject = (displayObject as IAutomationObject);
                if (delegate &&
                    // check that it's an IAutomationObject before
                    // checking visible since some components
                    // such as stage (which aren't IAutomationObjects)
                    // will yell and shout if you call visible on them
                    displayObject.visible)
                {
                	var obj:IAutomationObject ;
                	if(isAutomationComposite(delegate))
                		obj = getAutomationComposite(delegate);
                	else
                		obj = delegate;

                	return obj;
                }
                
                displayObject = displayObject.parent;
            }
        }
        return null;
	}
    /**
     *  @private
     */
    public function getElementFromPoint(x:int, y:int):IAutomationObject
    {
		//use the stage, not the system manager to find elements
		//because popups do not appear as children of the system manager
		//and so things like alerts wouldn't be found
        var stage:Stage = Automation.getMainApplication().stage;
      	return getElementFromPointOnRequiredWindow(x,y,stage);
    }

    /**
     *  @private
     */
    public function getRectangle(obj:DisplayObject):Array
    {
		var p:Point = new Point(0,0);
		p = obj.localToGlobal(p);
		// it was observed that the start points and the width and height are getting as
		// non interger values, which makes those values as zero at the other end.
		// so we are converting to the near int and passing.
        return [int(p.x), int(p.y),int( p.x + obj.width), int(p.y + obj.height)];
    }
    
    /**
     *  @private
     */
    public function isVisible(obj:DisplayObject):Boolean
    {
        while (obj && obj != obj.root && obj != obj.stage)
        {
            if (!obj.visible)
                return false;
            obj = obj.parent;
        }
        return true;
    }

    /**
     *  @private
     */
    private function getDistanceFromOriginalEvent(event:AutomationRecordEvent):int
    {
        var distance:int = 0;
        var displayObject:DisplayObject = cachedTargetOriginator as DisplayObject;
        
        while (displayObject != null && displayObject != event.automationObject)
        {
            ++distance;
            displayObject = displayObject.parent;
        }
        
        return displayObject == event.automationObject ? distance : int.MAX_VALUE;
    }

    /**
     *  @private
     */
    public function onEndKeySequence(event:KeyboardEvent):void
    {
/* 		if (flushCachedEvents() == null)
	        onFinishEventSequence();

        inMouseSequence = false;
 */    }
    
    /**
     *  @private
     */
    public function onEndMouseSequence(event:Event):void
    {
    	if (flushCacheTimeoutID != -1)
			clearTimeout(flushCacheTimeoutID);
		
		if(event.type == MouseEvent.MOUSE_UP || event.type == SandboxMouseEvent.MOUSE_UP_SOMEWHERE ||
		 event.type == SandboxMouseEvent.CLICK_SOMEWHERE)
			rebuildPartCache = true;
		
        // we're in the capture phase of mouse up sometimes,
        // so put in the timeout in either case.  so don't try
        // to optimize by checking eventCache.length
        flushCacheTimeoutID = setTimeout(endMouseSequence, 
                                         event.type == MouseEvent.MOUSE_UP || 
                                         event.type == SandboxMouseEvent.MOUSE_UP_SOMEWHERE ||
                                          event.type == SandboxMouseEvent.CLICK_SOMEWHERE ? 500 : 1);
    }
    
    /**
     *  @private
     */
    protected function keyFocusChangeHandler(event:FocusEvent):void
    {
         var focusTarget:Object = event.target;
	    // check whether the focus target is from the same application
	    // else do not record this event
	    // we want to avoid the recording of the bubbled event from other applications
	    if(focusTarget.root != sm1)
	    	return;
	    
	
	    var dispatcher:IAutomationObject = null;
		if(Automation.getMainApplication() is IAutomationObject)
			dispatcher = IAutomationObject(Automation.getMainApplication());
	 	
       	var ao:IAutomationObject = (focusTarget as IAutomationObject);
	    if (ao)
	        dispatcher = (getAutomationComposite(ao) || ao);
	  
	    recordAutomatableEvent(dispatcher, event);
    }   

    /**
     *  @private
     */
    private function endMouseSequence():void
    {
		if (flushCacheTimeoutID != -1)
		{
			clearTimeout(flushCacheTimeoutID);
			flushCacheTimeoutID = -1;
        }

		if (flushCachedEvents() == null)
	        onFinishEventSequence();

        inMouseSequence = false;
    }

    /**
     *  @private
     * 
     *  This is only public because the test harness needs to call this
     *  due to a bug in the player.  No one should call this.
     */
    public function flushCachedEvents():Event
    {
		var event:AutomationRecordEvent;

        if (eventCache.length > 0)
        {
            var closestEvents:Array = [];
            var closestDistance:int = int.MAX_VALUE;
            
            for (var i:int = 0; i < eventCache.length; ++i)
            {
                event = eventCache[i];
                var distance:int = getDistanceFromOriginalEvent(event);

                if (distance < closestDistance)
                {
				    closestDistance = distance;
                    closestEvents = [];
                    closestEvents.push(event);
                }
                else if (distance == closestDistance)
                {
                    closestEvents.push(event);
                }
            }
                
            if (closestEvents.length > 0)
            	event = closestEvents[0];
        }

		if (event != null)
		{
        	dispatchRecordEvent(event, true);
        	
        	  // at this place we record a new line hence increment the counter
        	  // since this happened with a previous decrement, we need not check the
        	  // boundary conditions
        	  var recordedLinesCount:Number= Automation.incrementRecordedLinesCount();
  		}

		return event;
    }

    /**
     *  @private
     */
    public function resolveIDToSingleObject(rid:AutomationID, 
                                            currentParent:IAutomationObject = null):IAutomationObject
    {
        
		var childArray:Array = resolveID(rid, currentParent);
        
        var message:String;
		
		if (childArray == null || childArray.length == 0)
		{
			message = resourceManager.getString(
				"automation_agent", "idNotResolved", [rid.toString()]);
            throw new AutomationError(message,
									  AutomationError.OBJECT_NOT_FOUND);
		}

        if (childArray.length > 1)
        {
            message = resourceManager.getString(
				"automation_agent", "matchesMsg", [childArray.length,
				rid.toString().replace(/\n/, ' ')]) + ":\n"; 

            for (var i:int = 0; i < childArray.length; i++)
			{
                message += AutomationClass.getClassName(childArray[i]) + 
						   "(" + childArray[i].automationName + ")\n";
			}

            throw new AutomationError(message,
									  AutomationError.OBJECT_NOT_UNIQUE);
        }
        return (childArray[0] as IAutomationObject);
    }
    
    private function isApplication(part:AutomationIDPart):Boolean
    {
    	// for Air we have top level parents which are notapplications
    	// they will be of the class 
    	// TBD this is just for prototype. This will not work if the user
    	// has extended the Window class
    	/*if(part["className"] == "mx.core.Window")
    		return true;*/
    		
    	if(part.hasOwnProperty(AutomationManager.airWindowIndicatorPropertyName))
    		return true;
    			
		if(scoreChild((Automation.getMainApplication() as IAutomationObject), part,true) >= 0)
			return true;
		
		return false;
    }

    /**
     *  @private
     */
    public function resolveID(rid:AutomationID, 
                              currentParent:IAutomationObject = null):Array
    {
    	var part:AutomationIDPart;
        var id:AutomationID = rid.clone();
		var message:String;
        if (currentParent == null)
        {
	        //remove the application
	        part = id.removeFirst();
	        if (!isApplication(part))
			{
				message = resourceManager.getString(
					"automation_agent", "rootApplication",[ id.toString()]);
	            throw new AutomationError(message,
	                                      AutomationError.ILLEGAL_RUNTIME_ID);
			}
	
			// check for the AIR window.we can get the current parent as null even for 
			// window object
			if (part.hasOwnProperty(AutomationManager.airWindowIndicatorPropertyName))	
        	{
        		// get the automationName
        		//var currentAutomationName:String = part["automationName"];
        		var currentAutomationName:String = getPassedUniqueName(part);
        		currentParent = getAIRWindow(currentAutomationName) as IAutomationObject;
        	}
        	else
            	currentParent = (Automation.getMainApplication() as IAutomationObject);
        }

        var result:Array = null;
        var currentChildArray:Array = [currentParent];
        
        while (true)
        {
            if (id.isEmpty())
            {
                result = currentChildArray;
                break;
            }

            // contains part for resolving
            part = id.removeFirst();

            // child found by resolving
            currentChildArray = currentParent.resolveAutomationIDPart(part);
            
            //check for nothing found
            if (currentChildArray.length == 0)
            {
				//null results are legal on the last node for regex searches
				//because it just means there was no match, but not legal
				//when still traversing the parent nodes
				if (!id.isEmpty())
				{
					message = resourceManager.getString(
						"automation_agent", "notResolved", [part.automationName,
						part.className, currentParent.automationName]);
	                throw new AutomationError(message,
	                                          AutomationError.OBJECT_NOT_FOUND);
				}
            }
			else
			{
	            //check for too many parents found
	            if (currentChildArray.length > 1 && !id.isEmpty())
				{
	                message = resourceManager.getString(
						"automation_agent", "matchesMsg",
						[currentChildArray.length, part.toString()]);
					throw new AutomationError(message,
	                                          AutomationError.OBJECT_NOT_UNIQUE);
				}

	            //check for parent = child
	            if (currentChildArray[0] == currentParent)
				{
					message = resourceManager.getString(
						"automation_agent", "resolvedTo",
						[currentParent, currentChildArray[0]]);
	                throw new AutomationError(message,
	                                          AutomationError.ILLEGAL_OPERATION);
				}

	            //traverse into the next parent
	            if (currentChildArray[0].numAutomationChildren > 0)
	                currentParent = currentChildArray[0] ;
	            //check for nothing found
	            else if (!id.isEmpty())
				{
					message = resourceManager.getString(
						"automation_agent", "idResolved",[ id.toString()]);
	                throw new AutomationError(message,
	                                          AutomationError.ILLEGAL_RUNTIME_ID);
				}
			}
        }
        return result;
    }

    /**
     *  @private
     */
    public function resolveIDPartToSingleObject(parent:IAutomationObject,
                                                part:AutomationIDPart):IAutomationObject
    {
        var rid:AutomationID = new AutomationID();
        rid.addFirst(part);

        return resolveIDToSingleObject(rid, parent);
    }

    /**
     *  @private
     */
    public function resolveIDPart(parent:IAutomationObject,
                                  part:AutomationIDPart):Array
    {
        var rid:AutomationID = new AutomationID();
        rid.addFirst(part);

        return resolveID(rid, parent);
    }

    /**
     *  @private
     */
	public function createID(obj:IAutomationObject, 
                             relativeToParent:IAutomationObject = null):AutomationID
	{
        var result:AutomationID = new AutomationID();
        
        if (obj == relativeToParent)
        	return result;
        
        do 
        {
            //if relativeToParent is not in the hiearchy, then we need to do a special
            //getParent so that we don't skip this parent
            var parent:IAutomationObject = 
                getParent(obj, relativeToParent, true);
            // use the real parent for creating child ids
            var part:AutomationIDPart = createIDPart(obj, parent);
            result.addFirst(part);

            // respect showInHierarchy when walking parent chain
            obj = getParent(obj, relativeToParent);
            
            if (obj == relativeToParent)
                break;
        } while (obj);
        return result;
	}

    /**
     *  @private
     */
    public function createIDPart(obj:IAutomationObject, 
                                 parent:IAutomationObject = null):AutomationIDPart
    {
        if (parent == null)
            parent = getParent(obj, null, true);

        var part:AutomationIDPart = (cachedParts 
                                     ? cachedParts[obj] as AutomationIDPart
                                     : null);

        if (!part)
        {
            part = (parent 
                    ? parent.createAutomationIDPart(obj) as AutomationIDPart
                    : helpCreateIDPart(null, obj));
                    
            if (hierarchyCacheCounter > 0)
                cachedParts[obj] = part;
        }

        return part;
    }
    
    /**
     *  @private
     */
    public function showInHierarchy(obj:IAutomationObject):Boolean
    {
        return  obj == null || 
                !(obj is IAutomationObject) ||
                (!isAutomationComposite(obj) && obj.showInAutomationHierarchy);
    }

    /**
     *  @private
     *
     *  Helper implementation of IAutomationIDHelper.  Resolves an id based 
     *  on a set of properties.  This should not be used, instead use 
     *  resolveID, resolveIDToSingleObject, or resolveIDPart.
     */
    public function helpResolveIDPart(parent:IAutomationObject,
                                      partObj:Object):Array
    {
    	var part:AutomationIDPart = partObj as AutomationIDPart;
    	if(!part)
    		return [];
        //        trace("--- searching for child [" + ObjectUtil.toString(part) +
        //              "] in parent [" + parent.automationName + "]");
        
        //Because resolving can be delegated to a child composite
        //we need to ignore hierarchy.  An example is
        //ComboBox composites List.  List will call helpResolveIDPart
        //but will appear to have no children since it's not in the
        //hierarchy, so pass true to getChildren to ignore showInHierarchy
        //Note that resolving off ComboBox instead of List would
        //not be appropriate since ComboBox may have other children (such
        //as edit propertyName or button)
        var children:Array = getChildren(parent, true);
		var winners:Array  = getWinners(children,part,false);
		if(winners.length > 1)
			winners = getWinners(children,part,true);
        return winners;
    }

	/**
	 *  @private
	 *
	 */
	 private function getWinners(children:Array, part:AutomationIDPart,forceIndexCalculation:Boolean):Array
	 {
		 //Because resolving can be delegated to a child composite
		 //we need to ignore hierarchy.  An example is
		 //ComboBox composites List.  List will call helpResolveIDPart
		 //but will appear to have no children since it's not in the
		 //hierarchy, so pass true to getChildren to ignore showInHierarchy
		 //Note that resolving off ComboBox instead of List would
		 //not be appropriate since ComboBox may have other children (such
		 //as edit propertyName or button)
		 var winners:Array = [];
		 var bestScore:int = -1;
		 for (var i:int = 0; i < children.length; i++)
		 {
			 var child:IAutomationObject = children[i]; 
			 /*
			 if (!child)
			 {
			 var message:String = resourceManager.getString(
			 "automation_agent", "nullReturned",
			 [i, parent.automationName, children.length]);
			 throw new Error(message);
			 }
			 */
			 // we are commenting out the checks above for the following reason
			 // this check stops the automation of the application if any cheild of the application
			 // is null. Initially since the automation framework was supporting only flex, all components
			 // by default will be inheriting IAutomationObject. But when the flash-flex compoenets got added
			 // to the application, it broke the automation of other flex components also because of this check.
			 // reason: flex-flash components were not implementing the IAutomationObjects and hence the components
			 // corresponding to that became null and hence the automation stopped.
			 // to avoid such a scenario we have commented out this check.
			 // and the flash-flex components are planning to be changed to implement this interface soon.
			 // till then the usage of this change will allow the users to continue with automation of other components.
			 
			 var score:int = -1;
			 if (child != null)
			 {
				 score = scoreChild(child, part,forceIndexCalculation);
			 }
			 
			 if (score == -1)
				 continue;
			 
			 // we are not processing all possible objects to match
			 // if we got an object with all the required properties of the part.
			 if(score == int.MAX_VALUE)
				 return [child];
			 
			 if (score > bestScore)
			 {
				 bestScore = score;
				 winners = [];
			 }
			 
			 if (score == bestScore)
				 winners.push(child);
		 }
		 
		 return winners;

	 }
    /**
     *  @private
     *
     *  Helper implementation of IAutomationIDHelper.  Creates an id for
     *  a given child.  This should not be used, instead use createID,
     *  or createIDPart.
     */
     
    public function helpCreateIDPart(parent:IAutomationObject,
                                     child:IAutomationObject,
                                     automationNameCallback:Function = null,
                                     automationIndexCallback:Function = null):AutomationIDPart
    {
        var part:AutomationIDPart = new AutomationIDPart();
        if(!automationEnvironment)
        	return part;
        	
        var automationClass:IAutomationClass =
            automationEnvironment.getAutomationClassByInstance(child);
        if(!automationClass)
        	return part;
        	
        var propertyDescriptors:Array = 
            automationClass.getPropertyDescriptors(child, false, true);

		if(!propertyDescriptors)
			return part;
			
		//It doesn't matter if a property is null
		//add it anyways, because the callee asked for it
		//and not adding it will confuse QTP since we've
		//told it already about the properties in the env file
		//If this causes a problem and we need to add the if
		//null checks back, then be sure to update QTPAdapter
		//to not return null properties in Learn and ActiveScreen

        for (var propNo:int = 0; propNo < propertyDescriptors.length; ++propNo)
        {
            var propertyName:String = propertyDescriptors[propNo].name;
            
            if (propertyName == "id")
            {
                part.id = child is IDeferredInstantiationUIComponent
                			? IDeferredInstantiationUIComponent(child).id
                			: null;    
               if ((part.id == null) && (parent == null))
               { 
               	   //trace ("inside the helpCreateIDPart - id "+ child.automationName);
	                // currently we are in the application object.
	                // this is a temp fix till we have AIR delegates in place.
	                // we need the application iD of this component instead of the id
	               	if(Automation.getMainApplication().hasOwnProperty("applicationID"))// this should work for AIR app's
					{
						part.id = Automation.getMainApplication().applicationID;
						 //trace ("inside the helpCreateIDPart - id "+ part.id );
					}
					else
					{
						//we are in flex app hosted from Air app
						part.id = processAppIDFromUniqueAppID();						
					}
               }
            }
            else if (propertyName == "automationName")
                part.automationName = (automationNameCallback == null 
                                       ? child.automationName 
                                       : automationNameCallback(child));
            else if (propertyName == "automationIndex")
				//note that parent can be null if it's the parentApplication
                part.automationIndex = (automationIndexCallback == null ? 
                				getChildIndex(getParent(child), child)
                				: automationIndexCallback(child));
            else if (propertyName == "className")
                part.className = AutomationClass.getClassName(child);
            else if (propertyName == "automationClassName")
                part.automationClassName = getAutomationClassName(child);
            else if (propertyName == AutomationManager.airWindowIndicatorPropertyName)
            {
            	// we added this property to identify the airtoplevel windows
            	part.isAIRWindow = true;
            }
            else
            {
                if (propertyName in child)
	                part[propertyName] = child[propertyName];
				else if (child is IStyleClient)
					part[propertyName] = IStyleClient(child).getStyle(propertyName);
	            else
				{
					var message:String = resourceManager.getString(
						"automation_agent", "notDefined", [propertyName, child]);
					traceMessage("AutomationManager", "helpCreateIDPart()", message);
                   // throw new Error(message);
				}
            }
        }

        if ("automationName" in part && ((part.automationName == null)||(part.automationName.length == 0)))
            part.automationName = part.automationIndex;
            
        return part;
    }
    
    private function processAppIDFromUniqueAppID():String
    {
    	var appId:String = getUniqueApplicationID();
    	var index:int = appId.lastIndexOf("_");
    	if(index != -1)
    	{
    		appId = appId.substring(index + 1, appId.length );
    	}
    	else
    	{
    		appId = null;
    	}
    	return appId;
    }
    
    /**
     *  @private
     */
    private function isClassAvailable(className:String):Boolean
    {
    	try
    	{
    		if(getDefinitionByName(className) != null)
    			return true;
    	}
    	catch(e:Error)
		{
			return false;
		}
		
		return false;
    }

    /**
     * Dispatch the event as a replayable event.  Causes the 
     * ReplayableEventEvent with REPLAYABLE_EVENT type to be fired.  
     * However, this method will not attempt the dispatch if there are no 
     * listeners.
     *
     * @param eventReplayer The IEventReplayer dispatching this 
     *                            event since event.target may not be 
     *                            accurate
     * @param event The event that represents the replayable event.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
     *  @playerversion AIR 1.1
     *  @productversion Flex 3
     */
    public function recordAutomatableEvent(recorder:IAutomationObject, event:Event,
                                           cacheable:Boolean = false):void
    {
    	// this method should not get called with null event.
    	// However during some usage of the events being dispatched programmatically
    	// the trigger events may be null and the record of the same is called with the
    	// null. Eventhough this is not the expected way of usage, a check is added.
    	if (event == null)
       		return;
       		
        if (!recording)
        	return;
        	
		var message:String;
        	
        var re:AutomationRecordEvent;
        if (event is AutomationRecordEvent)
        	re = event as AutomationRecordEvent;
        else
        {
        	re = new AutomationRecordEvent(AutomationRecordEvent.RECORD);
		    re.automationObject = recorder;
    		re.replayableEvent = event;
        	re.cacheable = cacheable;
        }
        	
		//swallow orphan clicks when not following a mouseDown
		if (re.replayableEvent.type == MouseEvent.CLICK && !inMouseSequence)
			return;

		// in the marshalled application if the tool libraries have not
		// handled the requriemetns all applications will not be getting the 
		// env details.
		if(!automationEnvironment)
				return ;
				
        var automationClass:IAutomationClass = 
                automationEnvironment.getAutomationClassByInstance(re.automationObject as IAutomationObject);

         if (automationClass == null)
		 {
			  message = resourceManager.getString(
			      "automation_agent", "classNotFound",
				  [AutomationClass.getClassName(re.automationObject)]);
              throw new Error(message);
		 }

         var eventDescriptor:IAutomationEventDescriptor =
               automationClass.getDescriptorForEvent(re.replayableEvent);

         if (eventDescriptor == null)
		 {
			   message = resourceManager.getString(
			       "automation_agent", "methodNotFound",
				   [AutomationClass.getClassName(re.replayableEvent),
				   automationClass]); 
               throw new Error(message);
		 } 
                
         re.name = eventDescriptor.name;
         re.args = eventDescriptor.record(re.automationObject, re.replayableEvent);

 		// check the recorded line count whether it is the max allowed limit 	
       var recordedLinesCount:Number=  Automation.incrementRecordedLinesCount();
       var licencePresent:Boolean = Automation.isLicensePresent();
       if((recordedLinesCount > Automation.recordReplayLimit ) && (licencePresent == false))
       {
      	endRecording();
      	
      	  var warningMessage:String = resourceManager.getString(
					"automation_agent", "recordLimitReached");
					
          Alert.show( warningMessage );
         return;
 
       }
       	
       	// if the components are part of the Popup winodws (e.g Alert and objects
       	// hosted by the popUpManager and if they belong to the non root applicaiotn
       	// they are hosted by the main application. So it looks like the events dispatched on
       	// them does not reach the appropriate application. So to handle the special case,
       	// we directly call the record Handler.
       	 if(isObjectChildOfSystemManagerProxy (re.automationObject) )
       	 	recordHandler(re);
       	 	
       	 if(getQualifiedClassName(re.automationObject) == "mx.controls::FlexNativeMenu")
       	 	recordHandler(re);
         if (re.bubbles && re.automationObject is IEventDispatcher)
		 	IEventDispatcher(re.automationObject).dispatchEvent(re);
		 else
			recordHandler(re);
    }
    
     /**
     *  @private
     */
    public function isObjectChildOfSystemManagerProxy(automationObject:IAutomationObject):Boolean
	{
		var obj:DisplayObject = automationObject as DisplayObject;
		if(obj == null)	//this happens for FlexNativeMenu in AIR as it is not a DisplayObject
			return false;
		if(obj.parent == null)
		{
			// when the focus of the popup objects are taken to some other application
			// it is obsreverd that the parent is becoming null.
			// dont know whether it is an issue with sdk.
			// however since we have the list of poppup objects applicable to us
			// we can check in that.
			if((lastRemovedpopUpObject == automationObject as DisplayObject ) || (popUpObjects.indexOf(obj) != -1))
				return true;

		}
		
		while(obj.parent)
		{
			if(obj.parent is SystemManagerProxy)
				return true;
			obj = obj.parent;

		}
		return false;
	}   
     
    /**
     *  @private
     */
    public function isObjectPopUp(automationObject:IAutomationObject):Boolean
	{
		var obj:DisplayObject = automationObject as DisplayObject;
		if(obj == null) //this happens for FlexNativeMenu in AIR as it is not a DisplayObject
			return false;
		if(obj.parent == null)
		{
			// when the focus of the popup objects are taken to some other application
			// it is obsreverd that the parent is becoming null.
			// dont know whether it is an issue with sdk.
			// however since we have the list of poppup objects applicable to us
			// we can check in that.
			if((lastRemovedpopUpObject == automationObject as DisplayObject ) || (popUpObjects.indexOf(obj) != -1))
				return true;

		}
		// we need to find out whether the object belongs to the system manager before it belongs to an application
		// this is also needed to find the popups from the main application.
		var applicationFound:Boolean = (obj is Application || isSparkApplication(obj))?true:false;
		while(obj.parent)
		{
			if(obj.parent is SystemManagerProxy)
				return true;
			else
			{
				if(obj.parent is Application || isSparkApplication(obj.parent))
					applicationFound = true;
				else if ((obj.parent == sm1)&&(!applicationFound))
					return true;
			}

			obj = obj.parent;

		}
		return false;
	}   
    
    /**
     *  @private
     */
    public function recordHandler(te:Event):void
	{
		var re:AutomationRecordEvent = te as AutomationRecordEvent;
		if(re == null)
			return;
		if (re.isDefaultPrevented())
		{
			
			// decrement the recording counter 
        	// as the recording does not happen here
        	var recordedLinesCount1:Number= Automation.decrementRecordedLinesCount();
			return;
		}

        if (!isAutomationComposite(re.automationObject))
        {
            if (re.cacheable && cachingEvents)
            {
                eventCache.push(re);
	            // decrement the recording counter 
	        	// as the recording does not happen here
	        	var recordedLinesCount2:Number= Automation.decrementRecordedLinesCount();
            }
            else
                dispatchRecordEvent(re, false);
        }
        else
        {
        	// decrement the recording counter 
        	// as the recording does not happen here
        	  var recordedLinesCount3:Number= Automation.decrementRecordedLinesCount();
        }
    }

    /**
     *  @private
     */
    public function addSynchronization(isComplete:Function,
                                       target:Object = null):void
    {
        synchronization.push({isComplete: isComplete, target: target });
    }

    /**
     *  @private
     */
    public  function isSynchronized(target:IAutomationObject):Boolean
    {
        for (var i:int = 0; i < synchronization.length; i++)
        {
            if (synchronization[i].isComplete())
                 synchronization.splice(i--, 1);
            else if (target == synchronization[i].target || 
            		(target && target == synchronization[i].target) ||
            		 synchronization[i].target == null)
                return false;
            }
        return true;
    }

    /**
     *  @private
     */ 
    public function getMemberFromObject(obj:Object, 
                                        name:String):Object
    {
    	var part:Object;
    	var component:Object;

        part = createIDPart(obj as IAutomationObject);
        component = obj;
	    	
        var result:Object = null;

        if (part != null && name in part)
            result = part[name];
        else if (name in obj)
            result = obj[name];
        else if (component != null)
        {
        	if (name in component)
	            result = component[name];
    	    else if (component is IStyleClient)
        	    result = IStyleClient(component).getStyle(name);
        }
       
        return result;
    }
    
    /**
     *  @private
     */
    public function getPropertyValue(obj:Object, 
                                     pd:IAutomationPropertyDescriptor,
                                     relativeParent:IAutomationObject = null):Object
    {
        return getMemberFromObject(obj, pd.name);
    }

	//--------------------------------------------------------------------------
	//
    //  Mouse simulator methods
    //
	//--------------------------------------------------------------------------

    /**
     *  @private
     */
    public function getMouseX(item:DisplayObject):Number
    {
        return item.globalToLocal(_currentMousePositions[_currentMousePositions.length - 1]).x;
    }

    /**
     *  @private
     */
    public function getMouseY(item:DisplayObject):Number
    {
        return item.globalToLocal(_currentMousePositions[_currentMousePositions.length - 1]).y;
    }

    /**
     *  @private
     */
    private function replayMouseEventInternal(target:IEventDispatcher, event:MouseEvent):Boolean
    {
		//feed mouseOut and rollOut events to the last-clicked object, for defocussing purposes.		
		if (lastMouseTarget && lastMouseTarget != target)
		{
			var sendMouseEvents:Boolean = true;
			// check whether the new target is child of the last target.
			// if it is a child we should not send mouseOut, rollOut events
			if(lastMouseTarget is DisplayObjectContainer && target is DisplayObject)
			{
				if(DisplayObjectContainer(lastMouseTarget).contains(target as DisplayObject))
				{
                    // make the inner most component as the last target.
                    // should we have a stack of these inner components
                    // so that we can playback rollOut for all of them?
					lastMouseTarget = target;
					sendMouseEvents = false;
				}
				
			}
			if(sendMouseEvents)
			{
				var mouseOut:MouseEvent = new MouseEvent(MouseEvent.MOUSE_OUT);
				var rollOut:MouseEvent = new MouseEvent(MouseEvent.ROLL_OUT, false);
				lastMouseTarget.dispatchEvent(mouseOut);
				lastMouseTarget.dispatchEvent(rollOut);
				lastMouseTarget = target as IEventDispatcher;
			}
		}

		if(!lastMouseTarget)
			lastMouseTarget = target as IEventDispatcher;

        return target.dispatchEvent(event);
    }

    private static var fakeMouseX:QName = new QName(mx_internal, "_mouseX");
    private static var fakeMouseY:QName = new QName(mx_internal, "_mouseY");

    /**
     *  @private
     */
    private function pushMouseSimulator(targetObj:Object, eventObj:Object):void
    {
        var target:DisplayObject = (targetObj is DisplayObject 
                                    ? DisplayObject(targetObj) 
                                    : null);
        var event:MouseEvent = (eventObj is MouseEvent 
                                ? MouseEvent(eventObj) 
                                : null);
        
        var pt:Point = (event != null 
                        ? new Point(event.localX, event.localY) 
                        : new Point(0, 0));

;
		
        pt = target != null ? target.localToGlobal(pt) : pt;

        _currentMousePositions.push(pt);
        _prevMouseTargets.push(target);
        
    
    	try
    	{
   			target.root[fakeMouseX] = pt.x;
   			target.root[fakeMouseY] = pt.y;
   		}
   		catch(e:Error)
   		{
			traceMessage("AutomationManager", "pushMouseSimulator()", AutomationConstants.invalidInAIR);
   		}
     
       
        Automation.mouseSimulator = this;
    }

    /**
     *  @private
     */
    private function popMouseSimulator():void
    {
        _currentMousePositions.pop();
		_prevMouseTargets.pop();
        var target:Object = _prevMouseTargets[_prevMouseTargets.length-1];
        if(target && target.root)
        {   
    	    try
	    	{
		        target.root[fakeMouseX] = _currentMousePositions[_currentMousePositions.length-1].x;
	    	    target.root[fakeMouseY] = _currentMousePositions[_currentMousePositions.length-1].y;
  	   		}
	   		catch(e:Error)
	   		{
				traceMessage("AutomationManager", "popMouseSimulator()", AutomationConstants.invalidInAIR);
	   		}
    	}
    	else
    	{
            //var sm:ISystemManager = Application.application.systemManager;
	        try
	    	{
	  			sm1[fakeMouseX] = undefined;
				sm1[fakeMouseY] = undefined; 		
			}
	   		catch(e:Error)
	   		{
				traceMessage("AutomationManager", "popMouseSimulator()", AutomationConstants.invalidInAIR);
	   		}
		
		
			if (!_currentMousePositions.length)
				Automation.mouseSimulator = null;
    	}
    }

	//--------------------------------------------------------------------------
	//
    //  Replay helper methods
    //
	//--------------------------------------------------------------------------

    /**
     *  @private
     */
    public function replayKeyboardEvent(to:IEventDispatcher, event:KeyboardEvent):Boolean
    {
        return replayKeyDownKeyUp(to, event.keyCode, event.ctrlKey, event.shiftKey);
    }
    
    /**
     *  @private
     */
    public function replayKeyDownKeyUp(to:IEventDispatcher,
                                       keyCode:uint,
                                       ctrlKey:Boolean = false,
                                       shiftKey:Boolean = false,
                                       altKey:Boolean = false):Boolean
	{		
		map(function(type:String):void
			{
				var event:KeyboardEvent = new KeyboardEvent(type);
				event.keyCode = keyCode;
				event.ctrlKey = ctrlKey;
				event.shiftKey = shiftKey;
				event.altKey = altKey;
				to.dispatchEvent(event);
			},
			KEY_CLICK_TYPES);
        
		return true;
	}    									

    /**
     *  @private
     */
    public function replayMouseEvent(target:IEventDispatcher, event:MouseEvent):Boolean
    {
        pushMouseSimulator(target, event);
    	replayMouseEventInternal(target, event);
        popMouseSimulator();
        
        return true;
    }
    
    /**
     *  @private
     */
    public function replayClick(to:IEventDispatcher, sourceEvent:MouseEvent = null):Boolean
    {
        sourceEvent = sourceEvent || new MouseEvent(MouseEvent.CLICK);

        pushMouseSimulator(to, sourceEvent);
       
    	map(function(type:String):void
    		{
                var localX:int = sourceEvent && !isNaN(sourceEvent.localX) ? sourceEvent.localX : 2;
                var localY:int = sourceEvent && !isNaN(sourceEvent.localY) ? sourceEvent.localY : 2;
                var event:MouseEvent = new MouseEvent(type, true, false, localX, localY);
                event.ctrlKey = sourceEvent.ctrlKey;
                event.shiftKey = sourceEvent.shiftKey;
                event.altKey = sourceEvent.altKey;
                event.buttonDown = (type == MouseEvent.MOUSE_DOWN);
    			replayMouseEventInternal(to, event);
    		},
    		MOUSE_CLICK_TYPES);

        popMouseSimulator();

        return true;
    }

    /**
     * @private
     */
    public function replayClickOffStage():Boolean
    {
    	var x:Number = Automation.getMainApplication().screen.left - 1000;
    	var y:Number = Automation.getMainApplication().screen.top - 1000;

		map(function(type:String):void
			{
				var event:MouseEvent = new MouseEvent(type);
				event.localX = x;
				event.localY = y;
				replayMouseEventInternal(
					IEventDispatcher(Automation.getMainApplication()), event);
			},
			MOUSE_CLICK_TYPES);
        return true;
    }

    /**
     *  @private
     *  The cache of IDParts and children cannot be maintained indefinetely because 
     *  they get stale as application state chagnes. Hence control is required over 
     *  the life of cache. The incrementCacheCounter and decrementCacheCounter
     *  APIs provide this control. The calls to these two APIs should be matched to maintian
     *  cache in a healthy state.
     */
    public function incrementCacheCounter():int
    {
        ++hierarchyCacheCounter;
        
        if (cachedParts == null)
        	cachedParts = new Dictionary();
        
        if (cachedChildren == null)
        	cachedChildren = new Dictionary();
        	
       	if(cachedCompositor == null)
       		cachedCompositor = new Dictionary();

        return hierarchyCacheCounter;
    }
    
    /**
     *  @private
     *  Takes a flag to force clear the cache.
     */
    public function decrementCacheCounter(clearNow:Boolean = false):int
    {
        if (clearNow || hierarchyCacheCounter < 1)
            hierarchyCacheCounter = 1;
        
        --hierarchyCacheCounter;
        
        if (hierarchyCacheCounter <= 0)
            clearHierarchyCache();
        
        return hierarchyCacheCounter;
    }
    
    /**
     *  @private
     *  Helper function to clear the cache contents.
     */
    private function clearHierarchyCache():void
    {
        hierarchyCacheCounter = 0;
        cachedParts = null;
        cachedChildren = null;
        cachedCompositor = null;
    }
    
    /**
     *  @private
     */
    private function clearEventCache():void
    {
        eventCache = [];
        cachingEvents = false;
        cachedTargetOriginator = null;
    }

    /**
     *  @private
     */
    private function dispatchRecordEvent(event:AutomationRecordEvent, 
                                         cacheable:Boolean = false):void
    {
        //the event is disqualifed if another event has already
        //been dispatched in the current mouse down, up, click sequence
		//should we limit this check to just cacheable event?  maybe not
		//but it may impact the text events that are cached
        if (!cacheable || !inMouseSequence || !recordedEventInCurrentMouseSequence)
		{
	        if (inMouseSequence)
	        {
				//Events that are recorded during a mouse sequence, but are
				//not from the same location of the current mouse target
				//do not count.  This is to avoid issues from text fields
				//that do their own event caching, dispatch events late
				//and look like they are part of the current mouse sequence
				//but aren't.  For example, in a datagrid, if a user clicks
				//on an editable item and types something, that typing is
				//queued, if they then click on another item, the text field
				//will flush the typing.  After that the data grid will record
				//a new item click.  We don't want to through that out because
				//text field did some caching.  They are unrelated.  Do this
				//check by looking seeing if the current target is on the path 
				//between cachedTargetOriginator and the root.
				//trace(event.methodName + " " + getDistanceFromOriginalEvent(event) + ", r:" + event.automationObject + ", ct:" + cachedTargetOriginator);
				if (getDistanceFromOriginalEvent(event) != int.MAX_VALUE)
		            recordedEventInCurrentMouseSequence = true;
	        }

			dispatchEvent(event);
		}

		//The cache should only be cleared when the last event has occurred 
		//as a result of a low-level interaction.  It's possible to dispatch
		//several non-cached events during a mouse sequence, such as drag scroll events
		if (cacheable || !inMouseSequence)
			onFinishEventSequence();
    }
    
   public function  recordCustomAutomationEvent(event:AutomationRecordEvent):Boolean
   {
   		if(!recording)
   			return false;
   			
   	 	if(event.type != AutomationRecordEvent.CUSTOM_RECORD)
   	 		return false;
   	 	
   	 	if(!event.automationObject)
   	 		return false;
   	 		
   	 	// create the AutomatioRecord event
   	 	var eventObj:AutomationRecordEvent = new AutomationRecordEvent( AutomationRecordEvent.RECORD,
   	 		event.bubbles,event.cancelable,event.automationObject,event.replayableEvent,
   	 		event.args,event.name,event.cacheable);
   	 	if(!eventObj.args)
   	 		eventObj.args = new Array();
   	 	if(!eventObj.name)
   	 		eventObj.name = "NoNamePassedByUser";
   	 	eventObj.recordTriggeredByCustomHandling = true;
   	 	
   	 	
   	 	//dispatch this new event
   	 	dispatchEvent(eventObj);
   	 	return true;
   }

    /**
     *  @private
     */
	private function onFinishEventSequence():void
	{
        rebuildPartCache = true;
	    clearEventCache();
    	decrementCacheCounter();
	}

    /**
     *  @private
     */
    private function getChildIndex(parent:IAutomationObject,
                                   child:IAutomationObject):String
    {
		//parent shouldn't be null, unless it's the parentApplication
		if (parent != null)
		{
	        parent = showInHierarchy(parent) ? parent : getParent(parent);
	        var parentsChildren:Array = getChildren(parent); 
	
	        for (var childNo:int = 0; childNo < parentsChildren.length; ++childNo)
	        {
	            if (child == parentsChildren[childNo])
	                return "index:" + childNo;
	        }
		}

        return "index:-1";
    }
 
    /**
     *  @private
     */
    private function captureIDFromMouseDownEvent(event:Event):void
    {
    	captureID(event);

        cachingEvents = true;
        cachedTargetOriginator = EventDispatcher(event.target);
        inMouseSequence = true;
        recordedEventInCurrentMouseSequence = false;
    }

    /**
     *  @private
     */
    private function captureIDFromKeyDownEvent(event:Event):void
    {
/*      captureID(event);

        cachingEvents = true;
        cachedTargetOriginator = EventDispatcher(event.target);
        inMouseSequence = true;
        recordedEventInCurrentMouseSequence = false;
 */    }
    
    /**
     *  @private
     */
    private function captureID(event:Event):void
    {
		if (flushCacheTimeoutID != -1)
			clearTimeout(flushCacheTimeoutID);

        //flush cached events because:
        //
        //a) sometimes there is no CLICK or DOUBLE_CLICK event
		//the events will only get flushed after a time out of about
		//500 MS.  It's possible for someone to mouse down before that
		//timeout so check to here to see if any events need to be flushed
		//
		//b) keyboard events are never involved in caching
		flushCachedEvents();

        if (rebuildPartCache)
        {
            //force the clear of the cache because even though
            //we match the increment here with a decrement after
            //an automation event is recorded, not all
            //low-level events will result in an automation
            //event being dispatched 
            decrementCacheCounter(true);
            incrementCacheCounter();

            var o:Object = event.target;
            while (o != null)
            {
                if (o is IAutomationObject)
                {
                    if (isAutomationComposite(o as IAutomationObject))
                        o = getAutomationComposite(o as IAutomationObject);
                    else
                        break;
                }
                else
                    o = DisplayObject(o).parent;
            }

            var obj:IAutomationObject = (o as IAutomationObject);
            while (obj)
            {
	            var ao:IAutomationObject = (obj as IAutomationObject);
				
				// Earlier we were just using automationOwner as parent which is different
				// from the parent we get while calculating id using createIdPart().
				// http://bugs.adobe.com/jira/browse/FLEXENT-1126
				// http://bugs.adobe.com/jira/browse/FLEXENT-1251
				// So using getParent() method here also which returns main application as
				// parent in special cases.
				var parent:IAutomationObject = getParent(obj, null, true);
				
				cachedParts[obj] = 
                    (parent ? parent.createAutomationIDPart(ao)
                     : helpCreateIDPart(null, ao));

                if(isAutomationComposite(ao))
                {
                	obj = getAutomationComposite(ao) as IAutomationObject;
                }
                else
                {
                	obj = parent;
                }
            }
            rebuildPartCache = false;
        }
    }

	
	/**
	 *  @private
	 */
	private var className2previousClassName:Object = {};
	
    /**
     *  @private
     */
    private function scoreChild(child:IAutomationObject,
                                part:Object,calculateIndexAnyway:Boolean):int
    {
		// this method is a very expensive method
		// which tries to find the score for the passed child with the
		// passed part.
		
		//get the properties to score against from getProperties
		//rather than introspecting the automation object
		//directly, this will get any cached values and ensure
		//we use the same logic for automationName
		
		// first let us check whether the automation class name is matching,
		// if not we can give a negative score and return.
		
		var propertyNames:Array = [];
		var automationIndexNeeded:Boolean = false;	
		
		var automationClassNameRequired:Boolean = false;
		var propertyName:String;
		for (propertyName in part)
		{
			if(propertyName  != "automationIndex")
			{
				if(propertyName == "automationClassName")
					automationClassNameRequired = true;
				else
					propertyNames.push(propertyName);
			}
			else
				automationIndexNeeded = true;
				
		}
		
		var n:int = 0;
		var i:int = 0;
		//special case automationClassName because it's not a real property
		//and we currently aren't putting it in the environment info so
		//helpCreateIDPart will not populate it even if you ask for it
		//because it has no descriptor
		// we can ignore the other properties, if this is not equal.
		var partPropertyValue:Object = null;
		if (automationClassNameRequired)
		{
			childPropertyValue = getAutomationClassName(child);
			partPropertyValue = part["automationClassName"];
			
			equal = comparePropertyValues(partPropertyValue, childPropertyValue);
			
			//if they are not equal it is possible that a script recorded in one version
			//is being used in another. So we check for compatible versions of this class
			if((!equal)&&(automationEnvironment))
			{
				var previousVersionClassNames:Array = className2previousClassName[childPropertyValue];
				
				if(	previousVersionClassNames == null)
				{
					// in the marshalled application if the tool libraries have not
					// handled the requriemetns all applications will not be getting the 
					// env details.
					var automationClass:IAutomationClass =
						automationEnvironment.getAutomationClassByInstance(child);
					
					if(automationClass is IAutomationClass2)
					{
						previousVersionClassNames = IAutomationClass2(automationClass).previousVersionClassNames;
						if(previousVersionClassNames == null)
							previousVersionClassNames = [];
						className2previousClassName[childPropertyValue] = previousVersionClassNames;
						
					}
				}
				n = previousVersionClassNames.length;
				for( i = 0; i < n; i++)
				{
					equal = comparePropertyValues(partPropertyValue, previousVersionClassNames[i]);
					if(equal)
						break;
				}
			}
		}
		
		if((!equal)&&(automationClassNameRequired))
		{
			// we can ignore the other properties, if this is not equal.
			score = -1;
			allEqual = false;
		}
		else
		{
			var childProperties:Array = getProperties(child, propertyNames);
			var childPropertyMap:Object = {};
			
			for (var childPropertyNo:int = 0; childPropertyNo < childProperties.length; ++childPropertyNo)
	        {
				childPropertyMap[propertyNames[childPropertyNo]] = childProperties[childPropertyNo];
	        }

            var score:int = 0;
	        var allEqual:Boolean = true;	
			var criticalPropertiesToMatch:Array=["automationIndex","automationClassName","className","automationName","id"];
			var criticalPropertiesMismatchFound:Boolean = false;
			var automationNameNeeded:Boolean = false;	
			
	        // iterate through part
	        for (propertyName in part)
	        {
	        	// calculating automation index is a very expensive process.
	        	// so we will delay it till all other required properties matches.
	        	if((propertyName.toLowerCase()  != "automationindex")&&(propertyName.toLowerCase()  != "automationclassname"))
	        	{
		        	var equal:Boolean;
					partPropertyValue = part[propertyName];
		            var childPropertyValue:Object = (propertyName in childPropertyMap)
		                                             ? childPropertyMap[propertyName] 
		                                             : null;
					
		            equal = comparePropertyValues(partPropertyValue, childPropertyValue);					
					if((!equal)&&(propertyName.toLowerCase()  == "automationname")&&((childPropertyValue=="")||(childPropertyValue==null)))
					{
						// in some components if the automationName is not specified, it is considered using the automationIndex.
						// since we are not creating automation index, we will leave it the benefit of doubt and will 
						// create it again when we are forming automation index.
						automationNameNeeded = true;
						equal = true;
					}


		            if (equal)
		            	++score;
		            else
					{
						// check what is not matching is not the critical property
						if(criticalPropertiesToMatch.indexOf(propertyName) != -1)
							criticalPropertiesMismatchFound = true;
						
		                allEqual = false;
					}
		  		}
		         
    		}
	        if(allEqual || (!criticalPropertiesMismatchFound) || calculateIndexAnyway) 
	        {
				var requiredPropList:Array  = new Array();
				
				if( automationIndexNeeded)
					requiredPropList.push("automationIndex");
				if(automationNameNeeded)
					requiredPropList.push("automationName");
				if(requiredPropList.length)
				{
		        	var childProperties1:Array = getProperties(child, requiredPropList);
					
					childPropertyMap = {};
					for (var childPropertyNo1:int = 0; childPropertyNo1 < childProperties1.length; childPropertyNo1++)
					{
						childPropertyMap[requiredPropList[childPropertyNo1]] = childProperties1[childPropertyNo1];
					}

		        	if(childProperties1 && (childProperties1.length == requiredPropList.length))
		        	{
						n = childProperties1.length;
						for(i = 0; i < n; i++)
						{
			        		//equal = comparePropertyValues("automationIndex", childProperties[0]);
							var partPropertyValue1:Object = part[requiredPropList[i]];
							propertyName = requiredPropList[i];
							var childPropertyValue1:Object = (propertyName in childPropertyMap)
								? childPropertyMap[propertyName] 
								: null;
							equal = comparePropertyValues(partPropertyValue1, childPropertyValue1);
			        		 if (equal)
				            	++score;
							 else
							 {
								 // check what is not matching is not the critical property
								 if(criticalPropertiesToMatch.indexOf(propertyName) != -1)
									 criticalPropertiesMismatchFound = true;
								 allEqual = false;
							 }
						}
		        	}
				}
	        }
			if(criticalPropertiesMismatchFound)
			{
				score = -1;
			}
		}
		
		if(allEqual)
		{
			if(automationIndexNeeded)
				score = int.MAX_VALUE; // in this case we dont need to analyse the children for further match
				// there will be only one child with index matching and all other properties also matched.
			else
				score = int.MAX_VALUE-1;
		}
         return score;
    }
    
    /**
     *  @private
     */
    public function getAutomationComposite(obj:IAutomationObject):IAutomationObject
    {
    	if(cachedCompositor)
    	{
    		var val:IAutomationObject = cachedCompositor[obj];
    		if(val != null)
    		{
    			if(val != obj)
	    			return val;
	    		else
	    			return null;
	    	}
    	}

		var childFound:IAutomationObject = compositeAnalysis(obj);
    	if(cachedCompositor)
			cachedCompositor[obj] = childFound;
			
	    if(childFound == obj)
	    	return null;

    	return childFound;
    }
    
	private function compositeAnalysis(obj:IAutomationObject):IAutomationObject
	{
    	var hierarchyArray:Array = [obj];

    	//build an array of parents till we reach null.
    	// do not call is getParent as it would call isAutomationComposite
		var parent:IAutomationObject = getParent(obj, null, true);
		while(parent)
		{
			hierarchyArray.push(parent);
			parent = getParent(parent, null, true);
		}    	

    	//start from the top finding each child
    	// if we do not find any child then the given object is composite.
    	// if we find all the children till the given object then it is not a composite. 

   		parent = hierarchyArray.pop();
		var childFound:IAutomationObject = parent;

    	if(!hierarchyArray.length)
	    	return childFound;
		
   		var childToBeFound:IAutomationObject = hierarchyArray.pop();
   		var ch:IAutomationObject;
   		do
    	{
			// code modified below to avoid the usage of numAutomationChildren and
			// getAutomationChildAt in a loop
			//var childList:Array = parent.getAutomationChildren();
			var childList:Array = getAutomationChildrenArray(parent);
			var numChildren:int = childList?childList.length:0;
			
    		//var numChildren:int = parent.numAutomationChildren;
    		for(var i:int = 0; i < numChildren; ++i)
    		{
    			//ch = parent.getAutomationChildAt(i);
				ch = childList[i] as IAutomationObject;
				if(ch)
				{
			    	if(cachedCompositor)
						cachedCompositor[ch] = ch;
	    			
	    			if(ch == childToBeFound)
	    			{
	    				childFound = childToBeFound;
	    				break;
	    			}
				}
    		}
    		
    		// have we found the child?
    		if(i == numChildren)
    		{
				if((childToBeFound  is IUIComponent)&&(parent is IUIComponent ))
				{
					// if ((IUIComponent(obj).systemManager != null) && (parent == IUIComponent(parent).systemManager.document))
					// https://bugs.adobe.com/jira/browse/FLEXENT-1038 .
					// when the passed object is a non ui object like repeater, using the same for the
					// above check will result in skipping the below condition and hence 
					// it skips the identification of repeaters in popup objects like title window
					// which are application children.
					//if ((IUIComponent(childToBeFound).systemManager != null) && (parent == IUIComponent(parent).systemManager.document))
					// chnaging the condition checking for https://bugs.adobe.com/jira/browse/FLEXENT-1044
					if ((IUIComponent(childToBeFound)) &&
						(IUIComponent(childToBeFound).systemManager != null) &&
						(IUIComponent(parent))&&
						(IUIComponent(parent).systemManager)&& 
						(parent == IUIComponent(parent).systemManager.document))
		    		{
						var children:Array = getApplicationChildren(parent);
			    		numChildren = children.length;
			    		for(i = 0; i < numChildren; ++i)
			    		{
			    			ch = children[i];
					    	if(cachedCompositor)
								cachedCompositor[ch] = ch;
			    			if(ch == childToBeFound)
			    			{
	    						childFound = childToBeFound;
			    				break;
			    			}
			    		}
		    		}
		
		    		// have we found the child?
		    		if(i == numChildren)
	    			{
				    	if(cachedCompositor)
							cachedCompositor[childToBeFound] = parent;
				   		childToBeFound = hierarchyArray.pop();
				   		continue;
	    			}	
	    		}
			}
	   		parent = childToBeFound;
	   		childToBeFound = hierarchyArray.pop();
	    }
	    while(childToBeFound);
	    
	    return childFound;
	}
    
    /**
     *  @private
     */
    public function isAutomationComposite(obj:IAutomationObject):Boolean
    {
    	if(cachedCompositor)
    	{
    		var val:IAutomationObject = cachedCompositor[obj];
    		if(val != null)
    		{
    			if(val == obj)
	    			return false;
	    		else
	    			return true;
	    	}
    	}

		var childFound:IAutomationObject = compositeAnalysis(obj);
    	if(cachedCompositor)
			cachedCompositor[obj] = childFound;

		if(obj == childFound)
	    	return false;

		return true;
    }
 
	 /**
     *  @private
     */
	private function uniqueAppIdReplyHandler(event:Event):void
	{
		// Marshalling events are needeed across applicaiton domain
		// so this conversion shall fail in the same domain
		if(event is MarshalledAutomationEvent)
			return;
			
		if(_inUniqueAppIdRequestProcessing == false)
			return;
		
		_inUniqueAppIdRequestProcessing = false;
	
		// in the reply event we expect two parameter
		if(sm1.isTopLevelRoot() == false)
		{
			if(mainListenerObj)
			{
				_uniqueApplicationId = event["interAppDataToSubApp"][0] as String;
				
			}
		}
	}
	 /**
     *  @private
     * this method is to get the provider for the swf bridge from different possible system managers
     * In the main application of the AIR, we can have different system managers if we  have the
     * air windows open. so we need to check in all of them to find the bridge provider and use
     * the identification based on the origin of the bridge provider.
     */
	private function getSwfBridgeProviderDetails(bridgeParent:IEventDispatcher):Object
	{
		var providerType:int = -1;
		var providerName:String;
		// the bridge can be in the current application or in the windows.
		// this will be applicable for the root application only as only the root application can 
		// have child windows.
		
		// first let us search in the main applicaiton system manager.
		var bp:ISWFBridgeProvider;
		
		if(sm1MSm && (sm1MSm.swfBridgeGroup ))
		{
			bp = sm1MSm.swfBridgeGroup.getChildBridgeProvider(bridgeParent);
			initUniqueAppId();
			providerName = _uniqueApplicationId;
			providerType = -1;
		} 
		if (!bp)
		{
			// now let us seach in the windows.
			var count:int  = allAirWindowList.length;
	    	var index:int = 0;
	    	while((!bp) && (index  <  count))
	    	{
	    		var currentWindow:IUIComponent = allAirWindowList[index]  as IUIComponent;
	    		if(currentWindow)
	    		{
		    		var currentWindowSysManager:IMarshalSystemManager = currentWindow.systemManager as IMarshalSystemManager;
					if(currentWindowSysManager)
					{
						if(currentWindowSysManager.swfBridgeGroup)
							bp = currentWindowSysManager.swfBridgeGroup.getChildBridgeProvider(bridgeParent); 
						if(bp)
						{
							providerName = getAIRWindowUniqueID(currentWindow  as DisplayObject);
							providerType = index;
						}
					}
				
	    		}
	    		index++;
	    	}
		}
		var returnObject:Object = new Object();
		returnObject["ISWFBridgeProvider"] = bp;
		returnObject["providerType"] = providerType;
		returnObject["providerName"] = providerName;
		
		
		return returnObject;
	}
	
	private function initUniqueAppId():void
	{
		if(!_uniqueApplicationId)
		{
			if(sm1.isTopLevelRoot() == false)
			{
				// we need to get the uniqueapplication id from the parentapplication 
				dispatchUniqueAppIdRequestEvent();
				_uniqueApplicationId = Automation.getMainApplication().className + "_" + _uniqueApplicationId;
			}
			else
			{
				_uniqueApplicationId = Automation.getMainApplication().className;
			}
		}
	}
	private function uniqueAppIdRequestHandler(event:Event):void
	{
		// Marshalling events are needeed across applicaiton domain
		// so this conversion shall fail in the same domain
		if(event is MarshalledAutomationEvent)
			return;
		
		// we get the bridge corresponding to the requesting application
		// we need to find the swfLoader corresponding to the bridge
		// get its index in its parents till we reach the sm of the
		// current application.
		//var bp:ISWFBridgeProvider = sm1.swfBridgeGroup.
		//	getChildBridgeProvider(event["interAppDataToMainApp"][0]);
		
		var providerType:int = -1; // -1 indicates the main application and any othe value indicates the window index 
		var providerName:String;
		var returnObject:Object = getSwfBridgeProviderDetails ((event["interAppDataToMainApp"][0]));
		
		var bp:ISWFBridgeProvider = returnObject["ISWFBridgeProvider"];
		providerType = returnObject["providerType"];
		providerName = returnObject["providerName"];
		if(bp)
		{
			var unique_id_processed:String = getObjectIdInCurrentApplication(bp as DisplayObject);
			// initUniqueAppId(); moved inside the getSwfBridgeProviderDetails
			//unique_id_processed = unique_id_processed + "_" + _uniqueApplicationId;
			unique_id_processed = unique_id_processed + "_" + providerName;
				
			if(mainListenerObj)
			{
				// unique id handling logic
				var event1:MarshalledAutomationEvent = new MarshalledAutomationEvent(
				MarshalledAutomationEvent.UNIQUE_APPID_REPLY);
				var temp:Array = new Array();
				temp.push(unique_id_processed);
				event1.interAppDataToSubApp =  temp;
				//dispatchMarshalledEventToSubApplications(event1);
				dispatchToSwfBridgeChildren(event1);
			}
		}
	}
		
	private var inEndRecordDetailsPassingDownToChildren:Boolean = false;
	public  function marhsalledEndRecordHandler(event:Event):void
    {   
    	if(!sm1MSm)
    		return;
    		
    	if(sm1MSm.useSWFBridge() == false)
    		return;
    		
    	// Marshalling events are needeed across applicaiton domain
		// so this conversion shall fail in the same domain
		if(event is MarshalledAutomationEvent)
			return;
		
		if(inEndRecordDetailsPassingDownToChildren == true)
			return;
			
    	endRecording();
    	
    	inEndRecordDetailsPassingDownToChildren = true;
    	// we should pass the information to our children also
    	var event1:MarshalledAutomationEvent = MarshalledAutomationEvent.marshal(event);
    	dispatchMarshalledEventToSubApplications(event1);
    	inEndRecordDetailsPassingDownToChildren = false;
    }
    
    private var inBeginRecordDetailsPassingDownToChildren:Boolean = false;
	public  function marhsalledBeginRecordHandler(event:Event):void
    {  
    	if(!sm1MSm)
    		return;
    		
    	if(sm1MSm.useSWFBridge() == false) // we are the root application
    		return;
    		
    	// Marshalling events are needeed across applicaiton domain
		// so this conversion shall fail in the same domain
		if(event is MarshalledAutomationEvent)
			return;
			
		if(inBeginRecordDetailsPassingDownToChildren == true)
			return;
		 
    	beginRecording();
    	
    	inBeginRecordDetailsPassingDownToChildren = true;
    	
    	// we should pass the information to our children also
    	var event1:MarshalledAutomationEvent = MarshalledAutomationEvent.marshal(event);
    	dispatchMarshalledEventToSubApplications(event1);
    	
    	inBeginRecordDetailsPassingDownToChildren = false;
    	
    }
    
    
    private   function dispatchMarshalledEventToSubApplications(event:Event):void
    {
    	dispatchToAllChildren(event);
    }
    
    
   // FLEXENT-894 or 895 it was observerd that popupmenubutton menu popup object is
   // creatd before application completion. So we need to listen to the event
   // from the main app before the application completion. 
   // we cannot process these objects as and when we get it, as our appDomain may not be
   // ready then. So we store it and once the application creation is over we process these
   // objects
    private var possiblePopupsBeforeAppComplete:Array;
    private  function popupHandlerBeforeApplicationCompletion (event:Event):void
    {
   		var currentAppObj:IAutomationObject = event["interAppDataToSubApp"][0] as IAutomationObject;
   		if(!(currentAppObj is IUIComponent) || currentAppObj == null || currentAppObj.automationDelegate)
		{
			return ;
		}
		else
		{
			if(!possiblePopupsBeforeAppComplete)
				possiblePopupsBeforeAppComplete = new Array();
			// these are our objects. And some may be popups.
			// let us add to a list and keep it so that once our application is complete 
			// we will try to add the delegate for the same.
			possiblePopupsBeforeAppComplete.push(currentAppObj);
		}
   		
    }
   
   // FLEXENT-894 or 895 it was observerd that popupmenubutton menu popup object is
   // creatd before application completion. 
   // So we store it and once the application creation is over we process these
   // objects
    private  function processPopupsBeforeApplicationComplete():void
    {
    	if(possiblePopupsBeforeAppComplete)
    	{
	    	var count:int = possiblePopupsBeforeAppComplete.length;
	    	var index:int = 0;
	    	while(index < count)
	    	{
	    		handlePopupObject(possiblePopupsBeforeAppComplete.shift());
	    		index++;
	    	}
    	
    	}
    }
    private var inPopupDataSendingDownToChildren:Boolean = false;
    
    private  function popupHandler (event:Event):void
    {
    	if(event is MarshalledAutomationEvent)
    		return ;
    		
    	if(inPopupDataSendingDownToChildren)
    		return;
    		
    	var currentAppObj:DisplayObject = event["interAppDataToSubApp"][0] as DisplayObject;
    	handlePopupObject(currentAppObj, event);
    	
    }
    
    private function handlePopupObject(currentAppObj:DisplayObject, event:Event=null):void
    {
    	if(createDelegate(currentAppObj)== true)
    	{
			// we got a new popup.
			// we need to add this to our pop up list also
			// this is neeeded beause in automation we need to consider the popup's as the
			// children of the application which has created the same
			if(!popUpObjects)
				popUpObjects = new Array();
			
			if(currentAppObj as IUIComponent)
			{
				if( (currentAppObj as IUIComponent).owner == (currentAppObj as IUIComponent).parent )
					popUpObjects.push(currentAppObj);
				else if ((currentAppObj as IUIComponent).owner is Application ||
					isSparkApplication((currentAppObj as IUIComponent).owner))
					// for the popups which are direct children of application we need to store
					popUpObjects.push(currentAppObj);
			}
			/*
			if(!((currentAppObj as IUIComponent)&&
	    			((currentAppObj as IUIComponent).owner != (currentAppObj as IUIComponent).parent)))
			popUpObjects.push(currentAppObj);

			*/
			
    		addDelegates(currentAppObj);
    	
    		// we only added the delegate for the outer object.
    		// we need to add for the children also.
    		currentAppObj.addEventListener(FlexEvent.CREATION_COMPLETE, popupCompleteHandler);
    		currentAppObj.parent.addEventListener(FlexEvent.REMOVE, popupRemoveHandler);
    	}
    	else
    	{
    		inPopupDataSendingDownToChildren = true;
    		var eventX:MarshalledAutomationEvent;
    		if(event)
    		{
    			// we should pass the information to our children also
    		 	eventX= MarshalledAutomationEvent.marshal(event);
    		}
    		else
    		{
    			eventX = new MarshalledAutomationEvent(
								MarshalledAutomationEvent.POPUP_HANDLER_REQUEST);
				var tempArr:Array = new Array();
				tempArr.push(currentAppObj);
				eventX.interAppDataToSubApp = tempArr;
    		}
    	
    		dispatchMarshalledEventToSubApplications(eventX);
    		inPopupDataSendingDownToChildren = false;
    	}
    }
    private static var lastRemovedpopUpObject:DisplayObject;
    private static function popupRemoveHandler(event:Event):void
    {
    	lastRemovedpopUpObject = null;
    	if(!popUpObjects)
    	{
			Automation.automationDebugTracer.traceMessage("AutomationManager", "popupRemoveHandler()", "How did we get an obejct to remove without adding ? ");
    		return;
    	}
    	var obejctToBeRemoved:Object = event.target;
    	
    	// remove the current objects from the popUps
    	var currentCount:int = popUpObjects.length;
    	var index:int = 0;
    	var requiredCount: int = 0;
    	var tempArray:Array = new Array();
    	var objFound:Boolean = false;
    	while (index < currentCount)
    	{
    		if( ((popUpObjects[index]as DisplayObject).parent) != obejctToBeRemoved)
    			tempArray.push(popUpObjects[index]);
    		else
    			lastRemovedpopUpObject = popUpObjects[index];
    		index ++;
    	}
    	popUpObjects = tempArray;
    	
    
    }
    
    public function getPopUpChildren():Array
    { 
      	return popUpObjects;
    }
	
	
	public function getPopUpChildrenCount():Number
	{ 
		if (!popUpObjects)
			return 0;
		
		return popUpObjects.length;
	}
    
    public function getPopUpChildObject(index:int):IAutomationObject
    { 
    	if(index < popUpObjects.length)
    		return popUpObjects[index] as IAutomationObject;
    	
    	return null;
    }
    
    private function popupCompleteHandler(event:Event):void
    {
    	var currentObject:DisplayObjectContainer = event.target as DisplayObjectContainer;
    	addPopupChildDelegates(currentObject);
		currentObject.addEventListener(Event.ADDED, childAddedHandler, false, 0, true);
    }
    
    
    private static function addPopupChildDelegates(currentObject: DisplayObjectContainer):void
    {
    	if(currentObject)
    	{
	    	var childCount:int = currentObject.numChildren;
	    	var index:int = 0;
	    	
	    	while(index < childCount)
	    	{
	    		var childObj:DisplayObject = currentObject.getChildAt(index);
	    		createDelegate(childObj);
	    		addDelegates(childObj);
	    		addPopupChildDelegates(childObj as DisplayObjectContainer);
	    		index++;
	    	}
    	}
    }
    
    private static function dragproxyStoreRequesthandler(event:Event):void
    {
    	// we will only store one dragProxyObject
    	if(!currentDragProxyHolder)
    		currentDragProxyHolder = new Array();
    	currentDragProxyHolder[0] = event["interAppDataToMainApp"][0] as DisplayObject;
    	
    }
    
    
    private  function dragproxyRetrieveRequesthandler(event:Event):void
    {
		var tempEventObj:MarshalledAutomationEvent = new MarshalledAutomationEvent(
				MarshalledAutomationEvent.DRAG_DROP_PROXY_RETRIEVE_REPLY);
		var tempArr:Array = new Array();
		if(currentDragProxyHolder && currentDragProxyHolder.length!= 0)
			tempArr.push(currentDragProxyHolder[0]);
		else
			tempArr.push(null);
		tempEventObj.interAppDataToSubApp = tempArr;
		currentDragProxyHolder = new Array();
					
    	dispatchMarshalledEventToSubApplications(tempEventObj);
    }
    
    public  function storeDragProxy(dragProxy:Object):void
    {
    	// if the drag start happened in the sandbox root we wont get the event 
    	// corresponding to the dragProxyReciever, so we need to store it explicitly
    	if(!currentDragProxyHolder)
       			currentDragProxyHolder = new Array();
       			
	    	currentDragProxyHolder[0] = dragProxy;
    }
    private static function dragProxyReciever(event:Event):void
    {
       	if(event["name"] == "popUpChildren.addChild")
       	{
       		if(!currentDragProxyHolder)
       			currentDragProxyHolder = new Array();
       			
	    	currentDragProxyHolder[0] = event["value"];
       	}
    }
    
    private var inSynchronizationSendingToChildren:Boolean = false;
    private  function synchronizationHandler(event:Event):void
    {
    	// we get this event when an application has started drag start
    	// and we get this in all applications. 
    	
    	if(event is MarshalledAutomationEvent)
    		return;
    		
    	if(inSynchronizationSendingToChildren)
    		return;
    		
    	// we need this method so that it calls the synchronization 
    	// method to clear the current status.
    	isSynchronized(null);
    	
    	inSynchronizationSendingToChildren = true;
    	
    	// we should pass the information to our children also
    	var event1:MarshalledAutomationEvent = MarshalledAutomationEvent.marshal(event);
    	dispatchMarshalledEventToSubApplications(event1);
    	
    	inSynchronizationSendingToChildren = false;
    }
    
    private static function isCurrentAppSandboxRoot(passedSystemManager:ISystemManager):Boolean
    {
    	var retVal:Boolean = false;
    	try
		{
			// get the root of the system manager of the current application
			if(passedSystemManager["root"] && (passedSystemManager.getSandboxRoot() == passedSystemManager["root"]))
				retVal =  true;
		}
		catch(e:Error)
		{
			
		}
		
		return retVal;
    }
    
    private static function getMainListenerObject(passedSystemManager:ISystemManager, passedMarshaledSystemManager:IMarshalSystemManager):IEventDispatcher
    {
    	var requiredObj:IEventDispatcher ;
    	if(passedSystemManager)
		{
			// we need to use the sanbox root if we belong to the 
    		// same security domain as that of the root applucation
			requiredObj = passedSystemManager.getSandboxRoot();
			//var passedMarshaledSystemManager:IMarshalSystemManager = passedSystemManager as IMarshalSystemManager;
		
			if (passedMarshaledSystemManager && passedMarshaledSystemManager.useSWFBridge() && (isCurrentAppSandboxRoot(passedSystemManager) == true))
			{
				// this application is not the root level application, but it is 
				// first application of the security domain. So this objects's mainListenerObj is 
				// parent brige
				requiredObj = passedMarshaledSystemManager.swfBridgeGroup.parentBridge;
			}
		}
		return requiredObj;
    }
    
    private  function addListenerToParentApplication(obj:IEventDispatcher):void
    {
		// as an application X we need to listen to the events coming from the parent. 
		// these events are always sent from the parent to the child. So these events are listened by 
		// the children on their parent. When we recieve the event,if we are not handling these, we should 
		// pass the same to the children. i.e always sent from the parent -> child. These events are 
		// handled by the children. i,e these are always added on the parent. 
   			
	 		obj.addEventListener(MarshalledAutomationEvent.BEGIN_RECORDING, marhsalledBeginRecordHandler,false,0,true);
   			
			obj.addEventListener(MarshalledAutomationEvent.END_RECORDING, marhsalledEndRecordHandler,false,0,true);
   			
			//obj.addEventListener(MarshalledAutomationEvent.ENV_DETAILS , envDetailsEventHandler, false, 0, true);
   			if((obj as SystemManager)&& (obj as SystemManager).getSandboxRoot())
				((obj as SystemManager).getSandboxRoot()).removeEventListener(MarshalledAutomationEvent.POPUP_HANDLER_REQUEST , popupHandlerBeforeApplicationCompletion, false);
			
			obj.addEventListener(MarshalledAutomationEvent.POPUP_HANDLER_REQUEST , popupHandler, false, 0, true);
   			
			obj.addEventListener(MarshalledAutomationEvent.UPDATE_SYCHRONIZATION,synchronizationHandler, false, 0, true);
   			
			obj.addEventListener(MarshalledAutomationEvent.INITIAL_DETAILS_REPLY,initialDetailsReplyHandler, false, 0, true);
			
			 obj.addEventListener(MarshalledAutomationEvent.START_POINT_REPLY,startPointReplyHandler, false, 0, true);
   			
			obj.addEventListener(MarshalledAutomationEvent.UNIQUE_APPID_REPLY , uniqueAppIdReplyHandler, false, 0, true);
			
			obj.addEventListener(MarshalledAutomationEvent.DRAG_DROP_PERFORM_REQUEST_TO_SUB_APP ,dragDropPerformRequesthandlerInSubApp, false, 0, true);
	
    }
    private  function addListenerToChildApplications(obj:IEventDispatcher):void 
    {
        // as an application x, we need to listen to these events coming from the children. 
        // these events will be processed only by the root application. so if we are not the root applicaiton 
        // we just need to dispatch these events on the parent. So always these events are from the child -> Parent.
        // i.e these events are always handled by the parent. So the listneres of the events should be added to the children.
   			
   		obj.addEventListener(MarshalledAutomationEvent.DRAG_DROP_PROXY_RETRIEVE_REQUEST, dragproxyRetrieveRequesthandler);
   			
  		obj.addEventListener(InterManagerRequest.SYSTEM_MANAGER_REQUEST,dragProxyReciever, false, 0, true);
   			
   		obj.addEventListener(MarshalledAutomationEvent.UPDATE_SYCHRONIZATION,synchronizationHandler, false, 0, true);
   			
  		obj.addEventListener(MarshalledAutomationEvent.INITIAL_DETAILS_REQUEST,initialDetailsRequestHandler, false, 0, true);
   			
   		obj.addEventListener(MarshalledAutomationEvent.UNIQUE_APPID_REQUEST , uniqueAppIdRequestHandler, false, 0, true);
   		
   		obj.addEventListener(MarshalledAutomationEvent.START_POINT_REQUEST , startPointRequestHandler, false, 0, true);
   		
   		obj.addEventListener(MarshalledAutomationEvent.DRAG_DROP_PERFORM_REQUEST_TO_ROOT_APP,dragDropPerformRequesthandlerInRootApp, false, 0, true);
	

	  }
    
    private function dragDropPerformRequesthandlerInSubApp(event:Event):void
    {
    	if(event is MarshalledAutomationEvent)
    		return;
    	
    	// take the details and check whether the object belongs to us.
    	var details:Array  = event["interAppDataToSubApp"];
    	if(details && details.length  == 2)
    	{
	    	var target:IUIComponent = details[0] as IUIComponent;
	    	if(target)
	    	{
	    		DragManagerAutomationImpl.setForcefulDragStart();
	    		var passedEventObj:Object = details[1];
	    		var dragEventInCurrentDomain:DragEvent = new DragEvent(passedEventObj["type"]);
	    		dragEventInCurrentDomain.action = passedEventObj["action"];
	    		dragEventInCurrentDomain.localX = passedEventObj["localX"];
	    		dragEventInCurrentDomain.localY= passedEventObj["localY"];
	    		
	    		DragManagerAutomationImpl.recordAutomatableDragDrop1(target as DisplayObject , dragEventInCurrentDomain);
	    	}
	    
    	}
    		
    }
    
    private function dragDropPerformRequesthandlerInRootApp(event:Event):void
    {
    	if(event is MarshalledAutomationEvent)
    		return;
    	
    	// take the details and check whether the object belongs to us.
    	var details:Array  = event["interAppDataToMainApp"];
    	if(details.length  == 2)
    	{
	    	var target:IUIComponent = details[0] as IUIComponent;
	    	if(target)
	    	{
	    		DragManagerAutomationImpl.setForcefulDragStart();
	    		var passedEventObj:Object = details[1];
	    		var dragEventInCurrentDomain:DragEvent = new DragEvent(passedEventObj["type"]);
	    		dragEventInCurrentDomain.action = passedEventObj["action"];
	    		dragEventInCurrentDomain.localX = passedEventObj["localX"];
	    		dragEventInCurrentDomain.localY= passedEventObj["localY"];
	    		DragManagerAutomationImpl.recordAutomatableDragDrop1(target as DisplayObject ,dragEventInCurrentDomain );
	    	}
	    	else
	    	{
	    		var eventObj:MarshalledAutomationEvent = new MarshalledAutomationEvent(MarshalledAutomationEvent.DRAG_DROP_PERFORM_REQUEST_TO_SUB_APP );
	    		eventObj.interAppDataToSubApp = details;
	    		dispatchToAllChildren(eventObj);
	    		
	    	}
    	}
    		
    }
    
    private static var listenerAdded:Boolean = false;
    /* this funciton is to add the required event listeners of
    automation manger */
    
    private  function addListenerToAllApplications(passedListenerObj:IEventDispatcher,
    	passedSystemManager:ISystemManager,passedMarshaledSystemManager:IMarshalSystemManager,fromAirWindow:Boolean = false):void
    {
    	
    	//var passedMarshaledSystemManager:IMarshalSystemManager = passedSystemManager as IMarshalSystemManager;
    	if(!passedMarshaledSystemManager)
    		return;
    		
    	// we need to take all the children and add listener to all the child 
    	// bridges in these application.
    	// an application in a different securty domain or applicaiton domain, when they
    	// have their child application, they have a bridge corresponding to their child application
    	// so the main application need to listen to all their child applications.
    	
		addListenerToParentApplication(passedListenerObj);
		
		if(passedMarshaledSystemManager.useSWFBridge())
		{
			// we need a special listener to the uniqueIdReply
			// this event we will listen always to the parentBridge rather than the main
			// communication object
	    	var bridgeParent:IEventDispatcher = passedMarshaledSystemManager.swfBridgeGroup.parentBridge;
	    	if(bridgeParent)
	    	{
	    		bridgeParent.addEventListener(MarshalledAutomationEvent.UNIQUE_APPID_REPLY,
	    			uniqueAppIdReplyHandler, false, 0, true);
	    		bridgeParent.addEventListener(MarshalledAutomationEvent.START_POINT_REPLY,
	    			startPointReplyHandler, false, 0, true);
	    	}
    	}
    
		
		// only the sandbox root applicaiton needs to listen to the communication over the main listener object
		if (fromAirWindow || (isCurrentAppSandboxRoot(passedSystemManager as ISystemManager)))
    		addListenerToChildApplications(passedSystemManager.getSandboxRoot());
  		
  			
		if (!passedMarshaledSystemManager.swfBridgeGroup)
			return;
		
    	var children:Array = passedMarshaledSystemManager.swfBridgeGroup.getChildBridges();
		for (var i:int; i < children.length; i++)
		{
		 	var childBridge:IEventDispatcher = IEventDispatcher(children[i]);
		 	addListenerToChildApplications(childBridge);
		}
		listenerAdded = true;
	
    }    
     
    public  function dispatchToParent(event:Event):void
    {
    	if(mainListenerObj.hasEventListener(event.type))
    		mainListenerObj.dispatchEvent(event);
    }
    
    private  function dispatchToBridgeParent(event:Event):void
    {
    	if(!sm1MSm)
    		return;
    		
    	var bridgeParent:IEventDispatcher = sm1MSm.swfBridgeGroup.parentBridge;
    	if(bridgeParent.hasEventListener(event.type))
    		bridgeParent.dispatchEvent(event);
    }
    
 
 	private  function dispatchToSwfBridgeChildren(event:Event):void
    {
         dispatchToSwfBridgeChildrenOfPassedSystemManager(sm1,sm1MSm,event);
         // we need to consider the possible swf bridge children from the windows also
         dispatchToSwfBridgeChildrenOfAllWindows(event);
    }
   
    private  function dispatchToSwfBridgeChildrenOfAllWindows(event:Event):void
    {
    	var count:int  = allAirWindowList.length;
    	var index:int = 0;
    	while(index  <  count)
    	{
    		var currentWindow:IUIComponent = allAirWindowList[index]  as IUIComponent;
    		if(currentWindow)
    		{
	    		var currentWindowSysManager:ISystemManager = currentWindow.systemManager;
	    	    var currentWindowMarshaledSysManager:IMarshalSystemManager = IMarshalSystemManager(
	    	    	currentWindow.systemManager.getImplementation("mx.managers::IMarshalSystemManager"));
		
				if(currentWindowSysManager)
				{
					dispatchToSwfBridgeChildrenOfPassedSystemManager(currentWindowSysManager,currentWindowMarshaledSysManager,event);
				}
			
    		}
    		index++;
    	}
    }
    
    private function dispatchToSwfBridgeChildrenOfPassedSystemManager(passedSystemManager:ISystemManager, 
    		passedMarshalledSystemManger:IMarshalSystemManager,
    		event:Event):void
    {
    	//var passedMarshalledSystemManger:IMarshalSystemManager = passedSystemManager as IMarshalSystemManager;
    	if(!passedMarshalledSystemManger)
    		return;
    		
    	 if (!passedMarshalledSystemManger.swfBridgeGroup)
			return;
		
    	var children:Array = passedMarshalledSystemManger.swfBridgeGroup.getChildBridges();
		for (var i:int; i < children.length; i++)
		{
		 	var childBridge:IEventDispatcher = IEventDispatcher(children[i]);
		 	if(childBridge.hasEventListener(event.type))
		 		childBridge.dispatchEvent(event);
		}
    }
    
    
    public  function dispatchToAllChildren(event:Event):void
    {
    	dispatchToAllChildrenOfPassedSystemManager(sm1,sm1MSm,event,false);
    	// we need to consider the possible children of the windows also.
    	dispathcToAllWindowChildApplications(event);
		
    }
    
    private function dispathcToAllWindowChildApplications(event:Event):void
    {
    	var count:int  = allAirWindowList.length;
    	var index:int = 0;
    	while(index  <  count)
    	{
    		var currentWindow:IUIComponent = allAirWindowList[index]  as IUIComponent;
    		if(currentWindow)
    		{
	    		var currentWindowSysManager:ISystemManager = currentWindow.systemManager;
	    		var currentWindowMarshaledSysManager:IMarshalSystemManager = IMarshalSystemManager(currentWindow.systemManager.getImplementation("mx.managers::IMarshalSystemManager"));
				if(currentWindowSysManager)
				{
					dispatchToAllChildrenOfPassedSystemManager(currentWindowSysManager,currentWindowMarshaledSysManager,event,true);
				}
			
    		}
    		index++;
    	}
    }
    
    private function dispatchToAllChildrenOfPassedSystemManager(passedSystemManager:ISystemManager, passedMarshalledSystemManger:IMarshalSystemManager,event:Event, fromAirWindow:Boolean):void
    {
    	//var passedMarshalledSystemManger:IMarshalSystemManager = passedSystemManager as IMarshalSystemManager;
    	if(!passedMarshalledSystemManger)
    		return;
   
   
    	// some children (of the same application domain)
    	// will be listening to the sandboxroot of the main app only
    	// hence we need to dispatch event on this object also.
    	if(fromAirWindow || (isCurrentAppSandboxRoot(passedSystemManager)))
    		passedSystemManager.getSandboxRoot().dispatchEvent(event);
    		
       	
    	if (!passedMarshalledSystemManger.swfBridgeGroup)
			return;
		
    	var children:Array = passedMarshalledSystemManger.swfBridgeGroup.getChildBridges();
		for (var i:int; i < children.length; i++)
		{
		 	var childBridge:IEventDispatcher = IEventDispatcher(children[i]);
		 	if(childBridge.hasEventListener(event.type))
		 		childBridge.dispatchEvent(event);
		}
    }
     
    private var _inInitialDetailsRequestProcessing:Boolean = false;
    private var _inStartPointRequestProcessing:Boolean = false;
    
    private static function initMainListeners():void
    {
    	if(!_sm1MSm)
			_sm1MSm = IMarshalSystemManager(sm1.getImplementation("mx.managers::IMarshalSystemManager"));
     	
     	if(!_mainListenerObj)
     		_mainListenerObj = getMainListenerObject(sm1,_sm1MSm);
     
    }
    private  function applicationCompleteHandler(event:Event):void
    {
    	if(!(event is FlexEvent))
    		return;
    	
    	initMainListeners();
     	//_mainListenerObj.addEventListener(MarshalledAutomationEvent.POPUP_HANDLER_REQUEST , popupHandlerBeforeApplicationCompletion, false, 0, true);
     		
    	// add listener to the child bridges
    	addListenerToAllApplications(_mainListenerObj,sm1,sm1MSm);
    	
    	// process the possible popops
    	processPopupsBeforeApplicationComplete();
         // we will listen to the initial details from our parent.
	    var initialStatusRequest:MarshalledAutomationEvent = 
	    		new MarshalledAutomationEvent(MarshalledAutomationEvent.INITIAL_DETAILS_REQUEST);
	   _inInitialDetailsRequestProcessing = true;
	    dispatchToParent(initialStatusRequest);
    	
    }
   
    private  var eventDetailsFromToolToChildren:Array;
    public function addEventListenersToAllParentApplications(eventDetailsArray:Array):void
    {
    	// we dont need to store the events as we will never get a new parent.
    	addEventListeners(mainListenerObj,eventDetailsArray);
    }
    
    
    public function addEventListenersToAllChildApplications(eventDetailsArray:Array):void
    {
    	eventDetailsFromToolToChildren = eventDetailsArray;
    	
    	addEventListenersToAllChildApplicationsOfPassedSystemManager(sm1,sm1MSm,eventDetailsFromToolToChildren,false);
    	// we need to consider the child application of the windows also
    	addEventListenersToAllChildApplicationsOfAllWindows(eventDetailsFromToolToChildren);
	
    }
    
    private function addEventListenersToAllChildApplicationsOfAllWindows(eventDetailsArray:Array):void
    {
    	var count:int  = allAirWindowList.length;
    	var index:int = 0;
    	while(index  <  count)
    	{
    		var currentWindow:IUIComponent = allAirWindowList[index]  as IUIComponent;
    		if(currentWindow)
    		{
	    		var currentWindowSysManager:ISystemManager = currentWindow.systemManager;
	    		var currentWindowMarshalSysManager:IMarshalSystemManager = IMarshalSystemManager(
	    									currentWindow.systemManager.getImplementation("mx.manager::IMarshalSystemManager"));
				if(!currentWindowSysManager)
				{
					addEventListenersToAllChildApplicationsOfPassedSystemManager(currentWindowSysManager,currentWindowMarshalSysManager,eventDetailsArray,true);
				}
			
    		}
    		index++;
    	}
    }
    
    private function addEventListenersToAllChildApplicationsOfPassedSystemManager(passedSystemManager:ISystemManager,
    	passedMarshalledSystemManger:IMarshalSystemManager,
    		eventDetailsArray:Array,fromAirWindow:Boolean):void
    {
   	  	//var passedMarshalledSystemManger:IMarshalSystemManager = passedSystemManager as IMarshalSystemManager;
    	if(!passedMarshalledSystemManger)
    		return;
   
   
    	if(fromAirWindow || (isCurrentAppSandboxRoot(passedSystemManager)))
    		addEventListeners(passedSystemManager.getSandboxRoot(),eventDetailsArray);
    	
 		
    	if (!passedMarshalledSystemManger.swfBridgeGroup)
			return;
		
    	var children:Array = passedMarshalledSystemManger.swfBridgeGroup.getChildBridges();
		for (var i:int; i < children.length; i++)
		{
		 	var childBridge:IEventDispatcher = IEventDispatcher(children[i]);
		 	addEventListeners(childBridge,eventDetailsArray);
		}
    } 
    
    private function childBridgeHandler(event:FlexChangeEvent):void
    {
    	// get the new bridge of the current application and add listeners to the same
    	var currentBridge:IEventDispatcher = event.data as IEventDispatcher;
    	handleBridge(currentBridge);
    	
    }
    
    private function handleBridge(currentBridge:IEventDispatcher):void
    {
    	if(currentBridge)
    	{
    		addEventListeners(currentBridge,eventDetailsFromToolToChildren);
    		addListenerToChildApplications(currentBridge);
    	}
    }
    
    private function addEventListeners(obj:IEventDispatcher, eventDetailsArray:Array):void
    {
    	// it is quite possible that tool library has not supported marshaling
    	// and hence these arrays would not have been initialised
    	if(!eventDetailsArray)
    		return;
    	var count:int = eventDetailsArray.length;
    	var index:int = 0;
    	
    	while(index < count)
    	{
    		var currentEventDetailsObj:EventDetails = eventDetailsArray[index] as EventDetails;
    		if(currentEventDetailsObj)
			{
		    			obj.addEventListener(currentEventDetailsObj.eventType, 
		    				currentEventDetailsObj.handlerFunction,
		    				currentEventDetailsObj.useCapture, 
		    				currentEventDetailsObj.priority, 
		    				currentEventDetailsObj.useWeekRef);
			}
    		index++;
    	}
    } 
   
    
    private function initialDetailsRequestHandler(event:Event):void
    {
    	if (event is MarshalledAutomationEvent)
    		return;
    		
       	var replyEvent:MarshalledAutomationEvent = new 
    		 MarshalledAutomationEvent(MarshalledAutomationEvent.INITIAL_DETAILS_REPLY);
    	// order of the elements in the array should not changed across versions.
    	// if some information is needed in further versions it needs to be added after this
    	// and handler can handle the data appropriately.
    	var tempArr:Array = new Array();
		tempArr.push(_recording);
		tempArr.push(_automationEnvironmentHandlingClassName);
		tempArr.push(_automationEnvironmentString);
		replyEvent.interAppDataToSubApp = tempArr;
		dispatchToAllChildren(replyEvent);
    }
  
  	private function startPointRequestHandler(event:Event):void
    {
    	if (event is MarshalledAutomationEvent)
    		return;
    	var windowId:String = event["interAppDataToMainApp"][0] as String;	
       	var replyEvent:MarshalledAutomationEvent = new 
    		 MarshalledAutomationEvent(MarshalledAutomationEvent.START_POINT_REPLY);
    	if(sm1.isTopLevelRoot() == false)
    	{
    		dispatchStartPointRequestEvent(windowId);
    		var tempArr:Array = new Array();
    		//var p:Point = AutomationHelper.getStageStartPointInScreenCoords(windowId);
    		tempArr.push(_appStartPoint.x);
    		tempArr.push(_appStartPoint.y);
		
			replyEvent.interAppDataToSubApp = tempArr;
			dispatchToAllChildren(replyEvent);
    	}	 
    		 
    	if(sm1.isTopLevelRoot() == true)
    	{	//start point request should be handled only by main application
    		//i.e., top level root application
    		var tempArr1:Array = new Array();
    		var p:Point = AutomationHelper.getStageStartPointInScreenCoords(windowId);
    		tempArr1.push(p.x);
    		tempArr1.push(p.y);
		
			replyEvent.interAppDataToSubApp = tempArr1;
			dispatchToAllChildren(replyEvent);
    	}
    }
    
    private function initialDetailsReplyHandler(event:Event):void
	{
		// Marshalling events are needeed across applicaiton domain
		// so this conversion shall fail in the same domain
		if(event is MarshalledAutomationEvent)
			return;
		
		 if (!_inInitialDetailsRequestProcessing)
    		return;
    	
    	_inInitialDetailsRequestProcessing = false;
    	

		if(sm1.isTopLevelRoot() == false)
		{
			try
	        {
				var interAppData:Array = event["interAppDataToSubApp"];
				_recording = interAppData[0] as Boolean;
				if(_recording == true)
				{
					_recording = false; // to make the beginRecording call happen
					beginRecording();
				}
				_automationEnvironmentString = interAppData[2];
				_automationEnvironmentHandlingClassName = interAppData[1];
				var envClass:Class = Class(getDefinitionByName(_automationEnvironmentHandlingClassName)); //( "mx.automation.tool.ToolEnvironment"));
				if (envClass != null)
	            {
	              _automationEnvironment = new envClass(new XML(_automationEnvironmentString));
	            }
			}
	        catch(e:Error)
	        {
	        	
	        }
		}  
	}
	
	private function startPointReplyHandler(event:Event):void
	{
		// Marshalling events are needeed across application domain
		// so this conversion shall fail in the same domain
		if(event is MarshalledAutomationEvent)
			return;
		
		 if (!_inStartPointRequestProcessing)
    		return;
    	
    	_inStartPointRequestProcessing = false;
		
		if(sm1.isTopLevelRoot() == false)
		{
			try
	        {
				var interAppData:Array = event["interAppDataToSubApp"];
				_appStartPoint = new Point(interAppData[0] as Number, interAppData[1] as Number);
			}
	        catch(e:Error)
	        {
	        	
	        }
		}  
	}
	
	
	private function getObjectIdInCurrentApplication(objectPassed:DisplayObject):String
	{
		
		if(!objectPassed)
			return null;
		
		var idString:String = null;
		var orderArraay:Array = new Array();
		try
		{
    		var object:DisplayObject = objectPassed;
    		var parent:DisplayObjectContainer = object.parent;
    		while(object &&  parent && (parent!= sm1))
    		{
    			orderArraay.push(getChildIndex1(parent,object));
    			object = parent;
    			parent = object.parent;
    		}
    		idString = orderArraay.join("");
		}
		catch(e:Error)
		{
			
		}
		return idString;
	}	
	private var _inUniqueAppIdRequestProcessing:Boolean = false;
	
	private function dispatchUniqueAppIdRequestEvent():void
	{
		if(!sm1MSm)
			return;
			
		_inUniqueAppIdRequestProcessing = true;
		var appIdReqEvent:MarshalledAutomationEvent = new MarshalledAutomationEvent(
	    			MarshalledAutomationEvent.UNIQUE_APPID_REQUEST);
		var tempArray:Array = new Array();
		tempArray.push(sm1MSm.swfBridgeGroup.parentBridge);
		appIdReqEvent.interAppDataToMainApp = tempArray;
		
		dispatchToBridgeParent(appIdReqEvent);
		    	
	}
	
	public function registerNewApplication(application:DisplayObject):void
	{
		if(!(application is Application || isSparkApplication(application)))
			return;
		
		if(application.root == sm1)
			return;
		
		application.root.addEventListener(FlexChangeEvent.ADD_CHILD_BRIDGE , childBridgeHandler);
		handleAlreadyPresentBridges(application);
	}
	
	private function handleAlreadyPresentBridges(application:DisplayObject):void
	{
		var currentSysManager:IMarshalSystemManager = (application as IUIComponent).systemManager as IMarshalSystemManager
		
		if(!currentSysManager)
			return;
			
		var childBridges:Array;
		if(currentSysManager && currentSysManager.swfBridgeGroup)
			childBridges = currentSysManager.swfBridgeGroup.getChildBridges();
		if(childBridges && childBridges.length)
		{
			var len:int = childBridges.length;
			var index:int = 0;
			while(index < len)
			{
				handleBridge(childBridges[index] as IEventDispatcher);
				index++;
			}
		}
	}
	
	public function registerNewFlexNativeMenu(menu:Object, sm:DisplayObject):void
	{
		createDelegateForFlexNativeMenu(menu, sm);
	}
	
	private function createDelegateForFlexNativeMenu(menu:Object, sm:DisplayObject):Boolean
	{
		var component:IAutomationObject = menu as IAutomationObject;
		var retValue:Boolean = false;
		var appDomain:ApplicationDomain;
		var className:String = "mx.controls::FlexNativeMenu";
		if(!sm)
		{
	        var factory:IFlexModuleFactory = ModuleManager.getAssociatedFactory(menu);
	        if (factory != null)
    	    {
        	    appDomain = ApplicationDomain(factory.info()["currentDomain"]);
	        }
	        else
	        {
	        	var message:String = "Factory module failure";
				traceMessage("AutomationManager","createDelegateForFlexNativeMenu()",message);
	        }
		}
		else
		{
			appDomain = (sm.loaderInfo) ? sm.loaderInfo.applicationDomain :
											ApplicationDomain.currentDomain;
		}
		
		var compClass:Class = appDomain.getDefinition(className) as Class;
		var mainComponentClass:Class = compClass;
		var delegateClass:Class = Automation.delegateDictionary[compClass] as Class;
		
		if(!delegateClass)
		{
			var componentClass:String = className;
			do 
			{
				try 
				{
					className = getQualifiedSuperclassName(appDomain.getDefinition(className));
					compClass = appDomain.getDefinition(className) as Class;
					delegateClass = Automation.delegateDictionary[compClass] as Class;
				}
				catch(e:Error)
				{
					traceMessage("AutomationManager","createDelegateForFlexNativeMenu()",e.message);
					break;
				}
			}
			while(!delegateClass);
			
			Automation.delegateDictionary[mainComponentClass] = delegateClass; 
			//trace("Added mapping for : " + componentClass);
		}

		var c:Class = delegateClass;
		if (c)
		{
			try
			{
				var delegate:Object = new c (menu);
			}
			catch(e:Error)
			{
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegateForFlexNativeMenu()",e.message);
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegateForFlexNativeMenu()","Delegate object could not be created");
			}
			
			try
			{
				component.automationDelegate = delegate;
				retValue = true;
			}
			catch(e:Error)
			{
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegateForFlexNativeMenu()",e.message);
				Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegateForFlexNativeMenu()","object created but delegates not set");
			}
		}
		else
			Automation.automationDebugTracer.traceMessage("AutomationManager","createDelegateForFlexNativeMenu()", "Unable to find definition for class : " + className);
			
		return retValue;
	}
	
	public function registerNewWindow(newWindow:DisplayObject):void
	{
		// we need to find a uniqueId for this window in Automation Manager
		// we are forming the unique id string as 
		// 'applicationName'::_::AIRWindow_index
		lastRegisteredWindowCount++;
		var currentWindowId:String = Automation.getMainApplication().automationName+ airWindowIdFixedString+
			String(lastRegisteredWindowCount);
		
		// we need bi directional mapping as we get the id we need to identify the window
		// later from the plugin
		allAirWindowsToIdDictionary[newWindow] = currentWindowId;
		allAirIdToWindowsDictionary[currentWindowId] = newWindow;
		// store the window in the list so that we can analyse the windows for eventhandling part.
		allAirWindowList.push(newWindow);
		
		// we need to dispatch an event so that tool library will try to coomunicate 
		// to the plugin using this id to get associate the hwnd with this id.
		dispatchEvent(new AutomationAirEvent(AutomationAirEvent.NEW_AIR_WINDOW,
			true,true,currentWindowId));
			
		inMouseSequence = false;
		createDelegate(newWindow);
		addDelegates(newWindow);
		newWindow.stage.addEventListener(Event.ADDED, childAddedHandler, false, 0, true);
		
		
		var sm2:ISystemManager = (newWindow  as IUIComponent).systemManager;
		var sm2MSm:IMarshalSystemManager = IMarshalSystemManager((newWindow  as IUIComponent).systemManager.getImplementation("mx.managers::IMarshalSystemManager"));
		if(!sm2)
			return;
			
			var windowMainListenerObj:IEventDispatcher = getMainListenerObject(sm2,sm2MSm);
			
			addListenerToAllApplications(windowMainListenerObj,sm2,sm2MSm,true);
			addEventListenersToAllChildApplicationsOfPassedSystemManager(sm2,sm2MSm,eventDetailsFromToolToChildren,true);
			
			sm2.addEventListener(FlexChangeEvent.ADD_CHILD_BRIDGE , childBridgeHandler);
			sm2.addEventListener(AutomationRecordEvent.RECORD,
            						recordHandler, false, EventPriority.DEFAULT_HANDLER, true);
         
            sm2.getSandboxRoot().addEventListener(MouseEvent.MOUSE_DOWN,
                                captureIDFromMouseDownEvent, true, 0, true);
                               
            sm2.addEventListener(KeyboardEvent.KEY_DOWN,
                                captureIDFromKeyDownEvent, true, 0, true);
            //ideally we would listen in the bubble phase so
            //we'd get this last and all components have had a chance
            //to react and record events, but some components are stopping
            //the propagation so capture first and flush events
            //in a delayed manner
            sm2.getSandboxRoot().addEventListener(MouseEvent.CLICK,
                                onEndMouseSequence, true, 0, true);
            sm2.getSandboxRoot().addEventListener(MouseEvent.DOUBLE_CLICK,
                                onEndMouseSequence, true, 0, true);
                                
           //	sm2.getSandboxRoot().addEventListener(SandboxMouseEvent.CLICK_SOMEWHERE,
           //                     onEndMouseSequence, true, 0, true);
           // sm2.getSandboxRoot().addEventListener(SandboxMouseEvent.DOUBLE_CLICK_SOMEWHERE,
            //                    onEndMouseSequence, true, 0, true);
                                
            sm2.addEventListener(KeyboardEvent.KEY_UP,
                                onEndKeySequence, true, 0, true);
            //Ideally we'd flush events after the last click (or double click)
            //however the player has a bug where it doesn't always send click
            //events (and also there can be legitimate times when a click
            //event won't come through, souch as a mouse down, mouse move off 
            //the component then a mouse up), so do a timed flush after the
            //mouse up (it needs to be after any click events that might occur)
            sm2.getSandboxRoot().addEventListener(MouseEvent.MOUSE_UP,
                                onEndMouseSequence, true, 0, true);
            //sm2.getSandboxRoot().addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,
              //                  onEndMouseSequence, true, 0, true);
			sm2.getSandboxRoot().addEventListener(FocusEvent.KEY_FOCUS_CHANGE, keyFocusChangeHandler, false, 0, true);
		
			
	}
	
    public function getAIRWindowUniqueID(newWindow:DisplayObject):String
    {
    	return allAirWindowsToIdDictionary[newWindow];
    }
  
	
	 public function getApplicationNameFromAutomationIDPart(objectIdPart:AutomationIDPart):String
     {
     	
        // check whether the current class is an AIR window as it is the another object
        // which can be the first level 
        // we have added a property by name 'applicationName' which is applicable only 
        // for the top level windows for AIR
        if (objectIdPart.hasOwnProperty(AutomationManager.airWindowIndicatorPropertyName))	
        {
        	// get the automationName
        	//var currentAutomationName:String = objectIdPart["automationName"];
        	var currentAutomationName:String = getPassedUniqueName(objectIdPart);
        	var appNameArray:Array = currentAutomationName.split(airWindowIdFixedString);
        	if(appNameArray && appNameArray.length)
        		return appNameArray[0];
        }
        	
        // if we reach here we are not the AIR top level window 
        // hence we can use the automationName to get the automation class name
	  	 //return (objectIdPart["automationName"].toString());
	  	 return getPassedUniqueName(objectIdPart);
     }
	private function getPassedUniqueName(part:AutomationIDPart):String
	{
		if(part.hasOwnProperty("automationName"))
	 	{
	 		if(part["automationName"] is RegExp)
	 		{
	 			var obj1:RegExp = part["automationName"] as RegExp;
	 			return obj1.source;
	 		}
	 		else
	   			return (part["automationName"].toString());
	   		
	  	}
	 	else if(part.hasOwnProperty("id"))
	 	{
	 		if(part["id"] is RegExp)
	 		{
	 			var obj:RegExp = part["id"] as RegExp;
	 			return obj.source;
	 		}
	 		else
	   			return (part["id"].toString());
	  	}
	  	else
 		{
 			// if we dont get any of the above conditions, we cannot support the
 			// marhslling. Hence we assume it is a single application scenario
 			// and get the current application name
   			return getUniqueApplicationID();
   		}
	}
	
	public function getAIRWindow(windowId:String):DisplayObject
	{
		if(windowId=="")
			return Automation.getMainApplication() as DisplayObject;
			
		return allAirIdToWindowsDictionary[windowId];
	}
	
	
   public function getAIRWindowUniqueIDFromObjectIDString(objectId:String ):String
   {
   		var objectID:AutomationID  = AutomationID.parse(objectId);
   		
   		// clone the automationID
	    var rid:AutomationID = objectID.clone();
           
        //remove the application
        var objectIdPart:AutomationIDPart = rid.removeFirst();
        
        return getAIRWindowUniqueIDFromAutomationIDPart(objectIdPart);
   }
   
   public function getAIRWindowUniqueIDFromAutomationIDPart(objectIdPart:AutomationIDPart ):String
   {
        
   	   // check whether the current class is an AIR window as it is the another object
        // which can be the first level 
        // we have added a property by name 'applicationName' which is applicable only 
        // for the top level windows for AIR
        if (objectIdPart.hasOwnProperty(AutomationManager.airWindowIndicatorPropertyName))	
        {
        	// get the automationName
        	//return objectIdPart["automationName"];
        	return getPassedUniqueName(objectIdPart);
        
        }
        // if we reach here we are not the AIR top level window 
        // hence we can use the automationName to get the automation class name
	  	 return null;
   }
   
   public  function getTopApplicationIndex(objectList:Array):int
    {
    	// we need to find the application which can be on the top. This is based on 
    	// the order of the SWFLoader not based on the order of applicaiton loading.
    	// let us for the application name list.
    	if(objectList)
    	{
    		var count:int  = objectList.length;
    		if(count > 1)
    		{
	    		var appNames:Array = new Array();
	    		var selectedObjectIndices:Array = new Array();
	    		var index:int  = 0;
	    		while(index < count)
	    		{
	    			var curentObj:Object = objectList[index];
	    			appNames.push(curentObj["applicationName"]); 
	    			selectedObjectIndices.push(index);
	    			index++;
	    		}
	    		
	    		var requiredIndex:int = 0;
	    		var higherOrderObject:Array = new Array();
	    		var indexToSort:int = 1;
	    		while(selectedObjectIndices.length > 1)
	    		{
	    			 var resultObj:Object = sortCurrentList(appNames,selectedObjectIndices,indexToSort);
	    			 appNames = new Array();
	    			 selectedObjectIndices = new Array();
	    			 appNames = resultObj["slectedAppNames"] as Array;
	    			 selectedObjectIndices = resultObj["selectedObjectIndices"]  as Array;
	    			 indexToSort = indexToSort+2;
	    		}
	    		
	    		return selectedObjectIndices[0];
    		}
    		else 
    			return 0;
    		
    		
    	}
    	return -1; 
    }
    
    private function sortCurrentList(passedNamesArray:Array , passesSelectedObjectIndices:Array, indexToSort:int):Object
    {
    	// find the higher order swf loader number from the current object.
    	var  highestSwfOrder:int = -1;
    	var count:int = passedNamesArray.length;
    	var index:int  = 0;
    	var selectedAppNames:Array = new Array();
    	var selectedObjectIndices:Array = new Array();
      	while(index < count)
    	{
    		var splitNames:Array = (passedNamesArray[index]as String).split("_");// TBD use constant
    		if(splitNames.length > indexToSort)
    		{
    			var currentOrderNumber:int = int(splitNames[splitNames.length-indexToSort-1]);
    			if( currentOrderNumber > highestSwfOrder)
    			{
    				highestSwfOrder = currentOrderNumber;
    				// clear the current order info arrays 
    				selectedAppNames = new Array();
    				selectedObjectIndices = new Array();
    				selectedAppNames.push(passedNamesArray[index]);
    				selectedObjectIndices.push(passesSelectedObjectIndices[index]);
    			}
    			else if (currentOrderNumber == highestSwfOrder)
    			{
    				selectedAppNames.push(passedNamesArray[index]);
    				selectedObjectIndices.push(passesSelectedObjectIndices[index]);
    			}
    		}
    		index++;
    	}
    	
    	var resultObj:Object = { slectedAppNames:selectedAppNames, selectedObjectIndices:selectedObjectIndices};
    	
    	return resultObj;
    	
    }
	
	public  function getAutomationChildrenArray(object:Object):Array
	{
		var automationObject:IAutomationObject = object as IAutomationObject;
		var childArray:Array = null;
		if (automationObject)
		{
			childArray =  automationObject.getAutomationChildren();
		}
		/*
		if(object.hasOwnProperty("getAutomationChildren") )
			return object.getAutomationChildren();
		if(object.automationDelegate.hasOwnProperty("getAutomationChildren") )
			return object.automationDelegate.getAutomationChildren();
		*/
		if(childArray)
			return childArray;
		
		// let us ensure that we are not returning a null array.
		return new Array();
	}
	public function  getPropertyValueFromPart(part:Object,obj:Object, 
											  pd:IAutomationPropertyDescriptor,
											  relativeParent:IAutomationObject = null):Object
	{
		return getMemberFromPartOrObject(part,obj, pd.name);
		
	}
	
	
	public function getMemberFromPartOrObject(part:Object,obj:Object, 
											  name:String):Object
	{
		//var part:Object;
		var component:Object;
		
		//part = createIDPart(obj as IAutomationObject);
		component = obj;
		
		var result:Object = null;
		
		if (part != null && name in part)
			result = part[name];
		else if (name in obj)
			result = obj[name];
		else if (component != null)
		{
			if (name in component)
				result = component[name];
			else if (component is IStyleClient)
				result = IStyleClient(component).getStyle(name);
		}
		
		return result;
	}
	
	
	/**
	 *  @private
	 */
	/*
	public function createIDPartForSpecifiedProperties(properties:Array,
													   obj:IAutomationObject, 
													   parent:IAutomationObject = null):AutomationIDPart
	{
		// create the part only with the requried properties
		if (parent == null)
			parent = getParent(obj, null, true);
	
		return helpCreateIDPartWithRequiredProperties(parent, obj,properties);		
	}
	*/
	
	/**
	 *  @private
	 */
	public function createIDPartForSpecifiedProperties(properties:Array,obj:IAutomationObject, 
								 parent:IAutomationObject = null):AutomationIDPart
	{
		if (parent == null)
			parent = getParent(obj, null, true);
		
		var parentObj:Object = parent as Object;
		// temp solution till we get the interfaces part of UIComponent
		
			var part:AutomationIDPart = parent 
			? parent.createAutomationIDPartWithRequiredProperties(obj,properties) as AutomationIDPart
			: helpCreateIDPartWithRequiredProperties(null, obj,properties);

		/*
		var part:AutomationIDPart = (parentObj &&(parentObj.automationDelegate) && (parentObj.automationDelegate.hasOwnProperty("createAutomationIDPartWithRequiredProperties")))
				? parentObj.automationDelegate.createAutomationIDPartWithRequiredProperties(obj,properties) as AutomationIDPart
				: helpCreateIDPartWithRequiredProperties(null, obj,properties);
		*/
		
		return part;
	}
	
	
	/**
	 *  @private
	 *
	 *  Helper implementation of IAutomationIDHelper.  Creates an id for
	 *  a given child.  This should not be used, instead use createID,
	 *  or createIDPart.
	 */
	
	public function helpCreateIDPartWithRequiredProperties(parent:IAutomationObject,
														  child:IAutomationObject,properyNamesList:Array,
														  automationNameCallback:Function = null,
														  automationIndexCallback:Function = null):AutomationIDPart
	{
		if(!properyNamesList)
			return helpCreateIDPart(parent,child,automationNameCallback,automationIndexCallback);
		else
			return getIdPart(parent,child,properyNamesList,automationNameCallback,automationIndexCallback);
	}
	
	
	private function getIdPart(parent:IAutomationObject,
							   child:IAutomationObject,properyNamesList:Array = null,
							   automationNameCallback:Function = null,
							   automationIndexCallback:Function = null):AutomationIDPart
	{
		var part:AutomationIDPart = new AutomationIDPart();
		//It doesn't matter if a property is null
		//add it anyways, because the callee asked for it
		//and not adding it will confuse QTP since we've
		//told it already about the properties in the env file
		//If this causes a problem and we need to add the if
		//null checks back, then be sure to update ToolAdapter
		//to not return null properties in Learn and ActiveScreen
		var indexCalculated:Boolean = false;
		for (var propNo:int = 0; propNo < properyNamesList.length; ++propNo)
		{
			var propertyName:String = properyNamesList[propNo];
			
			if (propertyName == "id")
			{
				part.id = child is IDeferredInstantiationUIComponent
					? IDeferredInstantiationUIComponent(child).id
					: null;    
				
				if ((part.id == null) && (parent == null))
				{ 
					//trace ("inside the helpCreateIDPart - id "+ child.automationName);
					// currently we are in the application object.
					// this is a temp fix till we have AIR delegates in place.
					// we need the application iD of this component instead of the id
					if(Automation.getMainApplication().hasOwnProperty("applicationID"))// this should work for AIR app's
					{
						part.id = Automation.getMainApplication().applicationID;
						//trace ("inside the helpCreateIDPart - id "+ part.id );
					}
					else
					{
						//we are in flex app hosted from Air app
						part.id = processAppIDFromUniqueAppID();
					}
				}
			}
			else if (propertyName == "automationName")
				part.automationName = (automationNameCallback == null 
					? child.automationName 
					: automationNameCallback(child));
			else if (propertyName == "automationIndex")
			{
				//note that parent can be null if it's the parentApplication
				part.automationIndex = (automationIndexCallback == null ? 
					getChildIndex(getParent(child), child)
					: automationIndexCallback(child));
				indexCalculated = true;
			}
			else if (propertyName == "className")
				part.className = AutomationClass.getClassName(child);
			else if (propertyName == "automationClassName")
				part.automationClassName = getAutomationClassName(child);
			else if (propertyName == AutomationManager.airWindowIndicatorPropertyName)
			{
				// we added this property to identify the airtoplevel windows
				part.isAIRWindow = true;
			}
			else
			{
				if (propertyName in child)
					part[propertyName] = child[propertyName];
				else
				{
					part[propertyName] = "";
					/// TBD
					
					var message:String = resourceManager.getString(
						"automation_agent", "notDefined", [propertyName, child]);
					//trace(message);
					/*
					throw new Error(message);
					*/
				}
			}
		}
		
		if ("automationName" in part && part.automationName == null)
		{
			
			if(indexCalculated)
				part.automationName = part.automationIndex;
			else
			{
				// calculate the index and assign the same as the automation value
				part.automationName = (automationIndexCallback == null ? 
					getChildIndex(getParent(child), child)
					: automationIndexCallback(child));
			}
		}
		
		return part;
	}
	
	public function traceMessage(className:String, methodName:String, message:String):void
	{
		trace(className+":"+methodName+" - "+message);
	}
	
	private function isSparkApplication(obj:DisplayObject):Boolean
	{
		if(AutomationHelper.isRequiredSparkClassPresent()){
			var sparkAppClass:Class = Class(ApplicationDomain.currentDomain.getDefinition("spark.components.Application"));
			if(obj is sparkAppClass)	
				return true;
		}
			
		return false;
	}
}

}