home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / managers / NativeDragManagerImpl.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  19.8 KB  |  553 lines
  1. package mx.managers
  2. {
  3.    import flash.desktop.Clipboard;
  4.    import flash.desktop.NativeDragManager;
  5.    import flash.desktop.NativeDragOptions;
  6.    import flash.display.BitmapData;
  7.    import flash.display.DisplayObject;
  8.    import flash.display.InteractiveObject;
  9.    import flash.events.Event;
  10.    import flash.events.IEventDispatcher;
  11.    import flash.events.MouseEvent;
  12.    import flash.events.NativeDragEvent;
  13.    import flash.geom.Point;
  14.    import flash.system.Capabilities;
  15.    import mx.core.DragSource;
  16.    import mx.core.IFlexDisplayObject;
  17.    import mx.core.IUIComponent;
  18.    import mx.core.UIComponentGlobals;
  19.    import mx.core.mx_internal;
  20.    import mx.events.DragEvent;
  21.    import mx.events.FlexEvent;
  22.    import mx.events.InterDragManagerEvent;
  23.    import mx.events.InterManagerRequest;
  24.    import mx.managers.dragClasses.DragProxy;
  25.    import mx.styles.CSSStyleDeclaration;
  26.    import mx.styles.StyleManager;
  27.    
  28.    use namespace mx_internal;
  29.    
  30.    public class NativeDragManagerImpl implements IDragManager
  31.    {
  32.       private static var sm:ISystemManager;
  33.       
  34.       private static var instance:IDragManager;
  35.       
  36.       private var _dragImage:IFlexDisplayObject;
  37.       
  38.       private var sandboxRoot:IEventDispatcher;
  39.       
  40.       private var _relatedObject:InteractiveObject;
  41.       
  42.       private var _allowedActions:NativeDragOptions;
  43.       
  44.       private var _action:String;
  45.       
  46.       private var _clipboard:Clipboard;
  47.       
  48.       public var dragProxy:DragProxy;
  49.       
  50.       private var _dragInitiator:IUIComponent;
  51.       
  52.       private var mouseIsDown:Boolean = false;
  53.       
  54.       private var _offset:Point;
  55.       
  56.       private var _allowMove:Boolean;
  57.       
  58.       public function NativeDragManagerImpl()
  59.       {
  60.          super();
  61.          if(instance)
  62.          {
  63.             throw new Error("Instance already exists.");
  64.          }
  65.          mx_internal::registerSystemManager(sm);
  66.          sandboxRoot = sm.getSandboxRoot();
  67.          sandboxRoot.addEventListener(InterDragManagerEvent.DISPATCH_DRAG_EVENT,marshalDispatchEventHandler,false,0,true);
  68.          sandboxRoot.addEventListener(InterManagerRequest.DRAG_MANAGER_REQUEST,marshalDragManagerHandler,false,0,true);
  69.          var _loc1_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  70.          _loc1_.name = "update";
  71.          sandboxRoot.dispatchEvent(_loc1_);
  72.       }
  73.       
  74.       public static function getInstance() : IDragManager
  75.       {
  76.          if(!instance)
  77.          {
  78.             sm = SystemManagerGlobals.topLevelSystemManagers[0];
  79.             instance = new NativeDragManagerImpl();
  80.          }
  81.          return instance;
  82.       }
  83.       
  84.       private function marshalDispatchEventHandler(param1:Event) : void
  85.       {
  86.          if(param1 is InterDragManagerEvent)
  87.          {
  88.             return;
  89.          }
  90.          var _loc2_:Object = param1;
  91.          var _loc3_:DisplayObject = SystemManager.getSWFRoot(_loc2_.dropTarget);
  92.          if(!_loc3_)
  93.          {
  94.             return;
  95.          }
  96.          var _loc4_:DragEvent = new DragEvent(_loc2_.dragEventType,_loc2_.bubbles,_loc2_.cancelable);
  97.          _loc4_.localX = _loc2_.localX;
  98.          _loc4_.localY = _loc2_.localY;
  99.          _loc4_.action = _loc2_.action;
  100.          _loc4_.ctrlKey = _loc2_.ctrlKey;
  101.          _loc4_.altKey = _loc2_.altKey;
  102.          _loc4_.shiftKey = _loc2_.shiftKey;
  103.          _loc4_.draggedItem = _loc2_.draggedItem;
  104.          _loc4_.dragSource = new DragSource();
  105.          var _loc5_:Array = _loc2_.dragSource.formats;
  106.          var _loc6_:int = int(_loc5_.length);
  107.          var _loc7_:int = 0;
  108.          while(_loc7_ < _loc6_)
  109.          {
  110.             _loc4_.dragSource.addData(_loc2_.dragSource.dataForFormat(_loc5_[_loc7_]),_loc5_[_loc7_]);
  111.             _loc7_++;
  112.          }
  113.          if(!_loc2_.dropTarget.dispatchEvent(_loc4_))
  114.          {
  115.             param1.preventDefault();
  116.          }
  117.       }
  118.       
  119.       public function getFeedback() : String
  120.       {
  121.          var _loc1_:InterManagerRequest = null;
  122.          if(!isDragging)
  123.          {
  124.             _loc1_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  125.             _loc1_.name = "getFeedback";
  126.             sandboxRoot.dispatchEvent(_loc1_);
  127.             return _loc1_.value as String;
  128.          }
  129.          return NativeDragManager.dropAction;
  130.       }
  131.       
  132.       private function marshalDragManagerHandler(param1:Event) : void
  133.       {
  134.          var _loc3_:InteractiveObject = null;
  135.          var _loc4_:InterManagerRequest = null;
  136.          if(param1 is InterManagerRequest)
  137.          {
  138.             return;
  139.          }
  140.          var _loc2_:Object = param1;
  141.          switch(_loc2_.name)
  142.          {
  143.             case "isDragging":
  144.                break;
  145.             case "acceptDragDrop":
  146.                if(isDragging)
  147.                {
  148.                   _loc3_ = _loc2_.value as InteractiveObject;
  149.                   if(_loc3_)
  150.                   {
  151.                      NativeDragManager.acceptDragDrop(_loc3_);
  152.                   }
  153.                }
  154.                break;
  155.             case "showFeedback":
  156.                if(isDragging)
  157.                {
  158.                   showFeedback(_loc2_.value);
  159.                }
  160.                break;
  161.             case "getFeedback":
  162.                if(isDragging)
  163.                {
  164.                   _loc2_.value = getFeedback();
  165.                }
  166.                break;
  167.             case "endDrag":
  168.                endDrag();
  169.                break;
  170.             case "update":
  171.                if(isDragging)
  172.                {
  173.                   _loc4_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  174.                   _loc4_.name = "isDragging";
  175.                   _loc4_.value = true;
  176.                   sandboxRoot.dispatchEvent(_loc4_);
  177.                }
  178.          }
  179.       }
  180.       
  181.       mx_internal function unregisterSystemManager(param1:ISystemManager) : void
  182.       {
  183.          if(param1.isTopLevel())
  184.          {
  185.             param1.removeEventListener(MouseEvent.MOUSE_DOWN,sm_mouseDownHandler);
  186.             param1.removeEventListener(MouseEvent.MOUSE_UP,sm_mouseUpHandler);
  187.          }
  188.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_ENTER,nativeDragEventHandler,true);
  189.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_COMPLETE,nativeDragEventHandler,true);
  190.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_DROP,nativeDragEventHandler,true);
  191.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_EXIT,nativeDragEventHandler,true);
  192.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_OVER,nativeDragEventHandler,true);
  193.          param1.stage.removeEventListener(NativeDragEvent.NATIVE_DRAG_START,nativeDragEventHandler,true);
  194.       }
  195.       
  196.       public function get isDragging() : Boolean
  197.       {
  198.          return NativeDragManager.isDragging;
  199.       }
  200.       
  201.       mx_internal function registerSystemManager(param1:ISystemManager) : void
  202.       {
  203.          if(param1.isTopLevel())
  204.          {
  205.             param1.addEventListener(MouseEvent.MOUSE_DOWN,sm_mouseDownHandler);
  206.             param1.addEventListener(MouseEvent.MOUSE_UP,sm_mouseUpHandler);
  207.          }
  208.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_ENTER,nativeDragEventHandler,true);
  209.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_COMPLETE,nativeDragEventHandler,true);
  210.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_DROP,nativeDragEventHandler,true);
  211.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_EXIT,nativeDragEventHandler,true);
  212.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_OVER,nativeDragEventHandler,true);
  213.          param1.stage.addEventListener(NativeDragEvent.NATIVE_DRAG_START,nativeDragEventHandler,true);
  214.       }
  215.       
  216.       private function sm_mouseUpHandler(param1:MouseEvent) : void
  217.       {
  218.          mouseIsDown = false;
  219.       }
  220.       
  221.       public function doDrag(param1:IUIComponent, param2:DragSource, param3:MouseEvent, param4:IFlexDisplayObject = null, param5:Number = 0, param6:Number = 0, param7:Number = 0.5, param8:Boolean = true) : void
  222.       {
  223.          var _loc9_:Number = NaN;
  224.          var _loc10_:Number = NaN;
  225.          var _loc13_:String = null;
  226.          var _loc14_:DragDataFormatFetcher = null;
  227.          var _loc15_:CSSStyleDeclaration = null;
  228.          var _loc16_:Class = null;
  229.          if(isDragging)
  230.          {
  231.             return;
  232.          }
  233.          if(!(param3.type == MouseEvent.MOUSE_DOWN || param3.type == MouseEvent.CLICK || mouseIsDown || param3.buttonDown))
  234.          {
  235.             return;
  236.          }
  237.          var _loc11_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  238.          _loc11_.name = "isDragging";
  239.          _loc11_.value = true;
  240.          sandboxRoot.dispatchEvent(_loc11_);
  241.          _loc11_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  242.          _loc11_.name = "mouseShield";
  243.          _loc11_.value = true;
  244.          sandboxRoot.dispatchEvent(_loc11_);
  245.          _clipboard = new Clipboard();
  246.          _dragInitiator = param1;
  247.          _offset = new Point(param5,param6);
  248.          _allowMove = param8;
  249.          _offset.y -= InteractiveObject(param1).mouseY;
  250.          _offset.x -= InteractiveObject(param1).mouseX;
  251.          _allowedActions = new NativeDragOptions();
  252.          _allowedActions.allowCopy = true;
  253.          _allowedActions.allowLink = true;
  254.          _allowedActions.allowMove = param8;
  255.          var _loc12_:int = 0;
  256.          while(_loc12_ < param2.formats.length)
  257.          {
  258.             _loc13_ = param2.formats[_loc12_] as String;
  259.             _loc14_ = new DragDataFormatFetcher();
  260.             _loc14_.dragSource = param2;
  261.             _loc14_.format = _loc13_;
  262.             _clipboard.setDataHandler(_loc13_,_loc14_.getDragSourceData,false);
  263.             _loc12_++;
  264.          }
  265.          if(!param4)
  266.          {
  267.             _loc15_ = StyleManager.getStyleDeclaration("DragManager");
  268.             _loc16_ = _loc15_.getStyle("defaultDragImageSkin");
  269.             param4 = new _loc16_();
  270.             _loc9_ = !!param1 ? Number(param1.width) : 0;
  271.             _loc10_ = !!param1 ? Number(param1.height) : 0;
  272.             if(param4 is IFlexDisplayObject)
  273.             {
  274.                IFlexDisplayObject(param4).setActualSize(_loc9_,_loc10_);
  275.             }
  276.          }
  277.          else
  278.          {
  279.             _loc9_ = Number(param4.width);
  280.             _loc10_ = Number(param4.height);
  281.          }
  282.          _dragImage = param4;
  283.          if(param4 is IUIComponent && param4 is ILayoutManagerClient && !ILayoutManagerClient(param4).initialized && Boolean(param1))
  284.          {
  285.             param4.addEventListener(FlexEvent.UPDATE_COMPLETE,initiateDrag);
  286.             param1.systemManager.popUpChildren.addChild(DisplayObject(param4));
  287.             if(param4 is ILayoutManagerClient)
  288.             {
  289.                UIComponentGlobals.mx_internal::layoutManager.validateClient(ILayoutManagerClient(param4),true);
  290.             }
  291.             if(param4 is IUIComponent)
  292.             {
  293.                param4.setActualSize(_loc9_,_loc10_);
  294.                _loc9_ = Number((param4 as IUIComponent).getExplicitOrMeasuredWidth());
  295.                _loc10_ = Number((param4 as IUIComponent).getExplicitOrMeasuredHeight());
  296.             }
  297.             else
  298.             {
  299.                _loc9_ = Number(param4.measuredWidth);
  300.                _loc10_ = Number(param4.measuredHeight);
  301.             }
  302.             if(param4 is ILayoutManagerClient)
  303.             {
  304.                UIComponentGlobals.mx_internal::layoutManager.validateClient(ILayoutManagerClient(param4));
  305.             }
  306.             return;
  307.          }
  308.          initiateDrag(null,false);
  309.       }
  310.       
  311.       private function isSameOrChildApplicationDomain(param1:Object) : Boolean
  312.       {
  313.          var _loc2_:DisplayObject = SystemManager.getSWFRoot(param1);
  314.          if(_loc2_)
  315.          {
  316.             return true;
  317.          }
  318.          var _loc3_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST);
  319.          _loc3_.name = "hasSWFBridges";
  320.          sandboxRoot.dispatchEvent(_loc3_);
  321.          if(!_loc3_.value)
  322.          {
  323.             return true;
  324.          }
  325.          return false;
  326.       }
  327.       
  328.       public function showFeedback(param1:String) : void
  329.       {
  330.          var _loc2_:InterManagerRequest = null;
  331.          if(isDragging)
  332.          {
  333.             if(param1 == DragManager.MOVE && !_allowedActions.allowMove)
  334.             {
  335.                return;
  336.             }
  337.             if(param1 == DragManager.COPY && !_allowedActions.allowCopy)
  338.             {
  339.                return;
  340.             }
  341.             if(param1 == DragManager.LINK && !_allowedActions.allowLink)
  342.             {
  343.                return;
  344.             }
  345.             NativeDragManager.dropAction = param1;
  346.          }
  347.          else
  348.          {
  349.             _loc2_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  350.             _loc2_.name = "showFeedback";
  351.             _loc2_.value = param1;
  352.             sandboxRoot.dispatchEvent(_loc2_);
  353.          }
  354.       }
  355.       
  356.       public function acceptDragDrop(param1:IUIComponent) : void
  357.       {
  358.          var _loc2_:InteractiveObject = null;
  359.          var _loc3_:InterManagerRequest = null;
  360.          if(isDragging)
  361.          {
  362.             _loc2_ = param1 as InteractiveObject;
  363.             if(_loc2_)
  364.             {
  365.                NativeDragManager.acceptDragDrop(_loc2_);
  366.             }
  367.          }
  368.          else
  369.          {
  370.             _loc3_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  371.             _loc3_.name = "acceptDragDrop";
  372.             _loc3_.value = param1;
  373.             sandboxRoot.dispatchEvent(_loc3_);
  374.          }
  375.       }
  376.       
  377.       private function initiateDrag(param1:FlexEvent, param2:Boolean = true) : void
  378.       {
  379.          var _loc3_:BitmapData = null;
  380.          if(param2)
  381.          {
  382.             _dragImage.removeEventListener(FlexEvent.UPDATE_COMPLETE,initiateDrag);
  383.          }
  384.          if(Boolean(_dragImage.width) && Boolean(_dragImage.height))
  385.          {
  386.             _loc3_ = new BitmapData(_dragImage.width,_dragImage.height,true,0);
  387.          }
  388.          else
  389.          {
  390.             _loc3_ = new BitmapData(1,1,true,0);
  391.          }
  392.          _loc3_.draw(_dragImage);
  393.          if(param2 && _dragImage is IUIComponent && Boolean(_dragInitiator))
  394.          {
  395.             _dragInitiator.systemManager.popUpChildren.removeChild(DisplayObject(_dragImage));
  396.          }
  397.          NativeDragManager.doDrag(InteractiveObject(_dragInitiator),_clipboard,_loc3_,_offset,_allowedActions);
  398.       }
  399.       
  400.       public function endDrag() : void
  401.       {
  402.          var _loc1_:InterManagerRequest = null;
  403.          _loc1_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  404.          _loc1_.name = "mouseShield";
  405.          _loc1_.value = false;
  406.          sandboxRoot.dispatchEvent(_loc1_);
  407.          _loc1_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  408.          _loc1_.name = "isDragging";
  409.          _loc1_.value = false;
  410.          sandboxRoot.dispatchEvent(_loc1_);
  411.       }
  412.       
  413.       private function sm_mouseDownHandler(param1:MouseEvent) : void
  414.       {
  415.          mouseIsDown = true;
  416.       }
  417.       
  418.       private function _dispatchDragEvent(param1:DisplayObject, param2:DragEvent) : void
  419.       {
  420.          var _loc3_:InterManagerRequest = null;
  421.          var _loc4_:InterDragManagerEvent = null;
  422.          if(isSameOrChildApplicationDomain(param1))
  423.          {
  424.             param1.dispatchEvent(param2);
  425.          }
  426.          else
  427.          {
  428.             _loc3_ = new InterManagerRequest(InterManagerRequest.INIT_MANAGER_REQUEST);
  429.             _loc3_.name = "mx.managers.IDragManagerImpl";
  430.             sandboxRoot.dispatchEvent(_loc3_);
  431.             _loc4_ = new InterDragManagerEvent(InterDragManagerEvent.DISPATCH_DRAG_EVENT,false,false,param2.localX,param2.localY,param2.relatedObject,param2.ctrlKey,param2.altKey,param2.shiftKey,param2.buttonDown,param2.delta,param1,param2.type,param2.dragInitiator,param2.dragSource,param2.action,param2.draggedItem);
  432.             sandboxRoot.dispatchEvent(_loc4_);
  433.          }
  434.       }
  435.       
  436.       private function nativeDragEventHandler(param1:NativeDragEvent) : void
  437.       {
  438.          var _loc8_:String = null;
  439.          var _loc9_:Object = null;
  440.          var _loc10_:InterManagerRequest = null;
  441.          var _loc13_:int = 0;
  442.          var _loc14_:DragDataFormatFetcher = null;
  443.          var _loc2_:String = param1.type.charAt(6).toLowerCase() + param1.type.substr(7);
  444.          var _loc3_:DragSource = new DragSource();
  445.          var _loc4_:DisplayObject = param1.target as DisplayObject;
  446.          var _loc5_:Clipboard = param1.clipboard;
  447.          var _loc6_:Array = _loc5_.formats;
  448.          var _loc7_:int = int(_loc6_.length);
  449.          _allowedActions = param1.allowedActions;
  450.          var _loc11_:Boolean = false;
  451.          if(Capabilities.os.substring(0,3) == "Mac")
  452.          {
  453.             _loc11_ = Boolean(param1.commandKey);
  454.          }
  455.          else
  456.          {
  457.             _loc11_ = Boolean(param1.controlKey);
  458.          }
  459.          if(Boolean(NativeDragManager.dragInitiator) && param1.type == NativeDragEvent.NATIVE_DRAG_START)
  460.          {
  461.             NativeDragManager.dropAction = _loc11_ || !_allowMove ? DragManager.COPY : DragManager.MOVE;
  462.          }
  463.          if(param1.type != NativeDragEvent.NATIVE_DRAG_EXIT)
  464.          {
  465.             _loc13_ = 0;
  466.             while(_loc13_ < _loc7_)
  467.             {
  468.                _loc8_ = _loc6_[_loc13_];
  469.                if(_loc5_.hasFormat(_loc8_))
  470.                {
  471.                   _loc14_ = new DragDataFormatFetcher();
  472.                   _loc14_.clipboard = _loc5_;
  473.                   _loc14_.format = _loc8_;
  474.                   _loc3_.addHandler(_loc14_.getClipboardData,_loc8_);
  475.                }
  476.                _loc13_++;
  477.             }
  478.          }
  479.          if(param1.type == NativeDragEvent.NATIVE_DRAG_DROP)
  480.          {
  481.             _relatedObject = param1.target as InteractiveObject;
  482.          }
  483.          var _loc12_:DragEvent = new DragEvent(_loc2_,false,param1.cancelable,NativeDragManager.dragInitiator as IUIComponent,_loc3_,param1.dropAction,_loc11_,param1.altKey,param1.shiftKey);
  484.          _loc12_.buttonDown = param1.buttonDown;
  485.          _loc12_.delta = param1.delta;
  486.          _loc12_.localX = param1.localX;
  487.          _loc12_.localY = param1.localY;
  488.          if(_loc2_ == DragEvent.DRAG_COMPLETE)
  489.          {
  490.             _loc12_.relatedObject = _relatedObject;
  491.          }
  492.          else
  493.          {
  494.             _loc12_.relatedObject = param1.relatedObject;
  495.          }
  496.          _dispatchDragEvent(_loc4_,_loc12_);
  497.          if(_loc2_ == DragEvent.DRAG_COMPLETE)
  498.          {
  499.             if(sm == sandboxRoot)
  500.             {
  501.                endDrag();
  502.             }
  503.             else
  504.             {
  505.                _loc10_ = new InterManagerRequest(InterManagerRequest.DRAG_MANAGER_REQUEST);
  506.                _loc10_.name = "endDrag";
  507.                sandboxRoot.dispatchEvent(_loc10_);
  508.             }
  509.          }
  510.       }
  511.    }
  512. }
  513.  
  514. import flash.desktop.Clipboard;
  515. import mx.core.DragSource;
  516. import mx.core.mx_internal;
  517.  
  518. use namespace mx_internal;
  519.  
  520. class DragDataFormatFetcher
  521. {
  522.    mx_internal static const VERSION:String = "3.5.0.12683";
  523.    
  524.    public var clipboard:Clipboard;
  525.    
  526.    public var format:String;
  527.    
  528.    public var dragSource:DragSource;
  529.    
  530.    public function DragDataFormatFetcher()
  531.    {
  532.       super();
  533.    }
  534.    
  535.    public function getDragSourceData() : Object
  536.    {
  537.       if(dragSource)
  538.       {
  539.          return dragSource.dataForFormat(format);
  540.       }
  541.       return null;
  542.    }
  543.    
  544.    public function getClipboardData() : Object
  545.    {
  546.       if(clipboard)
  547.       {
  548.          return clipboard.getData(format);
  549.       }
  550.       return null;
  551.    }
  552. }
  553.