Graphics  - AS3

Fyller i en rityta med en bitmappsbild. Bitmappen kan upprepas så att området fylls ut. Fyllningen gäller tills du anropar beginFill()-, beginBitmapFill()-, beginGradientFill()- eller beginShaderFill()-metoden. Anrop av metoden clear() tar bort fyllningen.

Programmet återger fyllningen när tre eller fler punkter har ritats, eller när metoden endFill() anropas.

Parametrar

     matrix = new flash.geom.Matrix(); 
     matrix.rotate(Math.PI / 4);
     

Relaterade API-element

package {
    import flash.display.Sprite;
    import flash.display.BitmapData;
    import flash.display.Loader;
    import flash.net.URLRequest;
    import flash.events.Event;
    import flash.events.IOErrorEvent;
    import flash.geom.Matrix;

    public class Graphics_beginBitmapFillExample extends Sprite {
 
        private var url:String = "image1.jpg";
        private var loader:Loader = new Loader();

        public function Graphics_beginBitmapFillExample() {

            var request:URLRequest = new URLRequest(url);
            
            loader.load(request);
            loader.contentLoaderInfo.addEventListener(Event.COMPLETE, drawImage);
            loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
        }

        private function drawImage(event:Event):void {

            var mySprite:Sprite = new Sprite();
            var myBitmap:BitmapData = new BitmapData(loader.width, loader.height, false);
  
            myBitmap.draw(loader, new Matrix());
            
            var matrix:Matrix = new Matrix();
            matrix.rotate(Math.PI/4);
            
            mySprite.graphics.beginBitmapFill(myBitmap, matrix, true);
            mySprite.graphics.drawRect(100, 50, 200, 90);
            mySprite.graphics.endFill();
            
            addChild(mySprite);
        }
 
         private function ioErrorHandler(event:IOErrorEvent):void {
            trace("Unable to load image: " + url);
        }
    }   
}

Anger en enkel enfärgsfyllning som efterföljande anrop till andra Graphics-metoder (till exempel lineTo() eller drawCircle()) använder vid ritning. Fyllningen gäller tills du anropar beginFill()-, beginBitmapFill()-, beginGradientFill()- eller beginShaderFill()-metoden. Anrop av metoden clear() tar bort fyllningen.

Programmet återger fyllningen när tre eller fler punkter har ritats, eller när metoden endFill() anropas.

Parametrar

Relaterade API-element

Anger en övertoningsfyllning som används för efterföljande anrop till andra Graphics-metoder (till exempel lineTo() eller drawCircle()) för objektet. Fyllningen gäller tills du anropar beginFill()-, beginBitmapFill()-, beginGradientFill()- eller beginShaderFill()-metoden. Anrop av metoden clear() tar bort fyllningen.

Programmet återger fyllningen när tre eller fler punkter har ritats, eller när metoden endFill() anropas.

