作者：未知 来源：月光软件站 加入时间：2005-2-28　月光软件站

// ***********************************************************************************************
// 			                      ______
// 			                   .-"      "-.
// 			                  /    AOL     \
// 			                 |              |
// 			                 |,  .-.  .-.  ,|
// 			                 | )(__/  \__)( |
// 			                 |/     /\     \|
// 			       (@_       (_     ^^     _)
// 			  _     ) \_______\__|IIIIII|__/__________________________
// 			 (_)@8@8{}<________|-\IIIIII/-|___________________________>
// 			        )_/        \          /
// 			       (@           `--------`                    AOL FLASH STUDIO
//
// ***********************************************************************************************
//
//    @FileName Graphic.as
//    @Description 图形类
//    @Package com.flashvan
//    @Author AOL
//    @Email [email protected]
//    @Create 2004.7.18
//    @LastChange 2004.7.18
//    @History
//
// ***********************************************************************************************
dynamic class com.flashvan.Graphic extends MovieClip
{
        static var symbolName:String = "__Packages.com.flashvan.Graphic";
        static var symbolOwner:Function = com.flashvan.Graphic;
        static var symbolLinked = Object.registerClass(symbolName, symbolOwner);
        
        
        function Graphic()
        {
                
        }
        
        
        static function create(base_mc:MovieClip, name:String, depth:Number,o:Object)
        {
                var mc = base_mc.attachMovie(symbolName, name, depth,o);
                return mc;
        }
        
        function drawRect(x1:Number, y1:Number, x2:Number, y2:Number):Void
        {
                moveTo(x1,y1);
                lineTo(x2,y1);
                lineTo(x2,y2);
                lineTo(x1,y2);
                lineTo(x1,y1);
        }
        
        
        function drawLine(x1:Number, y1:Number, x2:Number, y2:Number):Void
        {
                
        }
        
        function fillRect(x:Number, y:Number, width:Number, height:Number):Void
        {
                
        }
        
        // drawRoundRect
        // x - x position of  fill
        // y - y position of  fill
        // w - width of  fill
        // h  - height of  fill
        // r - corner radius of fill :: number or object {br:#,bl:#,tl:#,tr:#}
        // c - hex color of fill :: number or array [0x######,0x######]
        // alpha - alpha value of fill :: number or array [0x######,0x######]
        // rot - rotation of fill :: number or matrix object  {matrixType:"box",x:#,y:#,w:#,h:#,r:(#*(Math.PI/180))}
        // gradient - type of gradient "linear" or "radial"
        // ratios - (optional :: default  [0,255]) - specifies the distribution of colors :: array [#,#];
        function drawRoundRect(x:Number,y:Number,w:Number,h:Number,r,c,alpha,rot,gradient:String,ratios)
        {
                if (typeof r == "object") {
                        var rbr = r.br //bottom right corner
                        var rbl = r.bl //bottom left corner
                        var rtl = r.tl //top left corner
                        var rtr = r.tr //top right corner
                }
                else
                {
                        var rbr =  rbl = rtl = rtr = r;
                }
                // if color is an object then allow for complex fills
                if(typeof c == "object")
                {
                        if (typeof alpha != "object")
                        var alphas = [alpha,alpha];
                        else
                        var alphas = alpha;
                        
                        if (ratios == undefined)
                        var ratios = [ 0, 0xff ];
                        
                        var sh = h *.7
                        if (typeof rot != "object")
                        var matrix = {matrixType:"box", x:-sh, y:sh, w:w*2, h:h*4, r:rot * 0.0174532925199433 }
                        else
                        var matrix = rot;
                        
                        if (gradient == "radial")
                        beginGradientFill( "radial", c, alphas, ratios, matrix );
                        else
                        beginGradientFill( "linear", c, alphas, ratios, matrix );
                        
                }
                else if (c != undefined)
                {
                        beginFill (c, alpha);
                }
                
                // Math.sin and Math,tan values for optimal performance.
                // Math.rad = Math.PI/180 = 0.0174532925199433
                // r*Math.sin(45*Math.rad) =  (r*0.707106781186547);
                // r*Math.tan(22.5*Math.rad) = (r*0.414213562373095);
                
                //bottom right corner
                r = rbr;
                var a = r - (r*0.707106781186547); //radius - anchor pt;
                var s = r - (r*0.414213562373095); //radius - control pt;
                moveTo ( x+w,y+h-r);
                lineTo ( x+w,y+h-r );
                curveTo( x+w,y+h-s,x+w-a,y+h-a);
                curveTo( x+w-s,y+h,x+w-r,y+h);
                
                //bottom left corner
                r = rbl;
                var a = r - (r*0.707106781186547);
                var s = r - (r*0.414213562373095);
                lineTo ( x+r,y+h );
                curveTo( x+s,y+h,x+a,y+h-a);
                curveTo( x,y+h-s,x,y+h-r);
                
                //top left corner
                r = rtl;
                var a = r - (r*0.707106781186547);
                var s = r - (r*0.414213562373095);
                lineTo ( x,y+r );
                curveTo( x,y+s,x+a,y+a);
                curveTo( x+s,y,x+r,y);
                
                //top right
                r = rtr;
                var a = r - (r*0.707106781186547);
                var s = r - (r*0.414213562373095);
                lineTo ( x+w-r,y );
                curveTo( x+w-s,y,x+w-a,y+a);
                curveTo( x+w,y+s,x+w,y+r);
                lineTo ( x+w,y+h-r );
                
                if (c != undefined)
                endFill();
        }
        
        
        // ==============
        // mc.drawOval() - by Ric Ewing ([email protected]) - version 1.1 - 4.7.2002
        //
        // x, y = center of oval
        // radius = radius of oval. If [optional] yRadius is defined, r is the x radius.
        // yRadius = [optional] y radius of oval.
        // ==============
        function drawOval(x:Number, y:Number, radius:Number, yRadius:Number):Void
        {
                
                if (arguments.length<3)
                {
                        return;
                }
                // init variables
                var theta:Number, xrCtrl:Number, yrCtrl:Number, angle:Number, angleMid:Number;
                var px:Number, py:Number, cx:Number, cy:Number;
                // if only yRadius is undefined, yRadius = radius
                if (yRadius == undefined)
                {
                        yRadius = radius;
                }
                // covert 45 degrees to radians for our calculations
                theta = Math.PI/4;
                // calculate the distance for the control point
                xrCtrl = radius/Math.cos(theta/2);
                yrCtrl = yRadius/Math.cos(theta/2);
                // start on the right side of the circle
                angle = 0;
                moveTo(x+radius, y);
                // this loop draws the circle in 8 segments
                for (var i = 0; i<8; i++)
                {
                        // increment our angles
                        angle += theta;
                        angleMid = angle-(theta/2);
                        // calculate our control point
                        cx = x+Math.cos(angleMid)*xrCtrl;
                        cy = y+Math.sin(angleMid)*yrCtrl;
                        // calculate our end point
                        px = x+Math.cos(angle)*radius;
                        py = y+Math.sin(angle)*yRadius;
                        // draw the circle segment
                        curveTo(cx, cy, px, py);
                }
        }
        
        
        // ==============
        // mc.drawArc() - by Ric Ewing ([email protected]) - version 1.5 - 4.7.2002
        //
        // x, y = This must be the current pen position... other values will look bad
        // radius = radius of Arc. If [optional] yRadius is defined, then r is the x radius
        // arc = sweep of the arc. Negative values draw clockwise.
        // startAngle = starting angle in degrees.
        // yRadius = [optional] y radius of arc. Thanks to Robert Penner for the idea.
        // ==============
        // Thanks to: Robert Penner, Eric Mueller and Michael Hurwicz for their contributions.
        // ==============
        function drawArc(x:Number, y:Number, radius:Number, arc:Number, startAngle:Number, yRadius:Number)
        {
                
                if (arguments.length<5)
                {
                        return;
                }
                // if yRadius is undefined, yRadius = radius
                if (yRadius == undefined)
                {
                        yRadius = radius;
                }
                // Init vars
                var segAngle:Number, theta:Number, angle:Number, angleMid:Number, segs:Number;
                var ax:Number, ay:Number, bx:Number, by:Number, cx:Number, cy:Number;
                // no sense in drawing more than is needed :)
                if (Math.abs(arc)>360)
                {
                        arc = 360;
                }
                // Flash uses 8 segments per circle, to match that, we draw in a maximum
                // of 45 degree segments. First we calculate how many segments are needed
                // for our arc.
                segs = Math.ceil(Math.abs(arc)/45);
                // Now calculate the sweep of each segment
                segAngle = arc/segs;
                // The math requires radians rather than degrees. To convert from degrees
                // use the formula (degrees/180)*Math.PI to get radians.
                theta = -(segAngle/180)*Math.PI;
                // convert angle startAngle to radians
                angle = -(startAngle/180)*Math.PI;
                // find our starting points (ax,ay) relative to the secified x,y
                ax = x-Math.cos(angle)*radius;
                ay = y-Math.sin(angle)*yRadius;
                // if our arc is larger than 45 degrees, draw as 45 degree segments
                // so that we match Flash's native circle routines.
                if (segs>0)
                {
                        // Loop for drawing arc segments
                        for (var i = 0; i// increment our angle
                                angle += theta;
                                // find the angle halfway between the last angle and the new
                                angleMid = angle-(theta/2);
                                // calculate our end point
                                bx = ax+Math.cos(angle)*radius;
                                by = ay+Math.sin(angle)*yRadius;
                                // calculate our control point
                                cx = ax+Math.cos(angleMid)*(radius/Math.cos(theta/2));
                                cy = ay+Math.sin(angleMid)*(yRadius/Math.cos(theta/2));
                                // draw the arc segment
                                curveTo(cx, cy, bx, by);
                        }
                }
                // In the native draw methods the user must specify the end point
                // which means that they always know where they are ending at, but
                // here the endpoint is unknown unless the user calculates it on their
                // own. Lets be nice and let save them the hassle by passing it back.
                return {x:bx, y:by};
        }
        
        
        // ==============
        // mc.drawBurst() - by Ric Ewing ([email protected]) - version 1.4 - 4.7.2002
        //
        // x, y = center of burst
        // sides = number of sides or points
        // innerRadius = radius of the indent of the curves
        // outerRadius = radius of the outermost points
        // angle = [optional] starting angle in degrees. (defaults to 0)
        // ==============
        function drawBurst(x:Number, y:Number, sides:Number, innerRadius:Number, outerRadius:Number, angle:Number)
        {
                
                if(arguments<5)
                {
                        return;
                }
                if (sides>2)
                {
                        // init vars
                        var step:Number, halfStep:Number, qtrStep:Number, start:Number, n:Number;
                        var dx:Number, dy:Number, cx:Number, cy:Number;
                        // calculate length of sides
                        step = (Math.PI*2)/sides;
                        halfStep = step/2;
                        qtrStep = step/4;
                        // calculate starting angle in radians
                        start = (angle/180)*Math.PI;
                        moveTo(x+(Math.cos(start)*outerRadius), y-(Math.sin(start)*outerRadius));
                        // draw curves
                        for (n=1; n<=sides; n++)
                        {
                                cx = x+Math.cos(start+(step*n)-(qtrStep*3))*(innerRadius/Math.cos(qtrStep));
                                cy = y-Math.sin(start+(step*n)-(qtrStep*3))*(innerRadius/Math.cos(qtrStep));
                                dx = x+Math.cos(start+(step*n)-halfStep)*innerRadius;
                                dy = y-Math.sin(start+(step*n)-halfStep)*innerRadius;
                                curveTo(cx, cy, dx, dy);
                                cx = x+Math.cos(start+(step*n)-qtrStep)*(innerRadius/Math.cos(qtrStep));
                                cy = y-Math.sin(start+(step*n)-qtrStep)*(innerRadius/Math.cos(qtrStep));
                                dx = x+Math.cos(start+(step*n))*outerRadius;
                                dy = y-Math.sin(start+(step*n))*outerRadius;
                                curveTo(cx, cy, dx, dy);
                        }
                }
        };
        
        
        function drawPoly (x:Number, y:Number, sides:Number, radius:Number, angle:Number)
        {
                if (arguments.length<4)
                {
                        return;
                }
                // convert sides to positive value
                var count:Number = Math.abs(sides);
                // check that count is sufficient to build polygon
                if (count>2)
                {
                        // init vars
                        var step:Number, start:Number, n:Number, dx:Number, dy:Number;
                        // calculate span of sides
                        step = (Math.PI*2)/sides;
                        // calculate starting angle in radians
                        start = (angle/180)*Math.PI;
                        moveTo(x+(Math.cos(start)*radius), y-(Math.sin(start)*radius));
                        // draw the polygon
                        for (n=1; n<=count; n++)
                        {
                                dx = x+Math.cos(start+(step*n))*radius;
                                dy = y-Math.sin(start+(step*n))*radius;
                                lineTo(dx, dy);
                        }
                }
        }
        
        // ==============
        // mc.drawWedge() - by Ric Ewing ([email protected]) - version 1.3 - 6.12.2002
        //
        // x, y = center point of the wedge.
        // startAngle = starting angle in degrees.
        // arc = sweep of the wedge. Negative values draw clockwise.
        // radius = radius of wedge. If [optional] yRadius is defined, then radius is the x radius.
        // yRadius = [optional] y radius for wedge.
        // ==============
        // Thanks to: Robert Penner, Eric Mueller and Michael Hurwicz for their contributions.
        // ==============
        function drawWedge(x:Number, y:Number, startAngle:Number, arc:Number, radius:Number, yRadius:Number)
        {
                
                if (arguments.length<5)
                {
                        return;
                }
                // move to x,y position
                moveTo(x, y);
                // if yRadius is undefined, yRadius = radius
                if (yRadius == undefined)
                {
                        yRadius = radius;
                }
                // Init vars
                var segAngle:Number, theta:Number, angle:Number, angleMid:Number, segs:Number;
                var ax:Number, ay:Number, bx:Number, by:Number, cx:Number, cy:Number;
                // limit sweep to reasonable numbers
                if (Math.abs(arc)>360)
                {
                        arc = 360;
                }
                // Flash uses 8 segments per circle, to match that, we draw in a maximum
                // of 45 degree segments. First we calculate how many segments are needed
                // for our arc.
                segs = Math.ceil(Math.abs(arc)/45);
                // Now calculate the sweep of each segment.
                segAngle = arc/segs;
                // The math requires radians rather than degrees. To convert from degrees
                // use the formula (degrees/180)*Math.PI to get radians.
                theta = -(segAngle/180)*Math.PI;
                // convert angle startAngle to radians
                angle = -(startAngle/180)*Math.PI;
                // draw the curve in segments no larger than 45 degrees.
                if (segs>0)
                {
                        // draw a line from the center to the start of the curve
                        ax = x+Math.cos(startAngle/180*Math.PI)*radius;
                        ay = y+Math.sin(-startAngle/180*Math.PI)*yRadius;
                        lineTo(ax, ay);
                        // Loop for drawing curve segments
                        for (var i = 0; iMath.cos(angle)*radius;
                                by = y+Math.sin(angle)*yRadius;
                                cx = x+Math.cos(angleMid)*(radius/Math.cos(theta/2));
                                cy = y+Math.sin(angleMid)*(yRadius/Math.cos(theta/2));
                                curveTo(cx, cy, bx, by);
                        }
                        // close the wedge by drawing a line to the center
                        lineTo(x, y);
                }
        }
        
}
//end of Class

   在riacn看到一个转的国外人写的Graphic类，感觉不是很好。 首选它是从MovieClip类继承下来的，但它却
又用_root这个根时间轴来创建一个MovieClip的实例mc来mix-in到Graphic中。这样做是很不对的！并且一系列的
MovieClip的方法要通过mc来重写实现！我几个月前写的这个类虽然不是很充分，因为这是我组件库所有View的基类,
很多方法在考虑中,但绝对继承了MovieClip的所有方法和属性，而且跟MovieClip类一样是dynamic的.比起国外那
个，这个更有科学性.

相关软件：