home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / managers / dragClasses / DragProxy.as
Encoding:
Text File  |  2010-06-23  |  16.2 KB  |  475 lines
  1. package mx.managers.dragClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.InteractiveObject;
  6.    import flash.events.Event;
  7.    import flash.events.IEventDispatcher;
  8.    import flash.events.KeyboardEvent;
  9.    import flash.events.MouseEvent;
  10.    import flash.geom.Point;
  11.    import mx.core.DragSource;
  12.    import mx.core.IUIComponent;
  13.    import mx.core.UIComponent;
  14.    import mx.core.mx_internal;
  15.    import mx.effects.Move;
  16.    import mx.effects.Zoom;
  17.    import mx.events.DragEvent;
  18.    import mx.events.EffectEvent;
  19.    import mx.events.InterDragManagerEvent;
  20.    import mx.events.InterManagerRequest;
  21.    import mx.events.SandboxMouseEvent;
  22.    import mx.managers.CursorManager;
  23.    import mx.managers.DragManager;
  24.    import mx.managers.ISystemManager;
  25.    import mx.managers.SystemManager;
  26.    import mx.styles.CSSStyleDeclaration;
  27.    import mx.styles.StyleManager;
  28.    
  29.    use namespace mx_internal;
  30.    
  31.    public class DragProxy extends UIComponent
  32.    {
  33.       mx_internal static const VERSION:String = "3.5.0.12683";
  34.       
  35.       public var allowMove:Boolean = true;
  36.       
  37.       private var cursorClass:Class = null;
  38.       
  39.       public var action:String;
  40.       
  41.       private var sandboxRoot:IEventDispatcher;
  42.       
  43.       public var target:DisplayObject = null;
  44.       
  45.       public var dragInitiator:IUIComponent;
  46.       
  47.       public var xOffset:Number;
  48.       
  49.       public var yOffset:Number;
  50.       
  51.       public var dragSource:DragSource;
  52.       
  53.       private var cursorID:int = 0;
  54.       
  55.       private var lastMouseEvent:MouseEvent;
  56.       
  57.       public var startX:Number;
  58.       
  59.       public var startY:Number;
  60.       
  61.       private var lastKeyEvent:KeyboardEvent;
  62.       
  63.       public function DragProxy(param1:IUIComponent, param2:DragSource)
  64.       {
  65.          super();
  66.          this.dragInitiator = param1;
  67.          this.dragSource = param2;
  68.          var _loc3_:ISystemManager = param1.systemManager.topLevelSystemManager as ISystemManager;
  69.          var _loc4_:IEventDispatcher = sandboxRoot = _loc3_.getSandboxRoot();
  70.          _loc4_.addEventListener(MouseEvent.MOUSE_MOVE,mouseMoveHandler,true);
  71.          _loc4_.addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  72.          _loc4_.addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  73.          _loc4_.addEventListener(KeyboardEvent.KEY_UP,keyUpHandler);
  74.       }
  75.       
  76.       private static function getObjectsUnderPoint(param1:DisplayObject, param2:Point, param3:Array) : void
  77.       {
  78.          var doc:DisplayObjectContainer = null;
  79.          var rc:Object = null;
  80.          var n:int = 0;
  81.          var i:int = 0;
  82.          var child:DisplayObject = null;
  83.          var obj:DisplayObject = param1;
  84.          var pt:Point = param2;
  85.          var arr:Array = param3;
  86.          if(!obj.visible)
  87.          {
  88.             return;
  89.          }
  90.          if(obj is UIComponent && !UIComponent(obj).mx_internal::$visible)
  91.          {
  92.             return;
  93.          }
  94.          if(obj.hitTestPoint(pt.x,pt.y,true))
  95.          {
  96.             if(obj is InteractiveObject && InteractiveObject(obj).mouseEnabled)
  97.             {
  98.                arr.push(obj);
  99.             }
  100.             if(obj is DisplayObjectContainer)
  101.             {
  102.                doc = obj as DisplayObjectContainer;
  103.                if(doc.mouseChildren)
  104.                {
  105.                   if("rawChildren" in doc)
  106.                   {
  107.                      rc = doc["rawChildren"];
  108.                      n = int(rc.numChildren);
  109.                      i = 0;
  110.                      while(i < n)
  111.                      {
  112.                         try
  113.                         {
  114.                            getObjectsUnderPoint(rc.getChildAt(i),pt,arr);
  115.                         }
  116.                         catch(e:Error)
  117.                         {
  118.                         }
  119.                         i++;
  120.                      }
  121.                   }
  122.                   else if(doc.numChildren)
  123.                   {
  124.                      n = doc.numChildren;
  125.                      i = 0;
  126.                      while(i < n)
  127.                      {
  128.                         try
  129.                         {
  130.                            child = doc.getChildAt(i);
  131.                            getObjectsUnderPoint(child,pt,arr);
  132.                         }
  133.                         catch(e:Error)
  134.                         {
  135.                         }
  136.                         i++;
  137.                      }
  138.                   }
  139.                }
  140.             }
  141.          }
  142.       }
  143.       
  144.       public function mouseUpHandler(param1:MouseEvent) : void
  145.       {
  146.          var _loc2_:DragEvent = null;
  147.          var _loc6_:Point = null;
  148.          var _loc7_:Move = null;
  149.          var _loc8_:Zoom = null;
  150.          var _loc9_:Move = null;
  151.          var _loc3_:ISystemManager = dragInitiator.systemManager.topLevelSystemManager as ISystemManager;
  152.          var _loc4_:IEventDispatcher = sandboxRoot;
  153.          _loc4_.removeEventListener(MouseEvent.MOUSE_MOVE,mouseMoveHandler,true);
  154.          _loc4_.removeEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  155.          _loc4_.removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  156.          _loc4_.removeEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,mouseLeaveHandler);
  157.          _loc4_.removeEventListener(KeyboardEvent.KEY_UP,keyUpHandler);
  158.          var _loc5_:Object = automationDelegate;
  159.          if(Boolean(target) && action != DragManager.NONE)
  160.          {
  161.             _loc2_ = new DragEvent(DragEvent.DRAG_DROP);
  162.             _loc2_.dragInitiator = dragInitiator;
  163.             _loc2_.dragSource = dragSource;
  164.             _loc2_.action = action;
  165.             _loc2_.ctrlKey = param1.ctrlKey;
  166.             _loc2_.altKey = param1.altKey;
  167.             _loc2_.shiftKey = param1.shiftKey;
  168.             _loc6_ = new Point();
  169.             _loc6_.x = lastMouseEvent.localX;
  170.             _loc6_.y = lastMouseEvent.localY;
  171.             _loc6_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc6_);
  172.             _loc6_ = DisplayObject(target).globalToLocal(_loc6_);
  173.             _loc2_.localX = _loc6_.x;
  174.             _loc2_.localY = _loc6_.y;
  175.             if(_loc5_)
  176.             {
  177.                _loc5_.recordAutomatableDragDrop(target,_loc2_);
  178.             }
  179.             _dispatchDragEvent(target,_loc2_);
  180.          }
  181.          else
  182.          {
  183.             action = DragManager.NONE;
  184.          }
  185.          if(action == DragManager.NONE)
  186.          {
  187.             _loc7_ = new Move(this);
  188.             _loc7_.addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  189.             _loc7_.xFrom = x;
  190.             _loc7_.yFrom = y;
  191.             _loc7_.xTo = startX;
  192.             _loc7_.yTo = startY;
  193.             _loc7_.duration = 200;
  194.             _loc7_.play();
  195.          }
  196.          else
  197.          {
  198.             _loc8_ = new Zoom(this);
  199.             _loc8_.zoomWidthFrom = _loc8_.zoomHeightFrom = 1;
  200.             _loc8_.zoomWidthTo = _loc8_.zoomHeightTo = 0;
  201.             _loc8_.duration = 200;
  202.             _loc8_.play();
  203.             _loc9_ = new Move(this);
  204.             _loc9_.addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  205.             _loc9_.xFrom = x;
  206.             _loc9_.yFrom = this.y;
  207.             _loc9_.xTo = parent.mouseX;
  208.             _loc9_.yTo = parent.mouseY;
  209.             _loc9_.duration = 200;
  210.             _loc9_.play();
  211.          }
  212.          _loc2_ = new DragEvent(DragEvent.DRAG_COMPLETE);
  213.          _loc2_.dragInitiator = dragInitiator;
  214.          _loc2_.dragSource = dragSource;
  215.          _loc2_.relatedObject = InteractiveObject(target);
  216.          _loc2_.action = action;
  217.          _loc2_.ctrlKey = param1.ctrlKey;
  218.          _loc2_.altKey = param1.altKey;
  219.          _loc2_.shiftKey = param1.shiftKey;
  220.          dragInitiator.dispatchEvent(_loc2_);
  221.          if(Boolean(_loc5_) && action == DragManager.NONE)
  222.          {
  223.             _loc5_.recordAutomatableDragCancel(dragInitiator,_loc2_);
  224.          }
  225.          cursorManager.removeCursor(cursorID);
  226.          cursorID = CursorManager.NO_CURSOR;
  227.          this.lastMouseEvent = null;
  228.       }
  229.       
  230.       private function isSameOrChildApplicationDomain(param1:Object) : Boolean
  231.       {
  232.          var _loc2_:DisplayObject = SystemManager.getSWFRoot(param1);
  233.          if(_loc2_)
  234.          {
  235.             return true;
  236.          }
  237.          var _loc3_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.SYSTEM_MANAGER_REQUEST);
  238.          _loc3_.name = "hasSWFBridges";
  239.          sandboxRoot.dispatchEvent(_loc3_);
  240.          if(!_loc3_.value)
  241.          {
  242.             return true;
  243.          }
  244.          return false;
  245.       }
  246.       
  247.       public function showFeedback() : void
  248.       {
  249.          var _loc1_:Class = cursorClass;
  250.          var _loc2_:CSSStyleDeclaration = StyleManager.getStyleDeclaration("DragManager");
  251.          if(action == DragManager.COPY)
  252.          {
  253.             _loc1_ = _loc2_.getStyle("copyCursor");
  254.          }
  255.          else if(action == DragManager.LINK)
  256.          {
  257.             _loc1_ = _loc2_.getStyle("linkCursor");
  258.          }
  259.          else if(action == DragManager.NONE)
  260.          {
  261.             _loc1_ = _loc2_.getStyle("rejectCursor");
  262.          }
  263.          else
  264.          {
  265.             _loc1_ = _loc2_.getStyle("moveCursor");
  266.          }
  267.          if(_loc1_ != cursorClass)
  268.          {
  269.             cursorClass = _loc1_;
  270.             if(cursorID != CursorManager.NO_CURSOR)
  271.             {
  272.                cursorManager.removeCursor(cursorID);
  273.             }
  274.             cursorID = cursorManager.setCursor(cursorClass,2,0,0);
  275.          }
  276.       }
  277.       
  278.       override public function initialize() : void
  279.       {
  280.          super.initialize();
  281.          dragInitiator.systemManager.getSandboxRoot().addEventListener(SandboxMouseEvent.MOUSE_UP_SOMEWHERE,mouseLeaveHandler);
  282.          if(!getFocus())
  283.          {
  284.             setFocus();
  285.          }
  286.       }
  287.       
  288.       public function mouseMoveHandler(param1:MouseEvent) : void
  289.       {
  290.          var _loc2_:DragEvent = null;
  291.          var _loc3_:DisplayObject = null;
  292.          var _loc4_:int = 0;
  293.          var _loc10_:Array = null;
  294.          var _loc14_:Boolean = false;
  295.          var _loc15_:DisplayObject = null;
  296.          lastMouseEvent = param1;
  297.          var _loc5_:Point = new Point();
  298.          var _loc6_:Point = new Point(param1.localX,param1.localY);
  299.          var _loc7_:Point = DisplayObject(param1.target).localToGlobal(_loc6_);
  300.          _loc6_ = DisplayObject(sandboxRoot).globalToLocal(_loc7_);
  301.          var _loc8_:Number = _loc6_.x;
  302.          var _loc9_:Number = _loc6_.y;
  303.          x = _loc8_ - xOffset;
  304.          y = _loc9_ - yOffset;
  305.          if(!param1)
  306.          {
  307.             return;
  308.          }
  309.          var _loc11_:IEventDispatcher = systemManager.getTopLevelRoot();
  310.          _loc10_ = [];
  311.          DragProxy.getObjectsUnderPoint(DisplayObject(sandboxRoot),_loc7_,_loc10_);
  312.          var _loc12_:DisplayObject = null;
  313.          var _loc13_:int = int(_loc10_.length - 1);
  314.          while(_loc13_ >= 0)
  315.          {
  316.             _loc12_ = _loc10_[_loc13_];
  317.             if(_loc12_ != this && !contains(_loc12_))
  318.             {
  319.                break;
  320.             }
  321.             _loc13_--;
  322.          }
  323.          if(target)
  324.          {
  325.             _loc14_ = false;
  326.             _loc15_ = target;
  327.             _loc3_ = _loc12_;
  328.             while(_loc3_)
  329.             {
  330.                if(_loc3_ == target)
  331.                {
  332.                   dispatchDragEvent(DragEvent.DRAG_OVER,param1,_loc3_);
  333.                   _loc14_ = true;
  334.                   break;
  335.                }
  336.                dispatchDragEvent(DragEvent.DRAG_ENTER,param1,_loc3_);
  337.                if(target == _loc3_)
  338.                {
  339.                   _loc14_ = false;
  340.                   break;
  341.                }
  342.                _loc3_ = _loc3_.parent;
  343.             }
  344.             if(!_loc14_)
  345.             {
  346.                dispatchDragEvent(DragEvent.DRAG_EXIT,param1,_loc15_);
  347.                if(target == _loc15_)
  348.                {
  349.                   target = null;
  350.                }
  351.             }
  352.          }
  353.          if(!target)
  354.          {
  355.             action = DragManager.MOVE;
  356.             _loc3_ = _loc12_;
  357.             while(_loc3_)
  358.             {
  359.                if(_loc3_ != this)
  360.                {
  361.                   dispatchDragEvent(DragEvent.DRAG_ENTER,param1,_loc3_);
  362.                   if(target)
  363.                   {
  364.                      break;
  365.                   }
  366.                }
  367.                _loc3_ = _loc3_.parent;
  368.             }
  369.             if(!target)
  370.             {
  371.                action = DragManager.NONE;
  372.             }
  373.          }
  374.          showFeedback();
  375.       }
  376.       
  377.       private function dispatchDragEvent(param1:String, param2:MouseEvent, param3:Object) : void
  378.       {
  379.          var _loc4_:DragEvent = new DragEvent(param1);
  380.          var _loc5_:Point = new Point();
  381.          _loc4_.dragInitiator = dragInitiator;
  382.          _loc4_.dragSource = dragSource;
  383.          _loc4_.action = action;
  384.          _loc4_.ctrlKey = param2.ctrlKey;
  385.          _loc4_.altKey = param2.altKey;
  386.          _loc4_.shiftKey = param2.shiftKey;
  387.          _loc5_.x = lastMouseEvent.localX;
  388.          _loc5_.y = lastMouseEvent.localY;
  389.          _loc5_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc5_);
  390.          _loc5_ = DisplayObject(param3).globalToLocal(_loc5_);
  391.          _loc4_.localX = _loc5_.x;
  392.          _loc4_.localY = _loc5_.y;
  393.          _dispatchDragEvent(DisplayObject(param3),_loc4_);
  394.       }
  395.       
  396.       override protected function keyUpHandler(param1:KeyboardEvent) : void
  397.       {
  398.          checkKeyEvent(param1);
  399.       }
  400.       
  401.       private function effectEndHandler(param1:EffectEvent) : void
  402.       {
  403.          DragManager.mx_internal::endDrag();
  404.       }
  405.       
  406.       public function checkKeyEvent(param1:KeyboardEvent) : void
  407.       {
  408.          var _loc2_:DragEvent = null;
  409.          var _loc3_:Point = null;
  410.          if(target)
  411.          {
  412.             if(lastKeyEvent && param1.type == lastKeyEvent.type && param1.keyCode == lastKeyEvent.keyCode)
  413.             {
  414.                return;
  415.             }
  416.             lastKeyEvent = param1;
  417.             _loc2_ = new DragEvent(DragEvent.DRAG_OVER);
  418.             _loc2_.dragInitiator = dragInitiator;
  419.             _loc2_.dragSource = dragSource;
  420.             _loc2_.action = action;
  421.             _loc2_.ctrlKey = param1.ctrlKey;
  422.             _loc2_.altKey = param1.altKey;
  423.             _loc2_.shiftKey = param1.shiftKey;
  424.             _loc3_ = new Point();
  425.             _loc3_.x = lastMouseEvent.localX;
  426.             _loc3_.y = lastMouseEvent.localY;
  427.             _loc3_ = DisplayObject(lastMouseEvent.target).localToGlobal(_loc3_);
  428.             _loc3_ = DisplayObject(target).globalToLocal(_loc3_);
  429.             _loc2_.localX = _loc3_.x;
  430.             _loc2_.localY = _loc3_.y;
  431.             _dispatchDragEvent(target,_loc2_);
  432.             showFeedback();
  433.          }
  434.       }
  435.       
  436.       public function mouseLeaveHandler(param1:Event) : void
  437.       {
  438.          mouseUpHandler(lastMouseEvent);
  439.       }
  440.       
  441.       private function _dispatchDragEvent(param1:DisplayObject, param2:DragEvent) : void
  442.       {
  443.          var _loc3_:InterManagerRequest = null;
  444.          var _loc4_:InterDragManagerEvent = null;
  445.          if(isSameOrChildApplicationDomain(param1))
  446.          {
  447.             param1.dispatchEvent(param2);
  448.          }
  449.          else
  450.          {
  451.             _loc3_ = new InterManagerRequest(InterManagerRequest.INIT_MANAGER_REQUEST);
  452.             _loc3_.name = "mx.managers::IDragManager";
  453.             sandboxRoot.dispatchEvent(_loc3_);
  454.             _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);
  455.             sandboxRoot.dispatchEvent(_loc4_);
  456.          }
  457.       }
  458.       
  459.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  460.       {
  461.          checkKeyEvent(param1);
  462.       }
  463.       
  464.       public function stage_mouseMoveHandler(param1:MouseEvent) : void
  465.       {
  466.          if(param1.target != stage)
  467.          {
  468.             return;
  469.          }
  470.          mouseMoveHandler(param1);
  471.       }
  472.    }
  473. }
  474.  
  475.