Parametrar

	type:String — Ett värde från klassen GradientType som anger vilken övertoningstyp som ska användas. GradientType.LINEAR eller GradientType.RADIAL.
	colors:Array — En array med RGB-hexadecimala färgvärden som används i övertoningen: röd är till exempel 0xFF0000, blå är 0x0000FF o.s.v. Du kan ange upp till 15 färger. För varje färg måste du ange ett motsvarande värde i parametrarna alphas och ratios.
	alphas:Array — En array med alfavärden för motsvarande färger i färgarrayen. Giltiga värden är 0–1. Om värdet är mindre än 0 är standardvärdet 0. Om värdet är större än 1 är standardvärdet 1.
	ratios:Array — En array med färgdistributionsförhållanden. Giltiga värden är 0–255. Värdet definierar hur stor del av bredden (i procent) där färgen är 100 %. Värdet 0 står för positionen till vänster i övertoningsrutan och värdet 255 står för positionen till höger i övertoningsrutan. Obs!Detta värde står för positioner i övertoningsrutan och inte för den slutliga övertoningens koordinatmodell, som kan vara bredare eller smalare än övertoningsrutan. Ange ett värde för varje värde i parametern colors. För en linjär övertoning med två färger, blå och grön, visar följande exempel placeringen av färgerna i övertoningen baserat på olika värden i arrayen ratios: ratios Övertoning [0, 127] [0, 255] [127, 255] Värdena i arrayen måste öka sekventiellt, till exempel [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — En transformationsmatris som definierats av flash.geom.Matrix-klassen. I klassen flash.geom.Matrix finns en createGradientBox()-metod som gör att du enkelt kan ställa in matrisen för användning med metoden beginGradientFill()
	spreadMethod:String (default = "pad") — Ett värde från klassen SpreadMethod som anger vilken spridningsmetod som ska användas. SpreadMethod.PAD, SpreadMethod.REFLECT eller SpreadMethod.REPEAT. Ta till exempel en enkel linjär övertoning mellan två färger: import flash.geom.* import flash.display.* var fillType:String = GradientType.LINEAR; var colors:Array = [0xFF0000, 0x0000FF]; var alphas:Array = [1, 1]; var ratios:Array = [0x00, 0xFF]; var matr:Matrix = new Matrix(); matr.createGradientBox(20, 20, 0, 0, 0); var spreadMethod:String = SpreadMethod.PAD; this.graphics.beginGradientFill(fillType, colors, alphas, ratios, matr, spreadMethod); this.graphics.drawRect(0,0,100,100); I det här exemplet används SpreadMethod.PAD som spridningsmetod så att övertoningsfyllningen ser ut så här: Om du använder SpreadMethod.REFLECT som spridningsmetod skulle övertoningsfyllningen se ut så här: Om du använder SpreadMethod.REPEAT som spridningsmetod skulle övertoningsfyllningen se ut så här:
	interpolationMethod:String (default = "rgb") — Ett värde från InterpolationMethod-klassen som specificerar vilket värde som ska användas: InterpolationMethod.LINEAR_RGB eller InterpolationMethod.RGB Ta till exempel en enkel linjär övertoning mellan två färger (med parametern spreadMethod-parametern inställd på SpreadMethod.REFLECT). De olika interpoleringsmetoderna påverkar utseendet på följande sätt: InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Ett värde som styr fokalpunktens placering i övertoningen. Värdet 0 innebär att fokalpunkten är i mitten. Värdet 1 innebär att fokalpunkten är i kanten av övertoningscirkeln. Värdet -1 innebär att fokalpunkten är i övertoningscirkelns andra kant. Värden som är mindre än -1 eller större än 1 avrundas till -1 eller 1. I följande exempel visas en focalPointRatio som är inställd på 0,75:

Relaterade API-element

Anger en skuggfyllning som används för efterföljande anrop till andra Graphics-metoder (till exempel lineTo() eller drawCircle()) för objektet. Fyllningen gäller tills du anropar beginFill()-, beginBitmapFill()-, beginGradientFill()- eller beginShaderFill()-metoden. Anrop av metoden clear() tar bort fyllningen.

Programmet återger fyllningen när tre eller fler punkter har ritats, eller när metoden endFill() anropas.

Skuggningsfyllningar stöds inte vid GPU-återgivning (fyllda områden blir cyanfärgade).

Parametrar

     matrix = new flash.geom.Matrix(); 
     matrix.rotate(Math.PI / 4);
     

Relaterade API-element

Tar bort grafik som ritats i det här Graphics-objektet och återställer inställningar för fyllning och linjeformat.

Kopierar alla ritkommandon från det Graphics-objekt som är källan till det Graphics-objekt som anropas.

Parametrar

Ritar upp en kubisk bezier-kurva från den aktuella ritpositionen till den angiva ankarpunkten. Kubiska Bezier-kurvor består av två ankarpunkter och två kontrollpunkt. Kurvan interpolerar de två ankarpunkterna och kurvas mot två kontrollpunkter.

De fyra punkter som du använder för att rita upp en kubisk bezier-kurva med metoden cubicCurveTo() är följande:

• Ritpositionen för den första ankarpunkten.
• Parametrarna anchorX och anchorY anger den andra ankarpunkten.
• Parametrarna controlX1 och controlY1 anger den första kontrollpunkten.
• Parametrarna controlX2 och controlY2 anger den andra kontrollpunkten.

Om du anropar metoden cubicCurveTo() före moveTo(), kommer kurvan att utgå från positionen (0, 0).

Om metoden cubicCurveTo() lyckas, kommer den aktuella ritpositionen i Flash-miljön att sättas till (anchorX, anchorY). Om metoden cubicCurveTo() misslyckas förändras inte den aktuella ritpositionen.

Om filmklippet har innehåll som skapats med ritverktygen i Flash, kommer resultaten för anropen av cubicCurveTo()-metoden att ritas under innehållet.

Parametrar

package {
    import flash.display.Sprite;
    import flash.display.Shape;
    
    public class Graphics_cubicCurveToExample extends Sprite
    {
        public function Graphics_cubicCurveToExample():void
        {
            var rounderObject:Shape = new Shape();

            rounderObject.graphics.beginFill(0x0000FF);
            rounderObject.graphics.moveTo(250, 0);
            rounderObject.graphics.cubicCurveTo(275, 0, 300, 25, 300, 50);
            rounderObject.graphics.cubicCurveTo(300, 75, 275, 100, 250, 100);
            rounderObject.graphics.cubicCurveTo(225, 100, 200, 75, 200, 50);
            rounderObject.graphics.cubicCurveTo(200, 25, 225, 0, 250, 0);
            rounderObject.graphics.endFill();
            
            this.addChild(rounderObject);
        }
    }
}

Ritar en kvadratisk bezier-kurva med det nuvarande linjeformatet från den nuvarande ritpositionen till (anchorX, anchorY) med den kontrollpunkt som anges av(controlX, controlY). Den nuvarande ritpositionen ställs sedan in på (anchorX, anchorY). Om filmklippet du ritar i har innehåll som skapats med ritverktygen i Flash, ritas anrop till curveTo()-metoden under detta innehåll. Om du anropar curveTo()-metoden före anrop till moveTo()-metoden blir den aktuella standardritpositionen (0, 0). Om någon av parametrarna saknas fungerar inte metoden och den nuvarande ritpositionen ändras inte.

Den kurva som ritas är en kvadratisk Bezierkurva. Kvadratiska Bezier-kurvor består av två ankarpunkter och en kontrollpunkt. Kurvan interpolerar de två ankarpunkterna och kurvas mot kontrollpunkten.

Parametrar

package {
    import flash.display.Sprite;
    import flash.display.Shape;
    
    public class Graphics_curveToExample1 extends Sprite
    {
        public function Graphics_curveToExample1():void
        {
            var roundObject:Shape = new Shape();

            roundObject.graphics.beginFill(0x00FF00);
            roundObject.graphics.moveTo(250, 0);
            roundObject.graphics.curveTo(300, 0, 300, 50);
            roundObject.graphics.curveTo(300, 100, 250, 100);
            roundObject.graphics.curveTo(200, 100, 200, 50);
            roundObject.graphics.curveTo(200, 0, 250, 0);
            roundObject.graphics.endFill();
            
            this.addChild(roundObject);
        }
    }
}

package {
    import flash.display.Sprite;
    import flash.display.Shape;

    public class Graphics_curveToExample2 extends Sprite
    {
        public function Graphics_curveToExample2() {
            var newMoon:Shape = new Shape();
            
            newMoon.graphics.lineStyle(1, 0);
            newMoon.graphics.beginFill(0xFFFFFF);
            newMoon.graphics.moveTo(100, 100); 
            newMoon.graphics.curveTo(30, 150, 100, 200);    
            newMoon.graphics.curveTo(50, 150, 100, 100);
            graphics.endFill();
            
            this.addChild(newMoon);
        }
    }
}

Ritar en cirkel. Ställ in linjens stil eller fyllnad (eller båda) innan du anropar drawCircle()-metoden, genom att anropa linestyle()-, lineGradientStyle()-, beginFill()-, beginGradientFill()- eller beginBitmapFill()-metoden.

Parametrar

Relaterade API-element

Ritar en ellips. Ställ in linjens stil eller fyllnad (eller båda) innan du anropar drawEllipse()-metoden, genom att anropa linestyle()-, lineGradientStyle()-, beginFill()-, beginGradientFill()- eller beginBitmapFill()-metoden.

Parametrar

Relaterade API-element

package {
    import flash.display.Sprite;
    import flash.display.Shape;

    public class Graphics_drawEllipseExample extends Sprite
    {
        public static const SMALL:uint = 0;
        public static const MEDIUM:uint = 1;
        public static const LARGE:uint = 2;

        public function Graphics_drawEllipseExample()
        {
            drawEgg(SMALL, 0, 100);
            drawEgg(MEDIUM, 100, 60);
            drawEgg(LARGE, 250, 35);    
        }

        public function drawEgg(eggSize:uint, x:Number, y:Number):void  {
            
            var myEgg:Shape = new Shape();
            
            myEgg.graphics.beginFill(0xFFFFFF);
            myEgg.graphics.lineStyle(1);

            switch(eggSize) {
                case SMALL:
                    myEgg.graphics.drawEllipse(x, y, 60, 70);
                    break;
                case MEDIUM:
                    myEgg.graphics.drawEllipse(x, y, 120, 150);    
                    break;
                case LARGE:
                    myEgg.graphics.drawEllipse(x, y, 150, 200);
                    break;
                default:
                    trace ("Wrong size! There is no egg.");
                break;            
            }
            
            myEgg.graphics.endFill();
    
            this.addChild(myEgg);
        }
    }
}

Skickar en serie IGraphicsData-instanser för teckning. Den här metoden godkänner en Vector som innehåller objekt, inklusive banor, fyllningar och linjer, som implementerar IGraphicsData-gränssnittet. En Vector i IGraphicsData-instanser kan referera till en del av en form, eller en komplex, fullständigt definierad uppsättning data för återgivning av en hel form.

Grafikbanor kan innehålla andra grafikbanor. Om graphicsData-Vector innehåller en bana återges den och alla dess underordnade banor under den här åtgärden.

Parametrar

Relaterade API-element

package
{
    import flash.display.*;
    import flash.geom.*;

    public class DrawGraphicsDataExample extends Sprite
    {
        public function DrawGraphicsDataExample()
        {
            // establish the fill properties
            var myFill:GraphicsGradientFill = new GraphicsGradientFill();
            myFill.colors = [0xEEFFEE, 0x0000FF];
            myFill.matrix = new Matrix();
            myFill.matrix.createGradientBox(100, 100, 0);
            
            // establish the stroke properties
            var myStroke:GraphicsStroke = new GraphicsStroke(2);
            myStroke.fill = new GraphicsSolidFill(0x000000);
            
            // establish the path properties
            var pathCommands = new Vector.<int>(5, true);
            pathCommands[0] = GraphicsPathCommand.MOVE_TO;
            pathCommands[1] = GraphicsPathCommand.LINE_TO;
            pathCommands[2] = GraphicsPathCommand.LINE_TO;
            pathCommands[3] = GraphicsPathCommand.LINE_TO;
            pathCommands[4] = GraphicsPathCommand.LINE_TO;
            
            var pathCoordinates:Vector.<Number> = new Vector.<Number>(10, true);
            pathCoordinates.push(10,10, 10,100, 100,100, 100,10, 10,10);
            
            var myPath:GraphicsPath = new GraphicsPath(pathCommands, pathCoordinates);
            
            // populate the IGraphicsData Vector array
            var myDrawing:Vector.<IGraphicsData> = new Vector.<IGraphicsData>(3, true);
            myDrawing[0] = myFill;
            myDrawing[1] = myStroke;
            myDrawing[2] = myPath;
            
            // render the drawing
            graphics.drawGraphicsData(myDrawing);
        }
    }
}

Skickar en serie ritkommandon. Metoden drawPath() accepterar en vektor med enskilda moveTo()-, lineTo()- och curveTo()-ritkommandon och kombinerar dem till ett enda anrop. Parametrarna för metoden drawPath() kombinerar ritkommandon med x- och y-koordinatvärdepar och en ritriktning. Ritkommandona är heltal och utgörs av konstanter som definieras i klassen GraphicsPathCommand. x- och y-koordinatvärdeparen är siffror i en array där varje par definierar en koordinatplats. Ritriktningen är ett värde från klassen GraphicsPathWinding.

Teckningar återges ofta snabbare med drawPath() än med en serie enstaka lineTo()- och curveTo()-metodanrop.

drawPath()-metoden använder en flytande beräkning så att rotation och skalning av former blir mer exakt och ger bättre resultat. Det innebär dock att kurvor som skickas med drawPath()-metoden kan ha små justeringsfel på subpixelnivå när de används i kombination med metoderna lineTo() och curveTo().

Metoden drawPath() har också något annorlunda regler för att fylla i och rita linjer. De är:

• När en fyllning appliceras för att rendera en sökväg:
  • En underordnad sökväg på mindre än 3 punkter renderas inte. (Men observera att linjerenderingen sker i alla fall, i enlighet med reglerna för linjer nedan.)
  • En underordnad sökväg som inte är stängd (slutpunkten är inte lika med startpunkten) stängs implicit.
• När en linje används för att rendera en sökväg:
  • De underordnade sökvägarna kan bestå av valfritt antal punkter.
  • Den underordnade sökvägen stängs aldrig implicit.

Parametrar

Relaterade API-element

package
{
    import flash.display.*;
        
    public class DrawPathExample extends Sprite
    {
        public function DrawPathExample()
        {
            var star_commands:Vector.<int> = new Vector.<int>(5, true);
            
            star_commands[0] = GraphicsPathCommand.MOVE_TO;
            star_commands[1] = GraphicsPathCommand.LINE_TO;
            star_commands[2] = GraphicsPathCommand.LINE_TO;
            star_commands[3] = GraphicsPathCommand.LINE_TO;
            star_commands[4] = GraphicsPathCommand.LINE_TO;
            
            var star_coord:Vector.<Number> = new Vector.<Number>(10, true);
            star_coord[0] = 66; //x
            star_coord[1] = 10; //y 
            star_coord[2] = 23; 
            star_coord[3] = 127; 
            star_coord[4] = 122; 
            star_coord[5] = 50; 
            star_coord[6] = 10; 
            star_coord[7] = 49; 
            star_coord[8] = 109; 
            star_coord[9] = 127;
            
            graphics.beginFill(0x003366);
            graphics.drawPath(star_commands, star_coord);
        }
    }
}

 graphics.drawPath(star_commands, star_coord, GraphicsPathWinding.NON_ZERO);
 

Ritar en rektangel. Ställ in linjens stil eller fyllnad (eller båda) innan du anropar drawRect()-metoden, genom att anropa linestyle()-, lineGradientStyle()-, beginFill()-, beginGradientFill()- eller beginBitmapFill()-metoden.

Parametrar

Relaterade API-element

var movieClip:MovieClip = new MovieClip();
movieClip.graphics.beginFill(0xFF0000);
movieClip.graphics.drawRect(0, 0, 100, 80);
movieClip.graphics.endFill();
movieClip.x = 10;
movieClip.y = 10;
addChild(movieClip);

Ritar en rundad rektangel. Ställ in linjens stil eller fyllnad (eller båda) innan du anropar drawRoundRect()-metoden, genom att anropa linestyle()-, lineGradientStyle()-, beginFill()-, beginGradientFill()- eller beginBitmapFill()-metoden.

Parametrar

Relaterade API-element

Återger en uppsättning trianglar, oftast för att förvränga bitmappar så att de ser tredimensionella ut. drawTriangles()-metoden mappar antingen den aktuella fyllningen eller en bitmappsfyllning till triangelsidorna med hjälp av en uppsättning (u-, v-) koordinater.

Alla fyllningstyper kan användas, men om fyllningen har en omformningsmatris ignoreras den.

En uvtData-parameter förbättrar texturmappning när en bitmappsfyllning används.

Parametrar

Relaterade API-element

Tillämpar en fyllning på de linjer och kurvor som lagts till sedan det senaste anropet till beginFill()-, beginGradientFill()- eller beginBitmapFill()-metoden. Flash använder den fyllning som specificerades vid det föregående anropet till beginFill()-, beginGradientFill()- eller beginBitmapFill()-metoden. Om den nuvarande ritpositionen inte är lika med föregående position som angetts av en moveTo()-metod och en fyllning är definierad, stängs banan med en linje och fylls i.

Relaterade API-element

Anger en bitmapp som ska användas för linjen när linjer ritas.

Linjeformatet för bitmappen används för efterföljande anrop till Graphics-metoder som till exempel lineTo()-metoden eller drawCircle()-metoden. Linjeformatet gäller tills du anropar lineStyle()- eller lineGradientStyle()-metoderna eller lineBitmapStyle()-metoden igen med olika parametrar.

Du kan anropa metoden lineBitmapStyle() medan en bana ritas för att ange olika format för olika linjesegment inom en bana.

Anropa lineStyle()-metoden innan du anropar lineBitmapStyle()-metoden för att aktivera en linje, annars blir linjeformatets värde undefined.

Anrop till clear()-metoden återställer linjeformatet till undefined.

Parametrar

Relaterade API-element

Anger en övertoning som ska användas för linjen när linjer ritas.

Övertoningen för linjeformatet används för efterföljande anrop till Graphics-metoder, t.ex. lineTo()-metoder eller drawCircle()-metoden. Linjeformatet gäller tills du anropar lineStyle()- eller lineBitmappStyle()-metoderna eller lineGradientStyle()-metoden igen med olika parametrar.

Du kan anropa metoden lineGradientStyle() medan en bana ritas för att ange olika format för olika linjesegment inom en bana.

Anropa lineStyle()-metoden innan du anropar lineGradientStyle()-metoden för att aktivera en linje, annars blir linjeformatets värde undefined.

Anrop till clear()-metoden återställer linjeformatet till undefined.

Parametrar

	type:String — Ett värde från klassen GradientType som anger vilken övertoningstyp som ska användas. Antingen GradientType.LINEAR eller GradientType.RADIAL.
	colors:Array — En array med RGB-hexfärgvärden som ska användas i övertoningen (röd är till exempel 0xFF0000 och blå är 0x0000FF och så vidare).
	alphas:Array — En array med alfavärden för motsvarande färger i färgarrayen. Giltiga värden är 0–1. Om värdet är mindre än 0 är standardvärdet 0. Om värdet är större än 1 är standardvärdet 1.
	ratios:Array — En array med färgdistributionsförhållanden. Giltiga värden är 0 till 255. Värdet definierar hur stor del av bredden (i procent) där färgen är 100 %. Värdet 0 står för positionen till vänster i övertoningsrutan och värdet 255 står för positionen till höger i övertoningsrutan. Detta värde står för positioner i övertoningsrutan och inte för den slutliga övertoningens koordinatmodell, som kan vara bredare eller smalare än övertoningsrutan. Ange ett värde för varje värde i parametern colors. För en linjär övertoning med två färger, blå och grön, visar följande figur placeringen av färgerna i övertoningen baserat på olika värden i arrayen ratios: ratios Övertoning [0, 127] [0, 255] [127, 255] Värdena i arrayen måste öka sekventiellt, till exempel [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — En transformationsmatris som definierats av flash.geom.Matrix-klassen. I klassen flash.geom.Matrix finns en createGradientBox()-metod som gör att du enkelt kan ställa in matrisen för användning med metoden lineGradientStyle()
	spreadMethod:String (default = "pad") — Ett värde från klassen SpreadMethod som anger vilken spridningsmetod som ska användas: SpreadMethod.PAD SpreadMethod.REFLECT SpreadMethod.REPEAT
	interpolationMethod:String (default = "rgb") — Ett värde från klassen InterpolationMethod som specificerar vilket värde som ska användas. Ta till exempel en enkel linjär övertoning mellan två färger (med parametern spreadMethod-parametern inställd på SpreadMethod.REFLECT). De olika interpoleringsmetoderna påverkar utseendet på följande sätt: InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Ett värde som styr fokalpunktens placering i övertoningen. Värdet 0 innebär att fokalpunkten är i mitten. Värdet 1 innebär att fokalpunkten är i kanten av övertoningscirkeln. Värdet -1 innebär att fokalpunkten är i övertoningscirkelns andra kant. Värden som är mindre än -1 eller större än 1 avrundas till -1 eller 1. I följande bild visas en övertoning med focalPointRatio-värdet -0,75:

Relaterade API-element

package {
    import flash.display.Sprite;
    import flash.display.Shape;
    import flash.geom.Matrix; 
    import flash.display.GradientType;
    
    public class Graphics_lineGradientStyleExample extends Sprite
    {
        public function Graphics_lineGradientStyleExample()
        {
            var myShape:Shape = new Shape();
            var gradientBoxMatrix:Matrix = new Matrix();
  
            gradientBoxMatrix.createGradientBox(200, 40, 0, 0, 0);  
            
            myShape.graphics.lineStyle(5);
  
            myShape.graphics.lineGradientStyle(GradientType.LINEAR, [0xFF0000,
            0x00FF00, 0x0000FF], [1, 1, 1], [0, 128, 255], gradientBoxMatrix);
            
            myShape.graphics.drawRect(0, 0, 200, 40);
            myShape.graphics.drawCircle(100, 120, 50);  
             
            this.addChild(myShape);
    
        }
    }
}

Anger en skuggning som ska användas för linjen när linjer ritas.

Skuggningslinjeformatet används för efterföljande anrop till Graphics-metoder som till exempel lineTo()-metoden eller drawCircle()-metoden. Linjeformatet gäller tills du anropar lineStyle()- eller lineGradientStyle()-metoderna eller lineBitmapStyle()-metoden igen med olika parametrar.

Du kan anropa metoden lineShaderStyle() under tiden som du ritar en bana för att ange olika format för olika linjesegment inom en bana.

Anropa lineStyle()-metoden innan du anropar lineShaderStyle()-metoden för att aktivera en linje, annars blir linjeformatets värde undefined.

Anrop till clear()-metoden återställer linjeformatet till undefined.

Parametrar

Relaterade API-element

Anger ett linjeformat som används för efterföljande anrop till Graphics-metoder, t.ex. lineTo()-metoden eller drawCircle()-metoden. Linjeformatet gäller tills du anropar lineGradientStyle()-metoden, lineBitmapStyle()-metoden eller lineStyle()-metoden med olika parametrar.

Du kan anropa metoden lineStyle() medan en bana ritas för att ange olika format för olika linjesegment inom banan.

Obs: Anrop till clear()-metoden återställer linjeformatet till undefined.

Obs! Flash Lite 4 har bara stöd för de första tre parametrarna (thickness, color och alpha).

Parametrar

Relaterade API-element

Ritar en linje med det nuvarande linjeformatet från den nuvarande ritpositionen till (x, y). Den nuvarande ritpositionen ställs sedan in på (x, y). Om det visningsobjekt du ritar i har innehåll som skapats med ritverktygen i Flash, ritas anrop till metoden lineTo() under innehållet. Om du anropar lineTo() före anrop till moveTo()-metoden blir den aktuella standardritpositionen (0, 0). Om någon av parametrarna saknas fungerar inte metoden och den nuvarande ritpositionen ändras inte.

Parametrar

package {
    import flash.display.Sprite;
    import flash.display.LineScaleMode;
    import flash.display.CapsStyle;
    import flash.display.JointStyle;
    import flash.display.Shape;


    public class Graphics_lineToExample extends Sprite {

        public function Graphics_lineToExample() {

            var trapezoid:Shape = new Shape();    

            trapezoid.graphics.lineStyle(10, 0xFFD700, 1, false, LineScaleMode.VERTICAL,
                               CapsStyle.NONE, JointStyle.MITER, 10);

            trapezoid.graphics.moveTo(100, 100);
 
            trapezoid.graphics.lineTo(120, 50);
            trapezoid.graphics.lineTo(200, 50);
            trapezoid.graphics.lineTo(220, 100);
            trapezoid.graphics.lineTo(100, 100); 

            this.addChild(trapezoid);
        }
    }
}

Flyttar ritpositionen till (x, y). Om någon av parametrarna saknas fungerar inte metoden och den nuvarande ritpositionen ändras inte.

Parametrar

package {
    import flash.display.Sprite;
    import flash.display.CapsStyle;
    import flash.display.LineScaleMode;

    public class Graphics_moveToExample extends Sprite
    {
        public function Graphics_moveToExample() {
            
            graphics.lineStyle(3, 0x990000, 0.25, false, 
                            LineScaleMode.NONE, CapsStyle.SQUARE);

            graphics.moveTo(10, 20);
            graphics.lineTo(20, 20);
            graphics.moveTo(30, 20);
            graphics.lineTo(50, 20);
            graphics.moveTo(60, 20);
            graphics.lineTo(80, 20);
            graphics.moveTo(90, 20);
            graphics.lineTo(110, 20);            
            graphics.moveTo(120, 20);
            graphics.lineTo(130, 20);           
        }
    }
}

Frågar ett Sprite- eller Shape-objekt (och eventuellt dess underordnade objekt) efter deras vektorgrafikinnehåll. Resultatet är en vektor med IGraphicsData-objekt. Omformningar används på visningsobjektet innan frågan skickas, så de returnerade sökvägarna finns alla i samma koordinatsystem. Koordinaterna i resultatet anges i förhållande till scenen, inte det visningsobjekt som samplas.

Resultatet inkluderar följande typer av objekt, med angivna begränsningar:

• GraphicsSolidFill
• GraphicsGradientFill
  • Alla egenskaper för övertoningsfyllningen returneras av readGraphicsData().
  • Den returnerade matrisen är lik, men inte exakt likadan som, indatamatrisen.
• GraphicsEndFill
• GraphicsBitmapFill
  • Den returnerade matrisen är lik, men inte exakt likadan som, indatamatrisen.
  • repeat är alltid true.
  • smooth är alltid false.
• GraphicsStroke
  • thickness stöds.
  • fill har stöd för GraphicsSolidFill, GraphicsGradientFill och GraphicsBitmapFill enligt tidigare beskrivning.
  • Alla andra egenskaper har standardvärden.
• GraphicsPath
  • De enda kommandon som stöds är MOVE_TO, CURVE_TO och LINE_TO.

Följande visuella element och omformningar kan inte representeras och ingår inte i resultatet:

• Masker
• Text, med ett undantag: Statisk text som definierats med kantutjämningstypen "Kantutjämna för animering" återges som vektorformer och ingår därför i resultatet.
• Skuggfyllningar
• Blandningslägen
• Skalning med 9 segment
• Trianglar (som skapats med metoden drawTriangles())
• Ogenomskinlig bakgrund
• scrollrect-inställningar
• 2.5D-omformningar
• Ej synliga objekt (objekt vars visible-egenskap är false)

Parametrar

Relaterade API-element

package
{
    import flash.display.GraphicsPathCommand;
    import flash.display.IGraphicsData;
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.events.MouseEvent;
    
    public class ReadGraphicsDataExample extends Sprite
    {
        private var original:Shape;
        private var copy:Shape;
        
        public function ReadGraphicsDataExample()
        {
            original = new Shape();
            original.x = 50;
            original.y = 100;
            addChild(original);
            
            drawSquare();
            
            copy = new Shape();
            copy.x = 250;
            copy.y = 100;
            addChild(copy);
            
            stage.addEventListener(MouseEvent.CLICK, drawCopyOnClick);
        }
        
        private function drawCopyOnClick(event:MouseEvent):void
        {
            // reset
            copy.graphics.clear();
            
            // Sample the vector data. Move the original to 0,0
            // before sampling so that the coordinates match the 
            // relative coordinates of the original.
            var xPos:Number = original.x;
            var yPos:Number = original.y;
            original.x = 0;
            original.y = 0;
            var result:Vector.<IGraphicsData> = original.graphics.readGraphicsData(false);
            original.x = xPos;
            original.y = yPos;
            
            // re-draw
            copy.graphics.drawGraphicsData(result);
        }
        
        private function drawSquare():void
        {
            var squareCommands:Vector.<int> = new Vector.<int>(5, true);
            
            squareCommands[0] = GraphicsPathCommand.MOVE_TO;
            squareCommands[1] = GraphicsPathCommand.LINE_TO;
            squareCommands[2] = GraphicsPathCommand.LINE_TO;
            squareCommands[3] = GraphicsPathCommand.LINE_TO;
            
            var squareCoordinates:Vector.<Number> = new Vector.<Number>(8, true);
            squareCoordinates[0] = 0;
            squareCoordinates[1] = 0; 
            squareCoordinates[2] = 50; 
            squareCoordinates[3] = 0; 
            squareCoordinates[4] = 50; 
            squareCoordinates[5] = 50; 
            squareCoordinates[6] = 0; 
            squareCoordinates[7] = 50; 
            
            original.graphics.beginFill(0x003366);
            original.graphics.drawPath(squareCommands, squareCoordinates);
        }
    }
}

1. Deklarera en size-egenskap för senare användning vid fastställandet av storleken på varje form.
2. Deklarera egenskaper som sätter bakgrundsfärgen till orange, ramfärgen till mörkgrått, ramstorleken till 0 pixlar, hörnradie till 9 pixlar och utrymmet mellan scenkanten och de övriga objekten till 5 pixlar.
3. Använd de egenskaper som deklarerades i de föregående stegen tillsammans med de inbyggda metoderna hos Graphics-klassen för att rita cirkeln, den rundade rektangeln och fyrkanten i koordinaterna x = 0, y = 0.
4. Rita om var och en av formerna längs scenens överkant. Börja i x = 5, y = 5 med ett utrymme på 5 pixlar mellan formerna.

package {
    import flash.display.DisplayObject;
    import flash.display.Graphics;
    import flash.display.Shape;
    import flash.display.Sprite;

    public class GraphicsExample extends Sprite {
        private var size:uint         = 80;
        private var bgColor:uint      = 0xFFCC00;
        private var borderColor:uint  = 0x666666;
        private var borderSize:uint   = 0;
        private var cornerRadius:uint = 9;
        private var gutter:uint       = 5;

        public function GraphicsExample() {
            doDrawCircle();
            doDrawRoundRect();
            doDrawRect();
            refreshLayout();
        }

        private function refreshLayout():void {
            var ln:uint = numChildren;
            var child:DisplayObject;
            var lastChild:DisplayObject = getChildAt(0);
            lastChild.x = gutter;
            lastChild.y = gutter;
            for (var i:uint = 1; i < ln; i++) {
                child = getChildAt(i);
                child.x = gutter + lastChild.x + lastChild.width;
                child.y = gutter;
                lastChild = child;
            }
        }

        private function doDrawCircle():void {
            var child:Shape = new Shape();
            var halfSize:uint = Math.round(size / 2);
            child.graphics.beginFill(bgColor);
            child.graphics.lineStyle(borderSize, borderColor);
            child.graphics.drawCircle(halfSize, halfSize, halfSize);
            child.graphics.endFill();
            addChild(child);
        }

        private function doDrawRoundRect():void {
            var child:Shape = new Shape();
            child.graphics.beginFill(bgColor);
            child.graphics.lineStyle(borderSize, borderColor);
            child.graphics.drawRoundRect(0, 0, size, size, cornerRadius);
            child.graphics.endFill();
            addChild(child);
        }

        private function doDrawRect():void {
            var child:Shape = new Shape();
            child.graphics.beginFill(bgColor);
            child.graphics.lineStyle(borderSize, borderColor);
            child.graphics.drawRect(0, 0, size, size);
            child.graphics.endFill();
            addChild(child);
        }
    }
}