home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / graphics / RectangularDropShadow.as next >
Text File  |  2008-09-02  |  12KB  |  378 lines
  1. package mx.graphics
  2. {
  3.    import flash.display.BitmapData;
  4.    import flash.display.Graphics;
  5.    import flash.display.Shape;
  6.    import flash.filters.DropShadowFilter;
  7.    import flash.geom.Matrix;
  8.    import flash.geom.Point;
  9.    import flash.geom.Rectangle;
  10.    import mx.core.FlexShape;
  11.    import mx.core.mx_internal;
  12.    import mx.utils.GraphicsUtil;
  13.    
  14.    use namespace mx_internal;
  15.    
  16.    public class RectangularDropShadow
  17.    {
  18.       
  19.       mx_internal static const VERSION:String = "2.0.1.0";
  20.        
  21.       
  22.       private var leftShadow:BitmapData;
  23.       
  24.       private var _tlRadius:Number = 0;
  25.       
  26.       private var _angle:Number = 45;
  27.       
  28.       private var topShadow:BitmapData;
  29.       
  30.       private var _distance:Number = 4;
  31.       
  32.       private var rightShadow:BitmapData;
  33.       
  34.       private var _alpha:Number = 0.4;
  35.       
  36.       private var shadow:BitmapData;
  37.       
  38.       private var _brRadius:Number = 0;
  39.       
  40.       private var _blRadius:Number = 0;
  41.       
  42.       private var _color:int = 0;
  43.       
  44.       private var _trRadius:Number = 0;
  45.       
  46.       private var bottomShadow:BitmapData;
  47.       
  48.       private var changed:Boolean = true;
  49.       
  50.       public function RectangularDropShadow()
  51.       {
  52.          changed = true;
  53.          _alpha = 0.4;
  54.          _angle = 45;
  55.          _color = 0;
  56.          _distance = 4;
  57.          _tlRadius = 0;
  58.          _trRadius = 0;
  59.          _blRadius = 0;
  60.          _brRadius = 0;
  61.          super();
  62.       }
  63.       
  64.       public function set trRadius(param1:Number) : void
  65.       {
  66.          if(_trRadius != param1)
  67.          {
  68.             _trRadius = param1;
  69.             changed = true;
  70.          }
  71.       }
  72.       
  73.       public function get blRadius() : Number
  74.       {
  75.          return _blRadius;
  76.       }
  77.       
  78.       public function set brRadius(param1:Number) : void
  79.       {
  80.          if(_brRadius != param1)
  81.          {
  82.             _brRadius = param1;
  83.             changed = true;
  84.          }
  85.       }
  86.       
  87.       public function set color(param1:int) : void
  88.       {
  89.          if(_color != param1)
  90.          {
  91.             _color = param1;
  92.             changed = true;
  93.          }
  94.       }
  95.       
  96.       public function drawShadow(param1:Graphics, param2:Number, param3:Number, param4:Number, param5:Number) : void
  97.       {
  98.          var _loc6_:int = 0;
  99.          var _loc7_:int = 0;
  100.          var _loc8_:int = 0;
  101.          var _loc9_:int = 0;
  102.          var _loc10_:int = 0;
  103.          var _loc11_:int = 0;
  104.          var _loc12_:Number = NaN;
  105.          var _loc13_:Number = NaN;
  106.          var _loc14_:Matrix = null;
  107.          var _loc15_:Number = NaN;
  108.          var _loc16_:Number = NaN;
  109.          var _loc17_:Number = NaN;
  110.          var _loc18_:Number = NaN;
  111.          var _loc19_:Number = NaN;
  112.          var _loc20_:Number = NaN;
  113.          var _loc21_:Number = NaN;
  114.          var _loc22_:Number = NaN;
  115.          if(changed)
  116.          {
  117.             createShadowBitmaps();
  118.             changed = false;
  119.          }
  120.          param4 = Math.ceil(param4);
  121.          param5 = Math.ceil(param5);
  122.          _loc6_ = !!leftShadow ? int(leftShadow.width) : 0;
  123.          _loc7_ = !!rightShadow ? int(rightShadow.width) : 0;
  124.          _loc8_ = !!topShadow ? int(topShadow.height) : 0;
  125.          _loc9_ = !!bottomShadow ? int(bottomShadow.height) : 0;
  126.          _loc10_ = _loc6_ + _loc7_;
  127.          _loc11_ = _loc8_ + _loc9_;
  128.          _loc12_ = (param5 + _loc11_) / 2;
  129.          _loc13_ = (param4 + _loc10_) / 2;
  130.          _loc14_ = new Matrix();
  131.          if(leftShadow || topShadow)
  132.          {
  133.             _loc15_ = Math.min(tlRadius + _loc10_,_loc13_);
  134.             _loc16_ = Math.min(tlRadius + _loc11_,_loc12_);
  135.             _loc14_.tx = param2 - _loc6_;
  136.             _loc14_.ty = param3 - _loc8_;
  137.             param1.beginBitmapFill(shadow,_loc14_);
  138.             param1.drawRect(param2 - _loc6_,param3 - _loc8_,_loc15_,_loc16_);
  139.             param1.endFill();
  140.          }
  141.          if(rightShadow || topShadow)
  142.          {
  143.             _loc17_ = Math.min(trRadius + _loc10_,_loc13_);
  144.             _loc18_ = Math.min(trRadius + _loc11_,_loc12_);
  145.             _loc14_.tx = param2 + param4 + _loc7_ - shadow.width;
  146.             _loc14_.ty = param3 - _loc8_;
  147.             param1.beginBitmapFill(shadow,_loc14_);
  148.             param1.drawRect(param2 + param4 + _loc7_ - _loc17_,param3 - _loc8_,_loc17_,_loc18_);
  149.             param1.endFill();
  150.          }
  151.          if(leftShadow || bottomShadow)
  152.          {
  153.             _loc19_ = Math.min(blRadius + _loc10_,_loc13_);
  154.             _loc20_ = Math.min(blRadius + _loc11_,_loc12_);
  155.             _loc14_.tx = param2 - _loc6_;
  156.             _loc14_.ty = param3 + param5 + _loc9_ - shadow.height;
  157.             param1.beginBitmapFill(shadow,_loc14_);
  158.             param1.drawRect(param2 - _loc6_,param3 + param5 + _loc9_ - _loc20_,_loc19_,_loc20_);
  159.             param1.endFill();
  160.          }
  161.          if(rightShadow || bottomShadow)
  162.          {
  163.             _loc21_ = Math.min(brRadius + _loc10_,_loc13_);
  164.             _loc22_ = Math.min(brRadius + _loc11_,_loc12_);
  165.             _loc14_.tx = param2 + param4 + _loc7_ - shadow.width;
  166.             _loc14_.ty = param3 + param5 + _loc9_ - shadow.height;
  167.             param1.beginBitmapFill(shadow,_loc14_);
  168.             param1.drawRect(param2 + param4 + _loc7_ - _loc21_,param3 + param5 + _loc9_ - _loc22_,_loc21_,_loc22_);
  169.             param1.endFill();
  170.          }
  171.          if(leftShadow)
  172.          {
  173.             _loc14_.tx = param2 - _loc6_;
  174.             _loc14_.ty = 0;
  175.             param1.beginBitmapFill(leftShadow,_loc14_);
  176.             param1.drawRect(param2 - _loc6_,param3 - _loc8_ + _loc16_,_loc6_,param5 + _loc8_ + _loc9_ - _loc16_ - _loc20_);
  177.             param1.endFill();
  178.          }
  179.          if(rightShadow)
  180.          {
  181.             _loc14_.tx = param2 + param4;
  182.             _loc14_.ty = 0;
  183.             param1.beginBitmapFill(rightShadow,_loc14_);
  184.             param1.drawRect(param2 + param4,param3 - _loc8_ + _loc18_,_loc7_,param5 + _loc8_ + _loc9_ - _loc18_ - _loc22_);
  185.             param1.endFill();
  186.          }
  187.          if(topShadow)
  188.          {
  189.             _loc14_.tx = 0;
  190.             _loc14_.ty = param3 - _loc8_;
  191.             param1.beginBitmapFill(topShadow,_loc14_);
  192.             param1.drawRect(param2 - _loc6_ + _loc15_,param3 - _loc8_,param4 + _loc6_ + _loc7_ - _loc15_ - _loc17_,_loc8_);
  193.             param1.endFill();
  194.          }
  195.          if(bottomShadow)
  196.          {
  197.             _loc14_.tx = 0;
  198.             _loc14_.ty = param3 + param5;
  199.             param1.beginBitmapFill(bottomShadow,_loc14_);
  200.             param1.drawRect(param2 - _loc6_ + _loc19_,param3 + param5,param4 + _loc6_ + _loc7_ - _loc19_ - _loc21_,_loc9_);
  201.             param1.endFill();
  202.          }
  203.       }
  204.       
  205.       public function get angle() : Number
  206.       {
  207.          return _angle;
  208.       }
  209.       
  210.       private function createShadowBitmaps() : void
  211.       {
  212.          var _loc1_:Number = NaN;
  213.          var _loc2_:Number = NaN;
  214.          var _loc3_:Shape = null;
  215.          var _loc4_:Graphics = null;
  216.          var _loc5_:BitmapData = null;
  217.          var _loc6_:DropShadowFilter = null;
  218.          var _loc7_:Rectangle = null;
  219.          var _loc8_:Rectangle = null;
  220.          var _loc9_:Number = NaN;
  221.          var _loc10_:Number = NaN;
  222.          var _loc11_:Number = NaN;
  223.          var _loc12_:Number = NaN;
  224.          var _loc13_:Point = null;
  225.          var _loc14_:Rectangle = null;
  226.          _loc1_ = Math.max(tlRadius,blRadius) + 2 * distance + Math.max(trRadius,brRadius);
  227.          _loc2_ = Math.max(tlRadius,trRadius) + 2 * distance + Math.max(blRadius,brRadius);
  228.          if(_loc1_ < 0 || _loc2_ < 0)
  229.          {
  230.             return;
  231.          }
  232.          _loc3_ = new FlexShape();
  233.          (_loc4_ = _loc3_.graphics).beginFill(16777215);
  234.          GraphicsUtil.drawRoundRectComplex(_loc4_,0,0,_loc1_,_loc2_,tlRadius,trRadius,blRadius,brRadius);
  235.          _loc4_.endFill();
  236.          (_loc5_ = new BitmapData(_loc1_,_loc2_,true,0)).draw(_loc3_,new Matrix());
  237.          (_loc6_ = new DropShadowFilter(distance,angle,color,alpha)).knockout = true;
  238.          _loc7_ = new Rectangle(0,0,_loc1_,_loc2_);
  239.          _loc8_ = _loc5_.generateFilterRect(_loc7_,_loc6_);
  240.          _loc9_ = _loc7_.left - _loc8_.left;
  241.          _loc10_ = _loc8_.right - _loc7_.right;
  242.          _loc11_ = _loc7_.top - _loc8_.top;
  243.          _loc12_ = _loc8_.bottom - _loc7_.bottom;
  244.          shadow = new BitmapData(_loc8_.width,_loc8_.height);
  245.          shadow.applyFilter(_loc5_,_loc7_,new Point(_loc9_,_loc11_),_loc6_);
  246.          _loc13_ = new Point(0,0);
  247.          _loc14_ = new Rectangle();
  248.          if(_loc9_ > 0)
  249.          {
  250.             _loc14_.x = 0;
  251.             _loc14_.y = tlRadius + _loc11_ + _loc12_;
  252.             _loc14_.width = _loc9_;
  253.             _loc14_.height = 1;
  254.             leftShadow = new BitmapData(_loc9_,1);
  255.             leftShadow.copyPixels(shadow,_loc14_,_loc13_);
  256.          }
  257.          else
  258.          {
  259.             leftShadow = null;
  260.          }
  261.          if(_loc10_ > 0)
  262.          {
  263.             _loc14_.x = shadow.width - _loc10_;
  264.             _loc14_.y = trRadius + _loc11_ + _loc12_;
  265.             _loc14_.width = _loc10_;
  266.             _loc14_.height = 1;
  267.             rightShadow = new BitmapData(_loc10_,1);
  268.             rightShadow.copyPixels(shadow,_loc14_,_loc13_);
  269.          }
  270.          else
  271.          {
  272.             rightShadow = null;
  273.          }
  274.          if(_loc11_ > 0)
  275.          {
  276.             _loc14_.x = tlRadius + _loc9_ + _loc10_;
  277.             _loc14_.y = 0;
  278.             _loc14_.width = 1;
  279.             _loc14_.height = _loc11_;
  280.             topShadow = new BitmapData(1,_loc11_);
  281.             topShadow.copyPixels(shadow,_loc14_,_loc13_);
  282.          }
  283.          else
  284.          {
  285.             topShadow = null;
  286.          }
  287.          if(_loc12_ > 0)
  288.          {
  289.             _loc14_.x = blRadius + _loc9_ + _loc10_;
  290.             _loc14_.y = shadow.height - _loc12_;
  291.             _loc14_.width = 1;
  292.             _loc14_.height = _loc12_;
  293.             bottomShadow = new BitmapData(1,_loc12_);
  294.             bottomShadow.copyPixels(shadow,_loc14_,_loc13_);
  295.          }
  296.          else
  297.          {
  298.             bottomShadow = null;
  299.          }
  300.       }
  301.       
  302.       public function get brRadius() : Number
  303.       {
  304.          return _brRadius;
  305.       }
  306.       
  307.       public function get alpha() : Number
  308.       {
  309.          return _alpha;
  310.       }
  311.       
  312.       public function get color() : int
  313.       {
  314.          return _color;
  315.       }
  316.       
  317.       public function set angle(param1:Number) : void
  318.       {
  319.          if(_angle != param1)
  320.          {
  321.             _angle = param1;
  322.             changed = true;
  323.          }
  324.       }
  325.       
  326.       public function set tlRadius(param1:Number) : void
  327.       {
  328.          if(_tlRadius != param1)
  329.          {
  330.             _tlRadius = param1;
  331.             changed = true;
  332.          }
  333.       }
  334.       
  335.       public function get trRadius() : Number
  336.       {
  337.          return _trRadius;
  338.       }
  339.       
  340.       public function set distance(param1:Number) : void
  341.       {
  342.          if(_distance != param1)
  343.          {
  344.             _distance = param1;
  345.             changed = true;
  346.          }
  347.       }
  348.       
  349.       public function get distance() : Number
  350.       {
  351.          return _distance;
  352.       }
  353.       
  354.       public function get tlRadius() : Number
  355.       {
  356.          return _tlRadius;
  357.       }
  358.       
  359.       public function set alpha(param1:Number) : void
  360.       {
  361.          if(_alpha != param1)
  362.          {
  363.             _alpha = param1;
  364.             changed = true;
  365.          }
  366.       }
  367.       
  368.       public function set blRadius(param1:Number) : void
  369.       {
  370.          if(_blRadius != param1)
  371.          {
  372.             _blRadius = param1;
  373.             changed = true;
  374.          }
  375.       }
  376.    }
  377. }
  378.