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