home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2012 April / ME_04_2012.iso / Video-Tutorial / iPhoto / media / player.swf / scripts / mx / utils / MatrixUtil.as < prev    next >
Encoding:
Text File  |  2011-11-11  |  33.9 KB  |  835 lines
  1. package mx.utils
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.geom.Matrix;
  5.    import flash.geom.Matrix3D;
  6.    import flash.geom.PerspectiveProjection;
  7.    import flash.geom.Point;
  8.    import flash.geom.Rectangle;
  9.    import flash.geom.Utils3D;
  10.    import flash.geom.Vector3D;
  11.    import flash.system.ApplicationDomain;
  12.    import mx.core.mx_internal;
  13.    
  14.    use namespace mx_internal;
  15.    
  16.    public final class MatrixUtil
  17.    {
  18.       private static var fakeDollarParent:QName;
  19.       
  20.       private static var uiComponentClass:Class;
  21.       
  22.       private static var uiMovieClipClass:Class;
  23.       
  24.       private static var usesMarshalling:Object;
  25.       
  26.       private static var lastModuleFactory:Object;
  27.       
  28.       private static var computedMatrixProperty:QName;
  29.       
  30.       private static var $transformProperty:QName;
  31.       
  32.       mx_internal static const VERSION:String = "4.5.0.20967";
  33.       
  34.       private static const RADIANS_PER_DEGREES:Number = Math.PI / 180;
  35.       
  36.       mx_internal static var SOLUTION_TOLERANCE:Number = 0.1;
  37.       
  38.       mx_internal static var MIN_MAX_TOLERANCE:Number = 0.1;
  39.       
  40.       private static var staticPoint:Point = new Point();
  41.       
  42.       public function MatrixUtil()
  43.       {
  44.          super();
  45.       }
  46.       
  47.       public static function clampRotation(param1:Number) : Number
  48.       {
  49.          if(param1 > 180 || param1 < -180)
  50.          {
  51.             param1 %= 360;
  52.             if(param1 > 180)
  53.             {
  54.                param1 -= 360;
  55.             }
  56.             else if(param1 < -180)
  57.             {
  58.                param1 += 360;
  59.             }
  60.          }
  61.          return param1;
  62.       }
  63.       
  64.       public static function transformPoint(param1:Number, param2:Number, param3:Matrix) : Point
  65.       {
  66.          if(!param3)
  67.          {
  68.             staticPoint.x = param1;
  69.             staticPoint.y = param2;
  70.             return staticPoint;
  71.          }
  72.          staticPoint.x = param3.a * param1 + param3.c * param2 + param3.tx;
  73.          staticPoint.y = param3.b * param1 + param3.d * param2 + param3.ty;
  74.          return staticPoint;
  75.       }
  76.       
  77.       public static function composeMatrix(param1:Number = 0, param2:Number = 0, param3:Number = 1, param4:Number = 1, param5:Number = 0, param6:Number = 0, param7:Number = 0) : Matrix
  78.       {
  79.          var _loc8_:Matrix = new Matrix();
  80.          _loc8_.translate(-param6,-param7);
  81.          _loc8_.scale(param3,param4);
  82.          if(param5 != 0)
  83.          {
  84.             _loc8_.rotate(param5 / 180 * Math.PI);
  85.          }
  86.          _loc8_.translate(param6 + param1,param7 + param2);
  87.          return _loc8_;
  88.       }
  89.       
  90.       public static function decomposeMatrix(param1:Vector.<Number>, param2:Matrix, param3:Number = 0, param4:Number = 0) : void
  91.       {
  92.          var _loc5_:Number = NaN;
  93.          var _loc6_:Number = NaN;
  94.          var _loc7_:Number = NaN;
  95.          var _loc8_:Number = NaN;
  96.          var _loc10_:Point = null;
  97.          _loc5_ = param2.a;
  98.          _loc6_ = param2.b;
  99.          param1[3] = Math.sqrt(_loc5_ * _loc5_ + _loc6_ * _loc6_);
  100.          _loc7_ = param2.c;
  101.          _loc8_ = param2.d;
  102.          param1[4] = Math.sqrt(_loc7_ * _loc7_ + _loc8_ * _loc8_);
  103.          var _loc9_:Number = _loc5_ * _loc8_ - _loc6_ * _loc7_;
  104.          if(_loc9_ < 0)
  105.          {
  106.             param1[4] = -param1[4];
  107.             _loc7_ = -_loc7_;
  108.             _loc8_ = -_loc8_;
  109.          }
  110.          param1[2] = Math.atan2(_loc6_,_loc5_) / RADIANS_PER_DEGREES;
  111.          if(param3 != 0 || param4 != 0)
  112.          {
  113.             _loc10_ = param2.transformPoint(new Point(param3,param4));
  114.             param1[0] = _loc10_.x - param3;
  115.             param1[1] = _loc10_.y - param4;
  116.          }
  117.          else
  118.          {
  119.             param1[0] = param2.tx;
  120.             param1[1] = param2.ty;
  121.          }
  122.       }
  123.       
  124.       public static function rectUnion(param1:Number, param2:Number, param3:Number, param4:Number, param5:Rectangle) : Rectangle
  125.       {
  126.          if(!param5)
  127.          {
  128.             return new Rectangle(param1,param2,param3 - param1,param4 - param2);
  129.          }
  130.          var _loc6_:Number = Math.min(param5.left,param1);
  131.          var _loc7_:Number = Math.min(param5.top,param2);
  132.          var _loc8_:Number = Math.max(param5.right,param3);
  133.          var _loc9_:Number = Math.max(param5.bottom,param4);
  134.          param5.x = _loc6_;
  135.          param5.y = _loc7_;
  136.          param5.width = _loc8_ - _loc6_;
  137.          param5.height = _loc9_ - _loc7_;
  138.          return param5;
  139.       }
  140.       
  141.       public static function getEllipseBoundingBox(param1:Number, param2:Number, param3:Number, param4:Number, param5:Matrix, param6:Rectangle = null) : Rectangle
  142.       {
  143.          var _loc11_:Number = NaN;
  144.          var _loc12_:Number = NaN;
  145.          var _loc17_:Point = null;
  146.          var _loc7_:Number = param5.a;
  147.          var _loc8_:Number = param5.b;
  148.          var _loc9_:Number = param5.c;
  149.          var _loc10_:Number = param5.d;
  150.          if(param3 == 0 && param4 == 0)
  151.          {
  152.             _loc17_ = new Point(param1,param2);
  153.             _loc17_ = param5.transformPoint(_loc17_);
  154.             return rectUnion(_loc17_.x,_loc17_.y,_loc17_.x,_loc17_.y,param6);
  155.          }
  156.          if(_loc7_ * param3 == 0)
  157.          {
  158.             _loc11_ = Math.PI / 2;
  159.          }
  160.          else
  161.          {
  162.             _loc11_ = Math.atan(_loc9_ * param4 / (_loc7_ * param3));
  163.          }
  164.          if(_loc8_ * param3 == 0)
  165.          {
  166.             _loc12_ = Math.PI / 2;
  167.          }
  168.          else
  169.          {
  170.             _loc12_ = Math.atan(_loc10_ * param4 / (_loc8_ * param3));
  171.          }
  172.          var _loc13_:Number = _loc7_ * Math.cos(_loc11_) * param3 + _loc9_ * Math.sin(_loc11_) * param4;
  173.          var _loc14_:Number = -_loc13_;
  174.          _loc13_ += _loc7_ * param1 + _loc9_ * param2 + param5.tx;
  175.          _loc14_ += _loc7_ * param1 + _loc9_ * param2 + param5.tx;
  176.          var _loc15_:Number = _loc8_ * Math.cos(_loc12_) * param3 + _loc10_ * Math.sin(_loc12_) * param4;
  177.          var _loc16_:Number = -_loc15_;
  178.          _loc15_ += _loc8_ * param1 + _loc10_ * param2 + param5.ty;
  179.          _loc16_ += _loc8_ * param1 + _loc10_ * param2 + param5.ty;
  180.          return rectUnion(Math.min(_loc13_,_loc14_),Math.min(_loc15_,_loc16_),Math.max(_loc13_,_loc14_),Math.max(_loc15_,_loc16_),param6);
  181.       }
  182.       
  183.       public static function getQBezierSegmentBBox(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Matrix, param10:Rectangle) : Rectangle
  184.       {
  185.          var _loc11_:Point = null;
  186.          var _loc18_:Number = NaN;
  187.          var _loc19_:Number = NaN;
  188.          var _loc20_:Number = NaN;
  189.          var _loc21_:Number = NaN;
  190.          _loc11_ = MatrixUtil.transformPoint(param1 * param7,param2 * param8,param9);
  191.          param1 = _loc11_.x;
  192.          param2 = _loc11_.y;
  193.          _loc11_ = MatrixUtil.transformPoint(param3 * param7,param4 * param8,param9);
  194.          param3 = _loc11_.x;
  195.          param4 = _loc11_.y;
  196.          _loc11_ = MatrixUtil.transformPoint(param5 * param7,param6 * param8,param9);
  197.          param5 = _loc11_.x;
  198.          param6 = _loc11_.y;
  199.          var _loc12_:Number = Math.min(param1,param5);
  200.          var _loc13_:Number = Math.max(param1,param5);
  201.          var _loc14_:Number = Math.min(param2,param6);
  202.          var _loc15_:Number = Math.max(param2,param6);
  203.          var _loc16_:Number = param1 - 2 * param3 + param5;
  204.          if(_loc16_ != 0)
  205.          {
  206.             _loc18_ = (param1 - param3) / _loc16_;
  207.             if(0 <= _loc18_ && _loc18_ <= 1)
  208.             {
  209.                _loc19_ = (1 - _loc18_) * (1 - _loc18_) * param1 + 2 * _loc18_ * (1 - _loc18_) * param3 + _loc18_ * _loc18_ * param5;
  210.                _loc12_ = Math.min(_loc19_,_loc12_);
  211.                _loc13_ = Math.max(_loc19_,_loc13_);
  212.             }
  213.          }
  214.          var _loc17_:Number = param2 - 2 * param4 + param6;
  215.          if(_loc17_ != 0)
  216.          {
  217.             _loc20_ = (param2 - param4) / _loc17_;
  218.             if(0 <= _loc20_ && _loc20_ <= 1)
  219.             {
  220.                _loc21_ = (1 - _loc20_) * (1 - _loc20_) * param2 + 2 * _loc20_ * (1 - _loc20_) * param4 + _loc20_ * _loc20_ * param6;
  221.                _loc14_ = Math.min(_loc21_,_loc14_);
  222.                _loc15_ = Math.max(_loc21_,_loc15_);
  223.             }
  224.          }
  225.          return rectUnion(_loc12_,_loc14_,_loc13_,_loc15_,param10);
  226.       }
  227.       
  228.       public static function transformSize(param1:Number, param2:Number, param3:Matrix) : Point
  229.       {
  230.          var _loc4_:Number = param3.a;
  231.          var _loc5_:Number = param3.b;
  232.          var _loc6_:Number = param3.c;
  233.          var _loc7_:Number = param3.d;
  234.          var _loc8_:Number = 0;
  235.          var _loc9_:Number = 0;
  236.          var _loc10_:Number = param1 * _loc4_;
  237.          var _loc11_:Number = param1 * _loc5_;
  238.          var _loc12_:Number = param2 * _loc6_;
  239.          var _loc13_:Number = param2 * _loc7_;
  240.          var _loc14_:Number = _loc10_ + _loc12_;
  241.          var _loc15_:Number = _loc11_ + _loc13_;
  242.          var _loc16_:Number = Math.min(Math.min(_loc8_,_loc10_),Math.min(_loc12_,_loc14_));
  243.          var _loc17_:Number = Math.max(Math.max(_loc8_,_loc10_),Math.max(_loc12_,_loc14_));
  244.          var _loc18_:Number = Math.min(Math.min(_loc9_,_loc11_),Math.min(_loc13_,_loc15_));
  245.          var _loc19_:Number = Math.max(Math.max(_loc9_,_loc11_),Math.max(_loc13_,_loc15_));
  246.          staticPoint.x = _loc17_ - _loc16_;
  247.          staticPoint.y = _loc19_ - _loc18_;
  248.          return staticPoint;
  249.       }
  250.       
  251.       public static function transformBounds(param1:Number, param2:Number, param3:Matrix, param4:Point = null) : Point
  252.       {
  253.          var _loc21_:Number = NaN;
  254.          var _loc22_:Number = NaN;
  255.          var _loc23_:Number = NaN;
  256.          var _loc24_:Number = NaN;
  257.          var _loc5_:Number = param3.a;
  258.          var _loc6_:Number = param3.b;
  259.          var _loc7_:Number = param3.c;
  260.          var _loc8_:Number = param3.d;
  261.          var _loc9_:Number = 0;
  262.          var _loc10_:Number = 0;
  263.          var _loc11_:Number = param1 * _loc5_;
  264.          var _loc12_:Number = param1 * _loc6_;
  265.          var _loc13_:Number = param2 * _loc7_;
  266.          var _loc14_:Number = param2 * _loc8_;
  267.          var _loc15_:Number = _loc11_ + _loc13_;
  268.          var _loc16_:Number = _loc12_ + _loc14_;
  269.          var _loc17_:Number = Math.min(Math.min(_loc9_,_loc11_),Math.min(_loc13_,_loc15_));
  270.          var _loc18_:Number = Math.max(Math.max(_loc9_,_loc11_),Math.max(_loc13_,_loc15_));
  271.          var _loc19_:Number = Math.min(Math.min(_loc10_,_loc12_),Math.min(_loc14_,_loc16_));
  272.          var _loc20_:Number = Math.max(Math.max(_loc10_,_loc12_),Math.max(_loc14_,_loc16_));
  273.          staticPoint.x = _loc18_ - _loc17_;
  274.          staticPoint.y = _loc20_ - _loc19_;
  275.          if(param4)
  276.          {
  277.             _loc21_ = param3.tx;
  278.             _loc22_ = param3.ty;
  279.             _loc23_ = param4.x;
  280.             _loc24_ = param4.y;
  281.             param4.x = _loc17_ + _loc5_ * _loc23_ + _loc6_ * _loc24_ + _loc21_;
  282.             param4.y = _loc19_ + _loc7_ * _loc23_ + _loc8_ * _loc24_ + _loc22_;
  283.          }
  284.          return staticPoint;
  285.       }
  286.       
  287.       public static function projectBounds(param1:Rectangle, param2:Matrix3D, param3:PerspectiveProjection) : Rectangle
  288.       {
  289.          var _loc4_:Number = param3.projectionCenter.x;
  290.          var _loc5_:Number = param3.projectionCenter.y;
  291.          param2.appendTranslation(-_loc4_,-_loc5_,param3.focalLength);
  292.          param2.append(param3.toMatrix3D());
  293.          var _loc6_:Vector3D = new Vector3D(param1.left,param1.top,0);
  294.          var _loc7_:Vector3D = new Vector3D(param1.right,param1.top,0);
  295.          var _loc8_:Vector3D = new Vector3D(param1.left,param1.bottom,0);
  296.          var _loc9_:Vector3D = new Vector3D(param1.right,param1.bottom,0);
  297.          _loc6_ = Utils3D.projectVector(param2,_loc6_);
  298.          _loc7_ = Utils3D.projectVector(param2,_loc7_);
  299.          _loc8_ = Utils3D.projectVector(param2,_loc8_);
  300.          _loc9_ = Utils3D.projectVector(param2,_loc9_);
  301.          var _loc10_:Number = Math.max(Math.max(_loc6_.x,_loc7_.x),Math.max(_loc8_.x,_loc9_.x));
  302.          var _loc11_:Number = Math.min(Math.min(_loc6_.x,_loc7_.x),Math.min(_loc8_.x,_loc9_.x));
  303.          var _loc12_:Number = Math.max(Math.max(_loc6_.y,_loc7_.y),Math.max(_loc8_.y,_loc9_.y));
  304.          var _loc13_:Number = Math.min(Math.min(_loc6_.y,_loc7_.y),Math.min(_loc8_.y,_loc9_.y));
  305.          param1.x = _loc11_ + _loc4_;
  306.          param1.y = _loc13_ + _loc5_;
  307.          param1.width = _loc10_ - _loc11_;
  308.          param1.height = _loc12_ - _loc13_;
  309.          return param1;
  310.       }
  311.       
  312.       public static function isDeltaIdentity(param1:Matrix) : Boolean
  313.       {
  314.          return param1.a == 1 && param1.d == 1 && param1.b == 0 && param1.c == 0;
  315.       }
  316.       
  317.       public static function fitBounds(param1:Number, param2:Number, param3:Matrix, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number, param11:Number) : Point
  318.       {
  319.          var _loc16_:Point = null;
  320.          var _loc17_:Point = null;
  321.          var _loc18_:Point = null;
  322.          var _loc19_:Number = NaN;
  323.          var _loc20_:Number = NaN;
  324.          if(isNaN(param1) && isNaN(param2))
  325.          {
  326.             return new Point(param6,param7);
  327.          }
  328.          var _loc12_:Number = param8 < mx_internal::MIN_MAX_TOLERANCE ? 0 : param8 - mx_internal::MIN_MAX_TOLERANCE;
  329.          var _loc13_:Number = param9 < mx_internal::MIN_MAX_TOLERANCE ? 0 : param9 - mx_internal::MIN_MAX_TOLERANCE;
  330.          var _loc14_:Number = param10 + mx_internal::MIN_MAX_TOLERANCE;
  331.          var _loc15_:Number = param11 + mx_internal::MIN_MAX_TOLERANCE;
  332.          if(!isNaN(param1) && !isNaN(param2))
  333.          {
  334.             _loc16_ = calcUBoundsToFitTBounds(param1,param2,param3,_loc12_,_loc13_,_loc14_,_loc15_);
  335.             if(!_loc16_)
  336.             {
  337.                _loc17_ = fitTBoundsWidth(param1,param3,param4,param5,param6,param7,_loc12_,_loc13_,_loc14_,_loc15_);
  338.                if(_loc17_)
  339.                {
  340.                   _loc19_ = transformSize(_loc17_.x,_loc17_.y,param3).y;
  341.                   if(_loc19_ - mx_internal::SOLUTION_TOLERANCE > param2)
  342.                   {
  343.                      _loc17_ = null;
  344.                   }
  345.                }
  346.                _loc18_ = fitTBoundsHeight(param2,param3,param4,param5,param6,param7,_loc12_,_loc13_,_loc14_,_loc15_);
  347.                if(_loc18_)
  348.                {
  349.                   _loc20_ = transformSize(_loc18_.x,_loc18_.y,param3).x;
  350.                   if(_loc20_ - mx_internal::SOLUTION_TOLERANCE > param1)
  351.                   {
  352.                      _loc18_ = null;
  353.                   }
  354.                }
  355.                if(Boolean(_loc17_) && Boolean(_loc18_))
  356.                {
  357.                   _loc16_ = _loc17_.x * _loc17_.y > _loc18_.x * _loc18_.y ? _loc17_ : _loc18_;
  358.                }
  359.                else if(_loc17_)
  360.                {
  361.                   _loc16_ = _loc17_;
  362.                }
  363.                else
  364.                {
  365.                   _loc16_ = _loc18_;
  366.                }
  367.             }
  368.             return _loc16_;
  369.          }
  370.          if(!isNaN(param1))
  371.          {
  372.             return fitTBoundsWidth(param1,param3,param4,param5,param6,param7,_loc12_,_loc13_,_loc14_,_loc15_);
  373.          }
  374.          return fitTBoundsHeight(param2,param3,param4,param5,param6,param7,_loc12_,_loc13_,_loc14_,_loc15_);
  375.       }
  376.       
  377.       private static function fitTBoundsWidth(param1:Number, param2:Matrix, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number) : Point
  378.       {
  379.          var _loc11_:Point = null;
  380.          if(!isNaN(param3) && isNaN(param4))
  381.          {
  382.             _loc11_ = calcUBoundsToFitTBoundsWidth(param1,param2,param3,param6,param3,param8,param3,param10);
  383.             if(_loc11_)
  384.             {
  385.                return _loc11_;
  386.             }
  387.          }
  388.          else if(isNaN(param3) && !isNaN(param4))
  389.          {
  390.             _loc11_ = calcUBoundsToFitTBoundsWidth(param1,param2,param5,param4,param7,param4,param9,param4);
  391.             if(_loc11_)
  392.             {
  393.                return _loc11_;
  394.             }
  395.          }
  396.          return calcUBoundsToFitTBoundsWidth(param1,param2,param5,param6,param7,param8,param9,param10);
  397.       }
  398.       
  399.       private static function fitTBoundsHeight(param1:Number, param2:Matrix, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number, param10:Number) : Point
  400.       {
  401.          var _loc11_:Point = null;
  402.          if(!isNaN(param3) && isNaN(param4))
  403.          {
  404.             _loc11_ = calcUBoundsToFitTBoundsHeight(param1,param2,param3,param6,param3,param8,param3,param10);
  405.             if(_loc11_)
  406.             {
  407.                return _loc11_;
  408.             }
  409.          }
  410.          else if(isNaN(param3) && !isNaN(param4))
  411.          {
  412.             _loc11_ = calcUBoundsToFitTBoundsHeight(param1,param2,param5,param4,param7,param4,param9,param4);
  413.             if(_loc11_)
  414.             {
  415.                return _loc11_;
  416.             }
  417.          }
  418.          return calcUBoundsToFitTBoundsHeight(param1,param2,param5,param6,param7,param8,param9,param10);
  419.       }
  420.       
  421.       public static function calcUBoundsToFitTBoundsHeight(param1:Number, param2:Matrix, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number) : Point
  422.       {
  423.          var _loc12_:Point = null;
  424.          var _loc13_:Number = NaN;
  425.          var _loc14_:Number = NaN;
  426.          var _loc15_:Number = NaN;
  427.          var _loc16_:Number = NaN;
  428.          var _loc18_:Number = NaN;
  429.          var _loc19_:Number = NaN;
  430.          var _loc9_:Number = param2.b;
  431.          var _loc10_:Number = param2.d;
  432.          if(-1e-9 < _loc9_ && _loc9_ < 1e-9)
  433.          {
  434.             _loc9_ = 0;
  435.          }
  436.          if(-1e-9 < _loc10_ && _loc10_ < 1e-9)
  437.          {
  438.             _loc10_ = 0;
  439.          }
  440.          if(_loc9_ == 0 && _loc10_ == 0)
  441.          {
  442.             return null;
  443.          }
  444.          if(_loc9_ == 0 && _loc10_ == 0)
  445.          {
  446.             return null;
  447.          }
  448.          if(_loc9_ == 0)
  449.          {
  450.             return new Point(param3,param1 / Math.abs(_loc10_));
  451.          }
  452.          if(_loc10_ == 0)
  453.          {
  454.             return new Point(param1 / Math.abs(_loc9_),param4);
  455.          }
  456.          var _loc11_:Number = _loc9_ * _loc10_ >= 0 ? _loc10_ : -_loc10_;
  457.          if(_loc11_ != 0 && param3 > 0)
  458.          {
  459.             _loc18_ = 1 / _loc11_;
  460.             param3 = Math.max(param5,Math.min(param7,param3));
  461.             _loc13_ = param3;
  462.             _loc14_ = (param1 - _loc9_ * _loc13_) * _loc18_;
  463.             if(param6 <= _loc14_ && _loc14_ <= param8 && _loc9_ * _loc13_ + _loc11_ * _loc14_ >= 0)
  464.             {
  465.                _loc12_ = new Point(_loc13_,_loc14_);
  466.             }
  467.             _loc14_ = (-param1 - _loc9_ * _loc13_) * _loc18_;
  468.             if(param6 <= _loc14_ && _loc14_ <= param8 && _loc9_ * _loc13_ + _loc11_ * _loc14_ < 0)
  469.             {
  470.                if(!_loc12_ || transformSize(_loc12_.x,_loc12_.y,param2).x > transformSize(_loc13_,_loc14_,param2).x)
  471.                {
  472.                   _loc12_ = new Point(_loc13_,_loc14_);
  473.                }
  474.             }
  475.          }
  476.          if(_loc9_ != 0 && param4 > 0)
  477.          {
  478.             _loc19_ = 1 / _loc9_;
  479.             _loc14_ = param4 = Math.max(param6,Math.min(param8,param4));
  480.             _loc13_ = (param1 - _loc11_ * _loc14_) * _loc19_;
  481.             if(param5 <= _loc13_ && _loc13_ <= param7 && _loc9_ * _loc13_ + _loc11_ * _loc14_ >= 0)
  482.             {
  483.                if(!_loc12_ || transformSize(_loc12_.x,_loc12_.y,param2).x > transformSize(_loc13_,_loc14_,param2).x)
  484.                {
  485.                   _loc12_ = new Point(_loc13_,_loc14_);
  486.                }
  487.             }
  488.             _loc13_ = (-param1 - _loc11_ * _loc14_) * _loc19_;
  489.             if(param5 <= _loc13_ && _loc13_ <= param7 && _loc9_ * _loc13_ + _loc11_ * _loc14_ < 0)
  490.             {
  491.                if(!_loc12_ || transformSize(_loc12_.x,_loc12_.y,param2).x > transformSize(_loc13_,_loc14_,param2).x)
  492.                {
  493.                   _loc12_ = new Point(_loc13_,_loc14_);
  494.                }
  495.             }
  496.          }
  497.          if(_loc12_)
  498.          {
  499.             return _loc12_;
  500.          }
  501.          _loc15_ = param2.a;
  502.          _loc16_ = param2.c;
  503.          var _loc17_:Number = _loc15_ * _loc16_ >= 0 ? _loc16_ : -_loc16_;
  504.          return solveEquation(_loc9_,_loc11_,param1,param5,param6,param7,param8,_loc15_,_loc17_);
  505.       }
  506.       
  507.       public static function calcUBoundsToFitTBoundsWidth(param1:Number, param2:Matrix, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number) : Point
  508.       {
  509.          var _loc12_:Point = null;
  510.          var _loc13_:Number = NaN;
  511.          var _loc14_:Number = NaN;
  512.          var _loc15_:Number = NaN;
  513.          var _loc16_:Number = NaN;
  514.          var _loc18_:Number = NaN;
  515.          var _loc19_:Number = NaN;
  516.          var _loc9_:Number = param2.a;
  517.          var _loc10_:Number = param2.c;
  518.          if(-1e-9 < _loc9_ && _loc9_ < 1e-9)
  519.          {
  520.             _loc9_ = 0;
  521.          }
  522.          if(-1e-9 < _loc10_ && _loc10_ < 1e-9)
  523.          {
  524.             _loc10_ = 0;
  525.          }
  526.          if(_loc9_ == 0 && _loc10_ == 0)
  527.          {
  528.             return null;
  529.          }
  530.          if(_loc9_ == 0)
  531.          {
  532.             return new Point(param3,param1 / Math.abs(_loc10_));
  533.          }
  534.          if(_loc10_ == 0)
  535.          {
  536.             return new Point(param1 / Math.abs(_loc9_),param4);
  537.          }
  538.          var _loc11_:Number = _loc9_ * _loc10_ >= 0 ? _loc10_ : -_loc10_;
  539.          if(_loc11_ != 0 && param3 > 0)
  540.          {
  541.             _loc18_ = 1 / _loc11_;
  542.             param3 = Math.max(param5,Math.min(param7,param3));
  543.             _loc13_ = param3;
  544.             _loc14_ = (param1 - _loc9_ * _loc13_) * _loc18_;
  545.             if(param6 <= _loc14_ && _loc14_ <= param8 && _loc9_ * _loc13_ + _loc11_ * _loc14_ >= 0)
  546.             {
  547.                _loc12_ = new Point(_loc13_,_loc14_);
  548.             }
  549.             _loc14_ = (-param1 - _loc9_ * _loc13_) * _loc18_;
  550.             if(param6 <= _loc14_ && _loc14_ <= param8 && _loc9_ * _loc13_ + _loc11_ * _loc14_ < 0)
  551.             {
  552.                if(!_loc12_ || transformSize(_loc12_.x,_loc12_.y,param2).y > transformSize(_loc13_,_loc14_,param2).y)
  553.                {
  554.                   _loc12_ = new Point(_loc13_,_loc14_);
  555.                }
  556.             }
  557.          }
  558.          if(_loc9_ != 0 && param4 > 0)
  559.          {
  560.             _loc19_ = 1 / _loc9_;
  561.             _loc14_ = param4 = Math.max(param6,Math.min(param8,param4));
  562.             _loc13_ = (param1 - _loc11_ * _loc14_) * _loc19_;
  563.             if(param5 <= _loc13_ && _loc13_ <= param7 && _loc9_ * _loc13_ + _loc11_ * _loc14_ >= 0)
  564.             {
  565.                if(!_loc12_ || transformSize(_loc12_.x,_loc12_.y,param2).y > transformSize(_loc13_,_loc14_,param2).y)
  566.                {
  567.                   _loc12_ = new Point(_loc13_,_loc14_);
  568.                }
  569.             }
  570.             _loc13_ = (-param1 - _loc11_ * _loc14_) * _loc19_;
  571.             if(param5 <= _loc13_ && _loc13_ <= param7 && _loc9_ * _loc13_ + _loc11_ * _loc14_ < 0)
  572.             {
  573.                if(!_loc12_ || transformSize(_loc12_.x,_loc12_.y,param2).y > transformSize(_loc13_,_loc14_,param2).y)
  574.                {
  575.                   _loc12_ = new Point(_loc13_,_loc14_);
  576.                }
  577.             }
  578.          }
  579.          if(_loc12_)
  580.          {
  581.             return _loc12_;
  582.          }
  583.          _loc15_ = param2.b;
  584.          _loc16_ = param2.d;
  585.          var _loc17_:Number = _loc15_ * _loc16_ >= 0 ? _loc16_ : -_loc16_;
  586.          return solveEquation(_loc9_,_loc11_,param1,param5,param6,param7,param8,_loc15_,_loc17_);
  587.       }
  588.       
  589.       private static function solveEquation(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:Number, param9:Number) : Point
  590.       {
  591.          var _loc10_:Number = NaN;
  592.          var _loc11_:Number = NaN;
  593.          var _loc12_:Point = null;
  594.          if(param1 == 0 || param2 == 0)
  595.          {
  596.             return null;
  597.          }
  598.          var _loc13_:Number = (param3 - param4 * param1) / param2;
  599.          var _loc14_:Number = (param3 - param6 * param1) / param2;
  600.          var _loc15_:Number = Math.max(param5,Math.min(_loc13_,_loc14_));
  601.          var _loc16_:Number = Math.min(param7,Math.max(_loc13_,_loc14_));
  602.          var _loc17_:Number = param8 * param2 - param1 * param9;
  603.          if(_loc15_ <= _loc16_)
  604.          {
  605.             if(Math.abs(_loc17_) < 1e-9)
  606.             {
  607.                _loc11_ = param3 / (param1 + param2);
  608.             }
  609.             else
  610.             {
  611.                _loc11_ = param8 * param3 / _loc17_;
  612.             }
  613.             _loc11_ = Math.max(_loc15_,Math.min(_loc11_,_loc16_));
  614.             _loc10_ = (param3 - param2 * _loc11_) / param1;
  615.             return new Point(_loc10_,_loc11_);
  616.          }
  617.          _loc13_ = -(param4 * param1 + param3) / param2;
  618.          _loc14_ = -(param6 * param1 + param3) / param2;
  619.          _loc15_ = Math.max(param5,Math.min(_loc13_,_loc14_));
  620.          _loc16_ = Math.min(param7,Math.max(_loc13_,_loc14_));
  621.          if(_loc15_ <= _loc16_)
  622.          {
  623.             if(Math.abs(_loc17_) < 1e-9)
  624.             {
  625.                _loc11_ = -param3 / (param1 + param2);
  626.             }
  627.             else
  628.             {
  629.                _loc11_ = -param8 * param3 / _loc17_;
  630.             }
  631.             _loc11_ = Math.max(_loc15_,Math.min(_loc11_,_loc16_));
  632.             _loc10_ = (-param3 - param2 * _loc11_) / param1;
  633.             return new Point(_loc10_,_loc11_);
  634.          }
  635.          return null;
  636.       }
  637.       
  638.       public static function calcUBoundsToFitTBounds(param1:Number, param2:Number, param3:Matrix, param4:Number, param5:Number, param6:Number, param7:Number) : Point
  639.       {
  640.          var _loc16_:Point = null;
  641.          var _loc8_:Number = param3.a;
  642.          var _loc9_:Number = param3.b;
  643.          var _loc10_:Number = param3.c;
  644.          var _loc11_:Number = param3.d;
  645.          if(-1e-9 < _loc8_ && _loc8_ < 1e-9)
  646.          {
  647.             _loc8_ = 0;
  648.          }
  649.          if(-1e-9 < _loc9_ && _loc9_ < 1e-9)
  650.          {
  651.             _loc9_ = 0;
  652.          }
  653.          if(-1e-9 < _loc10_ && _loc10_ < 1e-9)
  654.          {
  655.             _loc10_ = 0;
  656.          }
  657.          if(-1e-9 < _loc11_ && _loc11_ < 1e-9)
  658.          {
  659.             _loc11_ = 0;
  660.          }
  661.          if(_loc9_ == 0 && _loc10_ == 0)
  662.          {
  663.             if(_loc8_ == 0 || _loc11_ == 0)
  664.             {
  665.                return null;
  666.             }
  667.             return new Point(param1 / Math.abs(_loc8_),param2 / Math.abs(_loc11_));
  668.          }
  669.          if(_loc8_ == 0 && _loc11_ == 0)
  670.          {
  671.             if(_loc9_ == 0 || _loc10_ == 0)
  672.             {
  673.                return null;
  674.             }
  675.             return new Point(param2 / Math.abs(_loc9_),param1 / Math.abs(_loc10_));
  676.          }
  677.          var _loc12_:Number = _loc8_ * _loc10_ >= 0 ? _loc10_ : -_loc10_;
  678.          var _loc13_:Number = _loc9_ * _loc11_ >= 0 ? _loc11_ : -_loc11_;
  679.          var _loc14_:Number = _loc8_ * _loc13_ - _loc9_ * _loc12_;
  680.          if(Math.abs(_loc14_) < 1e-9)
  681.          {
  682.             if(_loc12_ == 0 || _loc8_ == 0 || _loc8_ == -_loc12_)
  683.             {
  684.                return null;
  685.             }
  686.             if(Math.abs(_loc8_ * param2 - _loc9_ * param1) > 1e-9)
  687.             {
  688.                return null;
  689.             }
  690.             return solveEquation(_loc8_,_loc12_,param1,param4,param4,param6,param7,_loc9_,_loc13_);
  691.          }
  692.          var _loc15_:Number = 1 / _loc14_;
  693.          param1 *= _loc15_;
  694.          param2 *= _loc15_;
  695.          _loc16_ = solveSystem(_loc8_,_loc12_,_loc9_,_loc13_,param1,param2);
  696.          if((_loc16_) && param4 <= _loc16_.x && _loc16_.x <= param6 && param5 <= _loc16_.y && _loc16_.y <= param7 && _loc8_ * _loc16_.x + _loc12_ * _loc16_.x >= 0 && _loc9_ * _loc16_.x + _loc13_ * _loc16_.y >= 0)
  697.          {
  698.             return _loc16_;
  699.          }
  700.          _loc16_ = solveSystem(_loc8_,_loc12_,_loc9_,_loc13_,param1,-param2);
  701.          if((_loc16_) && param4 <= _loc16_.x && _loc16_.x <= param6 && param5 <= _loc16_.y && _loc16_.y <= param7 && _loc8_ * _loc16_.x + _loc12_ * _loc16_.x >= 0 && _loc9_ * _loc16_.x + _loc13_ * _loc16_.y < 0)
  702.          {
  703.             return _loc16_;
  704.          }
  705.          _loc16_ = solveSystem(_loc8_,_loc12_,_loc9_,_loc13_,-param1,param2);
  706.          if((_loc16_) && param4 <= _loc16_.x && _loc16_.x <= param6 && param5 <= _loc16_.y && _loc16_.y <= param7 && _loc8_ * _loc16_.x + _loc12_ * _loc16_.x < 0 && _loc9_ * _loc16_.x + _loc13_ * _loc16_.y >= 0)
  707.          {
  708.             return _loc16_;
  709.          }
  710.          _loc16_ = solveSystem(_loc8_,_loc12_,_loc9_,_loc13_,-param1,-param2);
  711.          if((_loc16_) && param4 <= _loc16_.x && _loc16_.x <= param6 && param5 <= _loc16_.y && _loc16_.y <= param7 && _loc8_ * _loc16_.x + _loc12_ * _loc16_.x < 0 && _loc9_ * _loc16_.x + _loc13_ * _loc16_.y < 0)
  712.          {
  713.             return _loc16_;
  714.          }
  715.          return null;
  716.       }
  717.       
  718.       public static function isEqual(param1:Matrix, param2:Matrix) : Boolean
  719.       {
  720.          return param1 && param2 && param1.a == param2.a && param1.b == param2.b && param1.c == param2.c && param1.d == param2.d && param1.tx == param2.tx && param1.ty == param2.ty || !param1 && !param2;
  721.       }
  722.       
  723.       public static function isEqual3D(param1:Matrix3D, param2:Matrix3D) : Boolean
  724.       {
  725.          var _loc3_:Vector.<Number> = null;
  726.          var _loc4_:Vector.<Number> = null;
  727.          if(Boolean(param1) && Boolean(param2) && param1.rawData.length == param2.rawData.length)
  728.          {
  729.             _loc3_ = param1.rawData;
  730.             _loc4_ = param2.rawData;
  731.             return _loc3_[0] == _loc4_[0] && _loc3_[1] == _loc4_[1] && _loc3_[2] == _loc4_[2] && _loc3_[3] == _loc4_[3] && _loc3_[4] == _loc4_[4] && _loc3_[5] == _loc4_[5] && _loc3_[6] == _loc4_[6] && _loc3_[7] == _loc4_[7] && _loc3_[8] == _loc4_[8] && _loc3_[9] == _loc4_[9] && _loc3_[10] == _loc4_[10] && _loc3_[11] == _loc4_[11] && _loc3_[12] == _loc4_[12] && _loc3_[13] == _loc4_[13] && _loc3_[14] == _loc4_[14] && _loc3_[15] == _loc4_[15];
  732.          }
  733.          return !param1 && !param2;
  734.       }
  735.       
  736.       private static function solveSystem(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number) : Point
  737.       {
  738.          return new Point(param4 * param5 - param2 * param6,param1 * param6 - param3 * param5);
  739.       }
  740.       
  741.       public static function getConcatenatedMatrix(param1:DisplayObject, param2:DisplayObject) : Matrix
  742.       {
  743.          return getConcatenatedMatrixHelper(param1,false,param2);
  744.       }
  745.       
  746.       public static function getConcatenatedComputedMatrix(param1:DisplayObject, param2:DisplayObject) : Matrix
  747.       {
  748.          return getConcatenatedMatrixHelper(param1,true,param2);
  749.       }
  750.       
  751.       private static function getConcatenatedMatrixHelper(param1:DisplayObject, param2:Boolean, param3:DisplayObject) : Matrix
  752.       {
  753.          var _loc5_:Rectangle = null;
  754.          var _loc6_:Boolean = false;
  755.          var _loc7_:Boolean = false;
  756.          var _loc8_:Object = null;
  757.          var _loc9_:ApplicationDomain = null;
  758.          var _loc4_:Matrix = new Matrix();
  759.          if(usesMarshalling == null)
  760.          {
  761.             usesMarshalling = ApplicationDomain.currentDomain.hasDefinition("mx.managers.systemClasses.MarshallingSupport");
  762.             if(!usesMarshalling && ApplicationDomain.currentDomain.hasDefinition("mx.core.UIComponent"))
  763.             {
  764.                uiComponentClass = Class(ApplicationDomain.currentDomain.getDefinition("mx.core.UIComponent"));
  765.             }
  766.             if(!usesMarshalling && ApplicationDomain.currentDomain.hasDefinition("mx.flash.UIMovieClip"))
  767.             {
  768.                uiMovieClipClass = Class(ApplicationDomain.currentDomain.getDefinition("mx.flash.UIMovieClip"));
  769.             }
  770.          }
  771.          if(fakeDollarParent == null)
  772.          {
  773.             fakeDollarParent = new QName(mx_internal,"$parent");
  774.          }
  775.          if(param2 && computedMatrixProperty == null)
  776.          {
  777.             computedMatrixProperty = new QName(mx_internal,"computedMatrix");
  778.          }
  779.          if($transformProperty == null)
  780.          {
  781.             $transformProperty = new QName(mx_internal,"$transform");
  782.          }
  783.          while(param1 && param1.transform.matrix && param1 != param3)
  784.          {
  785.             _loc5_ = param1.scrollRect;
  786.             if(_loc5_ != null)
  787.             {
  788.                _loc4_.translate(-_loc5_.x,-_loc5_.y);
  789.             }
  790.             if(Boolean(usesMarshalling) && "moduleFactory" in param1)
  791.             {
  792.                _loc8_ = param1["moduleFactory"];
  793.                if((_loc8_) && _loc8_ !== lastModuleFactory && "info" in _loc8_)
  794.                {
  795.                   _loc9_ = _loc8_["info"]()["currentDomain"];
  796.                   if((Boolean(_loc9_)) && _loc9_.hasDefinition("mx.core.UIComponent"))
  797.                   {
  798.                      uiComponentClass = Class(_loc9_.getDefinition("mx.core.UIComponent"));
  799.                   }
  800.                   if(Boolean(_loc9_) && _loc9_.hasDefinition("mx.flash.UIMovieClip"))
  801.                   {
  802.                      uiMovieClipClass = Class(_loc9_.getDefinition("mx.flash.UIMovieClip"));
  803.                   }
  804.                   lastModuleFactory = _loc8_;
  805.                }
  806.             }
  807.             _loc6_ = Boolean(uiComponentClass) && param1 is uiComponentClass;
  808.             _loc7_ = Boolean(uiMovieClipClass) && param1 is uiMovieClipClass;
  809.             if(param2 && _loc6_)
  810.             {
  811.                _loc4_.concat(param1[computedMatrixProperty]);
  812.             }
  813.             else if(_loc7_)
  814.             {
  815.                _loc4_.concat(param1[$transformProperty].matrix);
  816.             }
  817.             else
  818.             {
  819.                _loc4_.concat(param1.transform.matrix);
  820.             }
  821.             if(_loc6_)
  822.             {
  823.                param1 = param1[fakeDollarParent] as DisplayObject;
  824.             }
  825.             else
  826.             {
  827.                param1 = param1.parent as DisplayObject;
  828.             }
  829.          }
  830.          return _loc4_;
  831.       }
  832.    }
  833. }
  834.  
  835.