////////////////////////////////////////////////////////////////////////////////
//
//  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.managers.marshalClasses
{
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.IEventDispatcher;
import flash.geom.Rectangle;
import flash.geom.Point;

import mx.core.FlexGlobals;
import mx.core.IFlexDisplayObject;
import mx.core.IFlexModuleFactory;
import mx.core.ISWFLoader;
import mx.core.IUIComponent;
import mx.core.mx_internal;
import mx.events.DynamicEvent;
import mx.events.InterManagerRequest;
import mx.events.MoveEvent;
import mx.events.Request;
import mx.events.SandboxMouseEvent;
import mx.events.SWFBridgeRequest;
import mx.managers.IActiveWindowManager;
import mx.managers.IFocusManagerContainer;
import mx.managers.IMarshalSystemManager;
import mx.managers.ISystemManager;
import mx.managers.PopUpManagerImpl;
import mx.managers.PopUpData;
import mx.managers.SystemManager;
import mx.managers.SystemManagerGlobals;
import mx.managers.SystemManagerProxy;
import mx.styles.IStyleClient;
import mx.utils.NameUtil;

use namespace mx_internal;

[ExcludeClass]

[Mixin]

/**
 *  @private
 *  A SystemManager has various types of children,
 *  such as the Application, popups, 
 *  tooltips, and custom cursors.
 *  You can access the just the custom cursors through
 *  the <code>cursors</code> property,
 *  the tooltips via <code>toolTips</code>, and
 *  the popups via <code>popUpChildren</code>.  Each one returns
 *  a SystemChildrenList which implements IChildList.  The SystemManager's
 *  IChildList methods return the set of children that aren't popups, tooltips
 *  or cursors.  To get the list of all children regardless of type, you
 *  use the rawChildrenList property which returns this SystemRawChildrenList.
 */
public class PopUpManagerMarshalMixin
{
    include "../../core/Version.as";

	//--------------------------------------------------------------------------
	//
	//  Class Method
	//
	//--------------------------------------------------------------------------
	
	public static function init(fbs:IFlexModuleFactory):void
	{
		if (!PopUpManagerImpl.mixins)
			PopUpManagerImpl.mixins = [];
        if (PopUpManagerImpl.mixins.indexOf(PopUpManagerMarshalMixin) == -1)
        {
		    PopUpManagerImpl.mixins.push(PopUpManagerMarshalMixin);
		    PopUpManagerImpl.popUpInfoClass = MarshalPopUpData;
        }
	}

	//--------------------------------------------------------------------------
	//
	//  Constructor
	//
	//--------------------------------------------------------------------------

	/**
	 *  Constructor.
	 */
	public function PopUpManagerMarshalMixin(owner:PopUpManagerImpl = null)
	{
		super();

        if (!owner)
            return;
      
		this.popUpManager = owner;
		sm = ISystemManager(SystemManagerGlobals.topLevelSystemManagers[0]);
		popUpManager.addEventListener("initialize", initializeHandler);
		popUpManager.addEventListener("addPopUp", addPopUpHandler);
		popUpManager.addEventListener("addPlaceHolder", addPlaceHolderHandler);
		popUpManager.addEventListener("addedPopUp", addedPopUpHandler);
		popUpManager.addEventListener("topLevelSystemManager", topLevelSystemManagerHandler);
		popUpManager.addEventListener("isTopLevelRoot", isTopLevelRootHandler);
		popUpManager.addEventListener("bringToFront", bringToFrontHandler);
		popUpManager.addEventListener("createModalWindow", createModalWindowHandler);
		popUpManager.addEventListener("updateModalMask", updateModalMaskHandler);
		popUpManager.addEventListener("createdModalWindow", createdModalWindowHandler);
		popUpManager.addEventListener("showModalWindow", showModalWindowHandler);
		popUpManager.addEventListener("blurTarget", blurTargetHandler);
		popUpManager.addEventListener("hideModalWindow", hideModalWindowHandler);
		popUpManager.addEventListener("addMouseOutEventListeners", addMouseOutEventListenersHandler);
		popUpManager.addEventListener("removeMouseOutEventListeners", removeMouseOutEventListenersHandler);
		popUpManager.addEventListener("popUpRemoved", popUpRemovedHandler);
	}

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

	/**
	 *  @private
	 */
	private var popUpManager:PopUpManagerImpl;

    private var sm:ISystemManager;

	//--------------------------------------------------------------------------
	//
	//  Methods
	//
	//--------------------------------------------------------------------------


	public function initializeHandler(event:Event):void
	{
        sm.addEventListener(SWFBridgeRequest.CREATE_MODAL_WINDOW_REQUEST, createModalWindowRequestHandler, false, 0, true);
        sm.addEventListener(SWFBridgeRequest.SHOW_MODAL_WINDOW_REQUEST, showModalWindowRequest, false, 0, true);
        sm.addEventListener(SWFBridgeRequest.HIDE_MODAL_WINDOW_REQUEST, hideModalWindowRequest, false, 0, true);
	}


	public function addPopUpHandler(event:Request):void
	{
		var sm:ISystemManager = event.value.sm as ISystemManager;
		var parent:DisplayObjectContainer = event.value.parent as DisplayObjectContainer;
        if (!sm)
        {
            // check if parent is our sandbox root
            sm = ISystemManager(SystemManagerGlobals.topLevelSystemManagers[0]);
            if (sm.getSandboxRoot() != parent)
            {
                //trace("error: popup root was not SystemManager");
                return; // and maybe a nice error message
            }
        }

		// if using a bridge, then create a System Manager Proxy to host
		// the popup. The System Manager Proxy is the display object
		// added to the top-level system manager's children, not
		// the popup itself.
		var sbRoot:DisplayObject = sm.getSandboxRoot();
		var request:SWFBridgeRequest = null;
		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));
		if (mp.useSWFBridge())
		{
			if (sbRoot != sm)
			{
				var smp:SystemManagerProxy = new SystemManagerProxy(sm);
				request = new SWFBridgeRequest(SWFBridgeRequest.ADD_POP_UP_REQUEST, false, false,
				                                    mp.swfBridgeGroup.parentBridge,
													{ window: DisplayObject(smp),
														parent: parent,
														modal: event.value.modal,
														childList: event.value.childList});
				sbRoot.dispatchEvent(request);
				event.value = smp;
				event.preventDefault();
			}
		}
	}

	public function addPlaceHolderHandler(event:DynamicEvent):void
	{
		var sm:ISystemManager = event.sm as ISystemManager;
		var window:IFlexDisplayObject = event.window as IFlexDisplayObject
		var sbRoot:DisplayObject = sm.getSandboxRoot();
		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));

		// add a placeholder for an untrusted popup if this system manager
		// is hosting the popup.
		if (!sm.isTopLevelRoot() && sbRoot && DisplayObject(sm) == sbRoot)
		{
			var request:SWFBridgeRequest = new SWFBridgeRequest(SWFBridgeRequest.ADD_POP_UP_PLACE_HOLDER_REQUEST, false, false, null, { window: DisplayObject(window)});
			request.requestor = mp.swfBridgeGroup.parentBridge;
			request.data.placeHolderId = NameUtil.displayObjectToString(DisplayObject(window));
			sm.dispatchEvent(request);
		} 
	}

	public function addedPopUpHandler(event:DynamicEvent):void
	{
		var smp:ISystemManager = ISystemManager(event.systemManager);

		var awm:IActiveWindowManager = 
			IActiveWindowManager(smp.getImplementation("mx.managers::IActiveWindowManager"));

		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(smp.getImplementation("mx.managers::IMarshalSystemManager"));

        if (!(smp is SystemManagerProxy) && mp.useSWFBridge())
         	// We want the top-level root to activate the window.
         	mp.dispatchActivatedWindowEvent(DisplayObject(event.window));
        else
            awm.activate(IFocusManagerContainer(event.window));
	}

	public function topLevelSystemManagerHandler(event:Request):void
	{
		var parent:DisplayObjectContainer = event.value as DisplayObjectContainer;
		var localRoot:DisplayObjectContainer;

		if (parent.parent is SystemManagerProxy)
			localRoot = DisplayObjectContainer(SystemManagerProxy(parent.parent).systemManager);
		else if (parent is IUIComponent && IUIComponent(parent).systemManager is SystemManagerProxy)
			localRoot = DisplayObjectContainer(SystemManagerProxy(IUIComponent(parent).systemManager).systemManager);

		if (localRoot)
		{
			event.value = localRoot;
			event.preventDefault();
		}
	}


	public function isTopLevelRootHandler(event:Request):void
	{
        // Only need to calc the visible rect when the sandbox root is an untrusted application.
        // Otherwise the alert will float over the entire application.
        if (sm != sm.getSandboxRoot())
        {
            var request:InterManagerRequest = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST, false, false,
                                                        "isTopLevelRoot");
            sm.getSandboxRoot().dispatchEvent(request);
            event.value = Boolean(request.value);
			event.preventDefault();
        }
	}

	public function bringToFrontHandler(event:DynamicEvent):void
	{
		var o:PopUpData = event.popUpData;
		var popUp:IFlexDisplayObject = event.popUp;
        const sm:ISystemManager = ISystemManager(popUp.parent);
        if (sm is SystemManagerProxy)
        {
            // Since the proxy is parented to the SystemManager we need to 
            // be it to the front, not the pop up.
            var request:InterManagerRequest = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST, 
                                    false, false,
                                    "bringToFront", 
                                    {topMost: o.topMost, popUp: sm}); 
            sm.getSandboxRoot().dispatchEvent(request);
            event.preventDefault();
        }
	}

	public function createModalWindowHandler(event:DynamicEvent):void
	{
		var o:MarshalPopUpData = event.popUpData;
		var popUp:IFlexDisplayObject = event.popUp;
		var popupStyleClient:IStyleClient = popUp as IStyleClient;

        // set alpha of the popup and get it out of the focus loop
        if (!isNaN(o.modalTransparency))
            o.modalWindow.alpha = o.modalTransparency;
		o.modalTransparency = o.modalWindow.alpha;
			
        if (!isNaN(o.modalTransparencyColor))
            event.color = o.modalTransparencyColor;
        o.modalTransparencyColor = event.color;

		event.preventDefault();
    }

	public function updateModalMaskHandler(event:DynamicEvent):void
	{
		var o:MarshalPopUpData = event.popUpData;
        if (o.exclude)
        {
            o.modalMask = new Sprite();
            updateModalMask(sm, o.modalWindow, 
                            o.useExclude ? o.exclude : null, 
                            o.excludeRect, o.modalMask);    
            o.modalWindow.mask = o.modalMask;
            event.childrenList.addChild(o.modalMask);
            
            // update the modal window mask when the size or position of the area 
            // we are excluding changes.
            o.exclude.addEventListener(Event.RESIZE, o.resizeHandler);
            o.exclude.addEventListener(MoveEvent.MOVE, o.resizeHandler);
        }
    }
    
    public function createdModalWindowHandler(event:DynamicEvent):void
    {
		var o:MarshalPopUpData = event.popUpData;
		var popUp:IFlexDisplayObject = event.popUp;
		var popupStyleClient:IStyleClient = popUp as IStyleClient;

        var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));

        if (mp.useSWFBridge())
        {
            if (popupStyleClient)
            {
                o.modalTransparencyDuration = popupStyleClient.getStyle("modalTransparencyDuration");
                o.modalTransparencyBlur = popupStyleClient.getStyle("modalTransparencyBlur");
            }

            dispatchModalWindowRequest(SWFBridgeRequest.CREATE_MODAL_WINDOW_REQUEST, sm, sm.getSandboxRoot(), o, event.visibleFlag);
        }            
	}

    /**
     *  @private
     * 
     *  Update a mask to exclude the area of the exclude parameter from the area 
     *  of the modal window parameter.
     * 
     *  @param sm The system manager that hosts the modal window
     *  @param modalWindow The base area of the mask
     *  @param exclude The area to exlude from the mask, may be null.
     *  @param excludeRect An optionally rectangle that is included in the area
     *  to exclude. The rectangle is in global coordinates.
     *  @param mask A non-null sprite. The mask is rewritten for each call.
     * 
     */  
    mx_internal static function updateModalMask(sm:ISystemManager,
                                     modalWindow:DisplayObject, 
                                     exclude:IUIComponent, 
                                     excludeRect:Rectangle,
                                     mask:Sprite):void
    {
        var modalBounds:Rectangle = modalWindow.getBounds(DisplayObject(sm));
        var excludeBounds:Rectangle;
        var pt:Point;
            
        if (exclude is ISWFLoader) 
        {
            excludeBounds = ISWFLoader(exclude).getVisibleApplicationRect();
            pt = new Point(excludeBounds.x, excludeBounds.y);
            pt = DisplayObject(sm).globalToLocal(pt);
            excludeBounds.x = pt.x;
            excludeBounds.y = pt.y;    
        }
        else if (!exclude)
            excludeBounds = modalBounds.clone();    // don't exclude anything extra
        else 
            excludeBounds = DisplayObject(exclude).getBounds(DisplayObject(sm));
        
        // apply excludeRect to the result
        if (excludeRect)
        {
            pt = new Point(excludeRect.x, excludeRect.y);
            pt = DisplayObject(sm).globalToLocal(pt);
            var rect:Rectangle = new Rectangle(pt.x, pt.y, excludeRect.width, excludeRect.height);
            excludeBounds = excludeBounds.intersection(rect);
        }
        
        mask.graphics.clear();
        mask.graphics.beginFill(0x000000);
        
        // Fill the mask in three logical rows
        // 1. Above the exclude bounds
        if (excludeBounds.y > modalBounds.y)
            mask.graphics.drawRect(modalBounds.x, modalBounds.y, 
                                   modalBounds.width, excludeBounds.y - modalBounds.y);
                     
        // 2. Left and right of the exclude bounds
        if (modalBounds.x < excludeBounds.x)              
            mask.graphics.drawRect(modalBounds.x, excludeBounds.y, 
                                   excludeBounds.x - modalBounds.x, excludeBounds.height);
                                   
        if ((modalBounds.x + modalBounds.width) > (excludeBounds.x + excludeBounds.width))
            mask.graphics.drawRect(excludeBounds.x + excludeBounds.width, 
                                   excludeBounds.y, 
                                   modalBounds.x + modalBounds.width - excludeBounds.x - excludeBounds.width, 
                                   excludeBounds.height);
                                   
        // 3. Below the exclude bounds
        if ((excludeBounds.y + excludeBounds.height) < (modalBounds.y + modalBounds.height))
            mask.graphics.drawRect(modalBounds.x, excludeBounds.y + excludeBounds.height, 
                                   modalBounds.width, 
                                   modalBounds.y + modalBounds.height - excludeBounds.y - excludeBounds.height);
        mask.graphics.endFill();
                         
    }                                     

    private function dispatchModalWindowRequest(type:String, 
                                                sm:ISystemManager, 
                                                sbRoot:DisplayObject, 
                                                o:MarshalPopUpData,
                                                visibleFlag:Boolean):void
    {
        // if our first target is a sandbox root that is the top level root,
        // then we don't need to send a modal request. 
        if (!o.isRemoteModalWindow && sm != sbRoot)
        {
            var request:InterManagerRequest = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST, false, false,
                                                        "isTopLevelRoot");
            sbRoot.dispatchEvent(request);
            if (Boolean(request.value))
                return;
        }
        
		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));

        var modalRequest:SWFBridgeRequest = new SWFBridgeRequest(type, false, false, null,
												{ skip: !o.isRemoteModalWindow && sm != sbRoot,
												  useExclude: o.useExclude,   
												  show: visibleFlag,
												  remove: false,
												  transparencyDuration: o.modalTransparencyDuration,
												  transparency: o.modalTransparency,
												  transparencyColor: o.modalTransparencyColor,
												  transparencyBlur: o.modalTransparencyBlur});
        var bridge:IEventDispatcher = mp.swfBridgeGroup.parentBridge;; 
        modalRequest.requestor = bridge;
        bridge.dispatchEvent(modalRequest);
    }
    
	public function showModalWindowHandler(event:DynamicEvent):void
	{
		event.preventDefault();

		var o:MarshalPopUpData = event.popUpData;
		var popUp:IFlexDisplayObject = o.owner as IFlexDisplayObject;
        var sm:ISystemManager = event.systemManager;

        if (!isNaN(o.modalTransparencyDuration))
            event.duration = o.modalTransparencyDuration;
        o.modalTransparencyDuration = event.duration;

        if (!isNaN(o.modalTransparency))
            event.alpha = o.modalTransparency;
        o.modalTransparency = event.alpha;

        if (!isNaN(o.modalTransparencyBlur))
            event.blurAmount = o.modalTransparencyBlur;
    	o.modalTransparencyBlur = event.blurAmount;

		if (!isNaN(o.modalTransparencyColor))
	        event.transparencyColor = o.modalTransparencyColor;
    	o.modalTransparencyColor = event.transparencyColor;

		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));

        if (sm is SystemManagerProxy)
            sm = SystemManagerProxy(sm).systemManager;
        if (event.sendRequest && mp.useSWFBridge())
            dispatchModalWindowRequest(SWFBridgeRequest.SHOW_MODAL_WINDOW_REQUEST, sm, sm.getSandboxRoot(), o, true);
	}


	public function blurTargetHandler(event:Request):void
	{
		var o:PopUpData = event.value.popUpData;
		var popUp:IFlexDisplayObject = o.owner as IFlexDisplayObject;
        const sm:ISystemManager = ISystemManager(popUp.parent);

		var sbRoot:DisplayObject = sm.getSandboxRoot();

        var applicationRequest:InterManagerRequest = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST,
                                                           false, false,
                                                           "application",
                                                           sbRoot);
        sbRoot.dispatchEvent(applicationRequest);
        event.value = applicationRequest.value;
		event.preventDefault();
	}

	public function hideModalWindowHandler(event:DynamicEvent):void
	{
		var o:MarshalPopUpData = event.popUpData;
		var destroy:Boolean = event.destroy;

        if (destroy && o.exclude)
        {
            o.exclude.removeEventListener(Event.RESIZE, o.resizeHandler);
            o.exclude.removeEventListener(MoveEvent.MOVE, o.resizeHandler);
        }

        var sm:ISystemManager = ISystemManager(FlexGlobals.topLevelApplication.systemManager);

		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));

        if (mp.useSWFBridge())
        {
            var sbRoot:DisplayObject = sm.getSandboxRoot();
            
            // if our first target is a sandbox root that is the top level root,
            // then we don't need to send a modal request. 
            if (!o.isRemoteModalWindow && sm != sbRoot)
            {
                var request:InterManagerRequest = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST, false, false,
                                                            "isTopLevelRoot");
                sbRoot.dispatchEvent(request);
                if (Boolean(request.value))
                    return;
            }
            
            var modalRequest:SWFBridgeRequest = new SWFBridgeRequest(SWFBridgeRequest.HIDE_MODAL_WINDOW_REQUEST, false, false, null,
														{ skip: !o.isRemoteModalWindow && sm != sbRoot, 
															show: false,
															remove: destroy});
            var bridge:IEventDispatcher = mp.swfBridgeGroup.parentBridge;
            var target:IEventDispatcher;
            modalRequest.requestor = bridge;

            bridge.dispatchEvent(modalRequest);
        }
	}

    /**
     *  @private
     *  
     *  Create a modal window and optionally show it.
     */ 
    private function createModalWindowRequestHandler(event:Event):void
    {
        var request:SWFBridgeRequest;

        if (event is SWFBridgeRequest)
            request = SWFBridgeRequest(event);
        else
            request = SWFBridgeRequest.marshal(event);

        var sm:ISystemManager = popUpManager.getTopLevelSystemManager(DisplayObject(FlexGlobals.topLevelApplication));
		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));

        var sbRoot:DisplayObject = sm.getSandboxRoot();

        // process the message
        var popUpData:MarshalPopUpData = MarshalPopUpData(PopUpManagerImpl.createPopUpData());
        popUpData.isRemoteModalWindow = true;
        popUpData.systemManager = sm;
        popUpData.modalTransparency = request.data.transparency;
        
        // disable blur because we can mask the application and blur is not
        // working if we blur the modalWindow.
        popUpData.modalTransparencyBlur = 0; //request.transparencyBlur;
        popUpData.modalTransparencyColor = request.data.transparencyColor;
        popUpData.modalTransparencyDuration = request.data.transparencyDuration;

        // Get the SWFLoader to exclude.
        // The requestor may be a real SWFLoader or a sandbox bridge that 
        // requires a look up to get the SWFLoader. 
        popUpData.exclude = mp.swfBridgeGroup.getChildBridgeProvider(request.requestor) as IUIComponent;
        popUpData.useExclude = request.data.useExclude;
        popUpData.excludeRect = Rectangle(request.data.excludeRect);
        
        popUpManager.popupInfo.push(popUpData);
        
        popUpManager.createModalWindow(null, popUpData, sm.popUpChildren, request.data.show, sm, sbRoot);
    }
    
    /**
     *  @private
     *  
     *  Show a modal window.
     */ 
    private function showModalWindowRequest(event:Event):void
    {
        var request:SWFBridgeRequest = SWFBridgeRequest.marshal(event);

        if (event is SWFBridgeRequest)
            request = SWFBridgeRequest(event);
        else
            request = SWFBridgeRequest.marshal(event);

        var sm:ISystemManager = popUpManager.getTopLevelSystemManager(DisplayObject(FlexGlobals.topLevelApplication));
		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));
        var sbRoot:DisplayObject = sm.getSandboxRoot();
        
        // the highest popUpData in the list is the most recent modal window.
        // sanity check that the popupdata is really a modal window with a null
        // parent and popup window.
        var popUpData:MarshalPopUpData = findHighestRemoteModalPopupInfo();
        popUpData.excludeRect = Rectangle(request.data);
        popUpData.modalTransparency = request.data.transparency;
        
        // disable blur because we can mask the application and blur is not
        // working if we blur the modalWindow.
        popUpData.modalTransparencyBlur = 0; //request.transparencyBlur;
        popUpData.modalTransparencyColor = request.data.transparencyColor;
        popUpData.modalTransparencyDuration = request.data.transparencyDuration;

        if (popUpData.owner || popUpData.parent)
            throw new Error();              // not popUpData for a modal window
        
        popUpManager.showModalWindow(popUpData, sm);
    }
    
    /**
     *  @private
     *  
     *  Hide a modal window and optionally remove it.
     */ 
    private function hideModalWindowRequest(event:Event):void
    {
        var request:SWFBridgeRequest;
        
        // If the event is redispatched from the SystemManger it will be
        // marshalled. If the PopUpManager dispatches the event using
        // the sandbox root it will come here directly.
        if (event is SWFBridgeRequest)
            request = SWFBridgeRequest(event);
        else
            request = SWFBridgeRequest.marshal(event);

        var sm:ISystemManager = popUpManager.getTopLevelSystemManager(DisplayObject(FlexGlobals.topLevelApplication));
        var sbRoot:DisplayObject = sm.getSandboxRoot();
        
        // the highest popUpData in the list is the most recent modal window.
        // sanity check that the popupdata is really a modal window with a null
        // parent and popup window.
        var popUpData:MarshalPopUpData = findHighestRemoteModalPopupInfo();
        if (!popUpData || popUpData.owner || popUpData.parent)
            throw new Error();              // not popUpData for a modal window
                    
        popUpManager.hideModalWindow(popUpData, request.data.remove);
        
        // handle removing popup window 
        if (request.data.remove)
        {
            popUpManager.popupInfo.splice(popUpManager.popupInfo.indexOf(popUpData), 1);
			var awm:IActiveWindowManager = 
				IActiveWindowManager(sm.getImplementation("mx.managers::IActiveWindowManager"));
            awm.numModalWindows--;
        }
    }

    private function popUpRemovedHandler(event:DynamicEvent):void
    {

		var o:PopUpData = event.popUpData;
		var popUp:IFlexDisplayObject = o.owner as IFlexDisplayObject;
		var sm:ISystemManager = o.systemManager;
		var mp:IMarshalSystemManager = 
			IMarshalSystemManager(sm.getImplementation("mx.managers::IMarshalSystemManager"));

		// remove the focus manager from a bridged system manager, if any                
		if (sm is SystemManagerProxy)
		{

			var parentBridge:IEventDispatcher = mp.swfBridgeGroup.parentBridge;
			var request:SWFBridgeRequest = new SWFBridgeRequest(SWFBridgeRequest.REMOVE_POP_UP_REQUEST, false, false,
  					                            parentBridge,
        										{ window: DisplayObject(sm),
        										  parent:	o.parent,
        										  modal: o.modalWindow != null});
			sm.getSandboxRoot().dispatchEvent(request);
		}
		else if (mp.useSWFBridge())
		{
			// Must be locally hosted popup.
			// We need to remove the placeholder at the top level root
			request = new SWFBridgeRequest(SWFBridgeRequest.REMOVE_POP_UP_PLACE_HOLDER_REQUEST, false, false, null,
															{ window: DisplayObject(popUp)});
			request.requestor = mp.swfBridgeGroup.parentBridge;
			request.data.placeHolderId = NameUtil.displayObjectToString(DisplayObject(popUp));
			sm.dispatchEvent(request);
		}                    
	}

    public function addMouseOutEventListenersHandler(event:DynamicEvent):void
	{
		var o:MarshalPopUpData = event.popUpData;
		var sbRoot:DisplayObject = o.systemManager.getSandboxRoot();

        sbRoot.addEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,  o.marshalMouseOutsideHandler);
        sbRoot.addEventListener(SandboxMouseEvent.MOUSE_WHEEL_SOMEWHERE, o.marshalMouseOutsideHandler, true);
	}

    public function removeMouseOutEventListenersHandler(event:DynamicEvent):void
	{
		var o:MarshalPopUpData = event.popUpData;
		var sbRoot:DisplayObject = o.systemManager.getSandboxRoot();

        sbRoot.removeEventListener(SandboxMouseEvent.MOUSE_DOWN_SOMEWHERE,  o.marshalMouseOutsideHandler);
        sbRoot.removeEventListener(SandboxMouseEvent.MOUSE_WHEEL_SOMEWHERE, o.marshalMouseOutsideHandler, true);
	}

    /**
     *  @private
     *  Returns the PopUpData for the highest remote modal window on display.
     */
    private function findHighestRemoteModalPopupInfo():MarshalPopUpData
    {
        const n:int = popUpManager.popupInfo.length - 1;
        for (var i:int = n; i >= 0; i--)
        {
            var o:MarshalPopUpData = popUpManager.popupInfo[i];
            if (o.isRemoteModalWindow)
                return o;
        }
        return null;
    }

}

}