Graphics  - AS3

Riempie un'area di disegno con un'immagine bitmap. Per riempire l'area, la bitmap può essere ripetuta o affiancata a mosaico. Il riempimento rimane attivo finché non chiamate il metodo beginFill(), beginBitmapFill(), beginGradientFill() o beginShaderFill(). Una chiamata al metodo clear() cancella il riempimento.

L'applicazione esegue il rendering del riempimento quando vengono disegnati tre o più punti oppure quando viene chiamato il metodo endFill().

Parametri

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

Elementi API correlati

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);
        }
    }   
}

Specifica un riempimento semplice a colore singolo utilizzato per le chiamate successive ad altri metodi Graphics (ad esempio, lineTo() o drawCircle()) durante il disegno. Il riempimento rimane attivo finché non chiamate il metodo beginFill(), beginBitmapFill(), beginGradientFill() o beginShaderFill(). Una chiamata al metodo clear() cancella il riempimento.

L'applicazione esegue il rendering del riempimento quando vengono disegnati tre o più punti oppure quando viene chiamato il metodo endFill().

Parametri

Elementi API correlati

Specifica un riempimento con gradiente utilizzato per le chiamate successive ad altri metodi Graphics (ad esempio lineTo() or drawCircle()) per l'oggetto. Il riempimento rimane attivo finché non chiamate il metodo beginFill(), beginBitmapFill(), beginGradientFill() o beginShaderFill(). Una chiamata al metodo clear() cancella il riempimento.

L'applicazione esegue il rendering del riempimento quando vengono disegnati tre o più punti oppure quando viene chiamato il metodo endFill().

Parametri

	type:String — Un valore della classe GradientType che specifica il tipo di gradiente da utilizzare: GradientType.LINEAR o GradientType.RADIAL.
	colors:Array — Un array di valori di colore RGB esadecimali da utilizzare nel gradiente (ad esempio, il rosso è 0xFF0000, il blu 0x0000FF e così via). È possibile specificare fino a 15 colori. Per ciascun colore, accertarsi di specificare un valore corrispondente nei parametri alphas e ratios.
	alphas:Array — Un array di valori alfa per i colori corrispondenti nell'array dei colori; i valori validi sono compresi tra 0 e 1. Se il valore è minore di 0, il valore predefinito è 0. Se è maggiore di 1, il valore predefinito è 1.
	ratios:Array — Un array di rapporti di distribuzione del colore; i valori validi sono compresi tra 0 e 255. Questo valore definisce la percentuale della larghezza in corrispondenza della quale il campionamento del colore viene eseguito al 100%. Il valore 0 rappresenta la posizione di sinistra nel riquadro del gradiente, mentre 255 rappresenta la posizione di destra. Nota: questo valore rappresenta le posizioni all'interno del riquadro del gradiente, non nello spazio di coordinate del gradiente finale, che può essere più largo o più stretto del riquadro del gradiente. Specificate un valore per ciascun valore nel parametro colors. Ad esempio, per un gradiente lineare che include due colori, blu e verde, nell'esempio seguente è illustrata la posizione dei colori nel gradiente in base ai diversi valori dell'array ratios: ratios Gradiente [0, 127] [0, 255] [127, 255] I valori nell'array devono aumentare in maniera sequenziale; ad esempio, [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — Una matrice di trasformazione definita dalla classe flash.geom.Matrix. La classe flash.geom.Matrix include un metodo createGradientBox(), che consente di impostare con facilità la matrice affinché possa essere utilizzata con il metodo beginGradientFill().
	spreadMethod:String (default = "pad") — Un valore della classe SpreadMethod che specifica il metodo spread da utilizzare: SpreadMethod.PAD, SpreadMethod.REFLECT o SpreadMethod.REPEAT. Si consideri, ad esempio, un semplice gradiente lineare tra due colori: 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); Nell'esempio viene utilizzato SpreadMethod.PAD per il metodo spread e il riempimento del gradiente ha il seguente aspetto: Se utilizzate SpreadMethod.REFLECT per il metodo spread, il riempimento del gradiente ha il seguente aspetto: Se si utilizza SpreadMethod.REPEAT per il metodo spread, il riempimento del gradiente ha il seguente aspetto:
	interpolationMethod:String (default = "rgb") — Un valore della classe InterpolationMethod che specifica il valore da utilizzare: InterpolationMethod.LINEAR_RGB o InterpolationMethod.RGB Considerate, ad esempio, un gradiente lineare semplice tra due colori (con il parametro spreadMethod impostato su SpreadMethod.REFLECT). I diversi metodi di interpolazione influiscono sull'aspetto come illustrato di seguito: InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Un numero che controlla la posizione del punto focale del gradiente. 0 significa che il punto focale si trova al centro. 1 significa che il punto focale si trova su un bordo del cerchio del gradiente. -1 significa che il punto focale si trova sull'altro bordo del cerchio del gradiente. Un valore inferiore a -1 o superiore a 1 viene arrotondato rispettivamente a -1 o 1. Ad esempio, l'esempio seguente mostra focalPointRatio impostato su 0,75:

Altri esempi

Elementi API correlati

Specifica un riempimento con shader utilizzato per le chiamate successive ad altri metodi Graphics (ad esempio lineTo() or drawCircle()) per l'oggetto. Il riempimento rimane attivo finché non chiamate il metodo beginFill(), beginBitmapFill(), beginGradientFill() o beginShaderFill(). Una chiamata al metodo clear() cancella il riempimento.

L'applicazione esegue il rendering del riempimento quando vengono disegnati tre o più punti oppure quando viene chiamato il metodo endFill().

I riempimenti shader non sono supportati nel rendering GPU; le aree piene saranno colorate in ciano.

Parametri

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

Altri esempi

Elementi API correlati

Cancella gli elementi grafici disegnati in questo oggetto Graphics e ripristina le impostazioni dello stile di linea e di riempimento.

Copia tutti i comandi di disegno dall'oggetto Graphics di origine nell'oggetto Graphics chiamante.

Parametri

Disegna una curva di Bézier cubica dalla posizione di disegno corrente al punto di ancoraggio specificato. Le curve di Bézier cubiche sono composte da due punti di ancoraggio e da due punti di controllo. La curva interpola i due punti di ancoraggio e si incurva verso i due punti di controllo.

I quattro punti che utilizzate per disegnare una curva di Bézier cubica con il metodo cubicCurveTo() sono i seguenti:

• La posizione di disegno corrente è il primo punto di ancoraggio.
• I parametri anchorX e anchorY specificano il secondo punto di ancoraggio.
• I parametri controlX1 e controlY1 specificano il primo punto di controllo.
• I parametri controlX2 e controlY2 specificano il secondo punto di controllo.

Se si chiama il metodo cubicCurveTo() prima di chiamare moveTo(), la curva inizia alla posizione (0, 0).

Se il metodo cubicCurveTo() ha esito positivo, il runtime Flash imposta la posizione di disegno corrente su (anchorX, anchorY). Se il metodo cubicCurveTo() fallisce, la posizione di disegno corrente rimane invariata.

Se il clip filmato include contenuto creato con gli strumenti di disegno di Flash, i risultati delle chiamate del metodo cubicCurveTo() vengono disegnati sotto tale contenuto.

Parametri

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);
        }
    }
}

Disegna una curva di Bézier quadratica con lo stile di linea corrente dalla posizione di disegno corrente a (anchorX, anchorY) mediante il punto di controllo specificato da (controlX, controlY). La posizione di disegno corrente viene quindi impostata su (anchorX, anchorY). Se il clip filmato in cui si sta disegnando include contenuto creato con gli strumenti di disegno di Flash, le chiamate a curveTo() vengono disegnate sotto tale contenuto. Se chiamate il metodo curveTo() prima delle chiamate al metodo moveTo(), la posizione predefinita del disegno corrente viene impostata su (0, 0). Se mancano uno o più parametri, il metodo ha esito negativo e la posizione di disegno corrente non cambia.

La curva disegnata è una curva Bézier quadratica. Le curve Bézier quadratiche sono composte da due punti di ancoraggio e da un punto di controllo. La curva interpola i due punti di ancoraggio e si incurva verso il punto di controllo.

Parametri

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);
        }
    }
}

Disegna un cerchio. Impostate lo stile della linea, il riempimento o entrambi prima di chiamare il metodo drawCircle(), mediante una chiamata al metodo linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() o beginBitmapFill().

Parametri

Elementi API correlati

Disegna un'ellisse. Impostate lo stile della linea, il riempimento o entrambi prima di chiamare il metodo drawEllipse(), mediante una chiamata al metodo linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() o beginBitmapFill().

Parametri

Elementi API correlati

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);
        }
    }
}

Invia una serie di istanze IGraphicsData per disegnare. Questo metodo accetta un Vector contenente oggetti, tra cui percorsi, riempimenti e tratti, che implementano l'interfaccia IGraphicsData. Un Vector di istanze IGraphicsData può fare riferimento a una parte di una forma o a un set complesso di dati completamente definiti per il rendering di una forma completa.

I percorsi grafici possono contenere altri percorsi grafici. Se l'oggetto Vector graphicsData include un percorso, durante questa operazione viene eseguito il rendering di quel percorso e tutti i relativi percorsi secondari.

Parametri

Altri esempi

Elementi API correlati

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);
        }
    }
}

Invia una serie di comandi per disegnare. Il metodo drawPath() accetta un oggetto Vector di singoli comandi di disegno moveTo(), lineTo() e curveTo() e li combina insieme in un’unica chiamata. I parametri del metodo drawPath() combinano i comandi di disegno con le coppie di valori delle coordinate x e y e una direzione di disegno. I comandi di disegno sono numeri interi, rappresentati come costanti definite nella classe GraphicsPathCommand. Le coppie di valori delle coordinate x e y sono numeri in un array in cui ogni coppia definisce una posizione di coordinate. La direzione di disegno è un valore della classe GraphicsPathWinding.

In genere, il rendering dei disegni viene eseguito più velocemente con drawPath() che con una serie di singole chiamate ai metodi lineTo() e curveTo().

Il metodo drawPath() utilizza un calcolo a virgola mobile per fare in modo che la rotazione e la modifica in scala siano più precise e forniscano risultati migliori. Le curve inviate utilizzando il metodo drawPath() possono, tuttavia, presentare piccoli errori di allineamento dei sottopixel se utilizzate insieme ai metodi lineTo() e curveTo().

Il metodo drawPath() utilizza inoltre regole leggermente diverse per il riempimento e il disegno delle righe. Tali regole sono riportate di seguito:

• Quando un riempimento viene applicato al rendering di un percorso:
  • Non viene eseguito il rendering di un sottopercorso inferiore a 3 punti. (Notate tuttavia che il rendering del tratto viene comunque eseguito, in base alle regole seguenti relative ai tratti.)
  • Un sottopercorso non chiuso (il punto finale non è uguale al punto iniziale) viene implicitamente chiuso.
• Quando un tratto viene applicato al rendering di un percorso:
  • I sottopercorsi possono essere composti da un numero qualsiasi di punti.
  • Il sottopercorso non viene mai implicitamente chiuso.

Parametri

Altri esempi

Elementi API correlati

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);
 

Disegna un rettangolo. Impostate lo stile della linea, il riempimento o entrambi prima di chiamare il metodo drawRect(), mediante una chiamata al metodo linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() o beginBitmapFill().

Parametri

Elementi API correlati

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);

Disegna un rettangolo arrotondato. Impostate lo stile della linea, il riempimento o entrambi prima di chiamare il metodo drawRoundRect(), mediante una chiamata al metodo linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() o beginBitmapFill().

Parametri

Elementi API correlati

Viene eseguito il rendering di una serie di triangoli, di solito per distorcere le bitmap e conferire un aspetto tridimensionale. Il metodo drawTriangles() consente di mappare il riempimento corrente, o il riempimento di una bitmap, alle facce del triangolo utilizzando una serie di coordinate (u,v).

Potete utilizzare qualsiasi tipo di riempimento, tuttavia se al riempimento è associata una matrice di trasformazione, tale matrice verrà ignorata.

Un parametro uvtData migliora il mapping delle texture quando utilizzate un riempimento bitmap.

Parametri

Altri esempi

Elementi API correlati

Applica un riempimento alle linee e alle curve aggiunte dopo l'ultima chiamata al metodo beginFill(), beginGradientFill() o beginBitmapFill(). Flash utilizza il riempimento che è stato specificato nella precedente chiamata a beginFill(), beginGradientFill() o beginBitmapFill(). Se la posizione di disegno corrente non equivale alla posizione precedente specificata in un metodo moveTo() e viene definito un riempimento, il percorso viene chiuso con una linea e successivamente riempito.

Elementi API correlati

Specifica una bitmap da utilizzare per il tratto quando disegnate delle linee.

Lo stile di linea della bitmap viene utilizzato per le chiamate successive ai metodi Graphics, ad esempio il metodo lineTo() o drawCircle(). Lo stile di linea rimane attivo finché non chiamate di nuovo i metodi lineStyle() o lineGradientStyle() o lineBitmapStyle() con parametri diversi.

Potete chiamare il metodo lineBitmapStyle() mentre disegnate un percorso per specificare stili diversi per segmenti di linea diversi all'interno di un percorso.

Chiamate il metodo lineStyle() prima di chiamare il metodo lineBitmapStyle() per attivare lo stile tratto; in caso contrario lo stile della linea rimane undefined.

Se chiamate il metodo clear(), lo stile di linea viene reimpostato su undefined.

Parametri

Elementi API correlati

Specifica un gradiente da utilizzare per il tratto quando disegnate delle linee.

Lo stile della linea sfumato viene utilizzato per le chiamate successive ai metodi Graphics, ad esempio i metodi lineTo() o il metodo drawCircle(). Lo stile di linea rimane attivo finché non chiamate di nuovo il metodo lineStyle() o lineBitmapStyle() oppure il metodolineGradientStyle() con parametri diversi.

Potete chiamare il metodo lineGradientStyle() mentre disegnate un percorso per specificare stili diversi per segmenti di linea diversi all'interno di un percorso.

Chiamate il metodo lineStyle() prima di chiamare il metodo lineGradientStyle() per attivare lo stile tratto; in caso contrario lo stile della linea rimane undefined.

Se chiamate il metodo clear(), lo stile di linea viene reimpostato su undefined.

Parametri

	type:String — Un valore della classe GradientType che specifica il tipo di gradiente da utilizzare: GradientType.LINEAR o GradientType.RADIAL.
	colors:Array — Un array di valori di colore RGB esadecimali da utilizzare nel gradiente (ad esempio, rosso è 0xFF0000, blu è 0x0000FF e così via).
	alphas:Array — Un array di valori alfa per i colori corrispondenti nell'array dei colori; i valori validi sono compresi tra 0 e 1. Se il valore è minore di 0, il valore predefinito è 0. Se è maggiore di 1, il valore predefinito è 1.
	ratios:Array — Un array di rapporti di distribuzione del colore; i valori validi sono compresi tra 0 e 255. Questo valore definisce la percentuale della larghezza in cui il colore viene campionato al 100%. Il valore 0 rappresenta la posizione di sinistra nel riquadro del gradiente, mentre 255 rappresenta la posizione di destra. Questo valore rappresenta le posizioni all'interno del riquadro del gradiente, non nello spazio di coordinate del gradiente finale, che può essere più largo o più stretto del riquadro del gradiente. Specificate un valore per ciascun valore nel parametro colors. Ad esempio, per un gradiente lineare che include due colori, blu e verde, nella figura seguente è illustrata la posizione dei colori nel gradiente in base ai diversi valori dell'array ratios: ratios Gradiente [0, 127] [0, 255] [127, 255] I valori nell'array devono aumentare in maniera sequenziale; ad esempio, [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — Una matrice di trasformazione definita dalla classe flash.geom.Matrix. La classe flash.geom.Matrix include un metodo createGradientBox(), che consente di impostare con facilità la matrice affinché possa essere utilizzata con il metodo lineGradientStyle().
	spreadMethod:String (default = "pad") — Un valore della classe SpreadMethod che specifica il metodo spread da utilizzare: SpreadMethod.PAD SpreadMethod.REFLECT SpreadMethod.REPEAT
	interpolationMethod:String (default = "rgb") — Un valore della classe InterpolationMethod che specifica il valore da utilizzare. Considerate, ad esempio, un gradiente lineare semplice tra due colori (con il parametro spreadMethod impostato su SpreadMethod.REFLECT). I diversi metodi di interpolazione influiscono sull'aspetto come illustrato di seguito: InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Un numero che controlla la posizione del punto focale del gradiente. Il valore 0 indica che il punto focale si trova al centro. 1 indica che il punto focale si trova su un bordo del cerchio del gradiente. -1 significa che il punto focale si trova sull'altro bordo del cerchio del gradiente. Un valore inferiore a -1 o superiore a 1 viene arrotondato rispettivamente a -1 o 1. L'immagine seguente mostra un gradiente con focalPointRatio pari a -0,75:

Altri esempi

Elementi API correlati

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);
    
        }
    }
}

Specifica uno shader da utilizzare per il tratto quando disegnate delle linee.

Lo stile di linea dello shader viene utilizzato per le chiamate successive ai metodi Graphics, ad esempio il metodo lineTo() o drawCircle(). Lo stile di linea rimane attivo finché non chiamate di nuovo i metodi lineStyle() o lineGradientStyle() o lineBitmapStyle() con parametri diversi.

Potete chiamare il metodo lineShaderStyle() mentre disegnate un percorso per specificare stili diversi per segmenti di linea diversi all'interno di un percorso.

Chiamate il metodo lineStyle() prima di chiamare il metodo lineShaderStyle() per attivare lo stile tratto; in caso contrario lo stile della linea rimane undefined.

Se chiamate il metodo clear(), lo stile di linea viene reimpostato su undefined.

Parametri

Elementi API correlati

Specifica lo stile della linea utilizzato per le chiamate successive ai metodi Graphics, ad esempio lineTo() o drawCircle(). Lo stile della linea rimane attivo finché non chiamate il metodo lineGradientStyle(), lineBitmapStyle() o lineStyle() con parametri diversi.

Potete chiamare il metodo lineStyle() mentre disegnate un percorso per specificare stili diversi per segmenti di linea diversi all'interno di un percorso.

Nota: se chiamate il metodo clear(), lo stile di linea viene reimpostato su undefined.

Nota: Flash Lite 4 supporta solo i primi tre parametri (thickness, color e alpha).

Parametri

Elementi API correlati

Disegna una linea con lo stile di linea corrente dalla posizione di disegno corrente a (x, y); la posizione di disegno corrente viene quindi impostata su (x, y). Se l'oggetto di visualizzazione in cui si sta disegnando include contenuto creato con gli strumenti di disegno di Flash, le chiamate al metodo lineTo() vengono disegnate sotto tale contenuto. Se chiamate lineTo() prima di qualunque chiamata al metodo moveTo(), la posizione predefinita per il disegno corrente viene impostata su (0, 0). Se mancano uno o più parametri, il metodo ha esito negativo e la posizione di disegno corrente non cambia.

Parametri

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);
        }
    }
}

Sposta la posizione di disegno corrente nel punto (x, y). Se mancano uno o più parametri, il metodo ha esito negativo e la posizione di disegno corrente non cambia.

Parametri

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);           
        }
    }
}

Interroga un oggetto Sprite o Shape (e, facoltativamente, i relativi oggetti secondari) per il contenuto grafico vettoriale. Il risultato è un oggetto Vector di oggetti IGraphicsData. Le trasformazioni vengono applicate all’oggetto di visualizzazione prima della query, in modo che i percorsi restituiti siano tutti nello stesso spazio di coordinate. Le coordinate nell’insieme di dati del risultato sono relative allo stage, non all’oggetto di visualizzazione che viene campionato.

Il risultato include i seguenti tipi di oggetti con le limitazioni specificate:

• GraphicsSolidFill
• GraphicsGradientFill
  • Tutte le proprietà del riempimento con gradiente vengono restituite da readGraphicsData().
  • La matrice restituita è simile, ma non identica, alla matrice di input.
• GraphicsEndFill
• GraphicsBitmapFill
  • La matrice restituita è simile, ma non identica, alla matrice di input.
  • repeat è sempre true.
  • smoothè sempre false.
• GraphicsStroke
  • thickness è supportata.
  • fill supporta GraphicsSolidFill, GraphicsGradientFill e GraphicsBitmapFill, come descritto in precedenza
  • Tutte le altre proprietà presentano valori predefiniti.
• GraphicsPath
  • Gli unici comandi supportati sono MOVE_TO, CURVE_TO e LINE_TO.

Gli elementi visivi e le trasformazioni seguenti non possono essere rappresentati e non vengono inclusi nel risultato:

• Maschere
• Testo, con una sola eccezione: il testo statico definito con il tipo di anti-alias "anti-alias for animation" viene renderizzato come serie di forme vettoriali, in modo da poter essere incluso nel risultato.
• Riempimenti shader
• Metodi di fusione
• Modifica in scala a 9 porzioni
• Triangoli (creati con il metodo drawTriangles())
• Sfondo opaco
• Impostazioni di scrollrect
• Trasformazioni 2.5D
• Oggetti non visibili (oggetti dei quali la proprietà visible è false)

Parametri

Elementi API correlati

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. Dichiarate una proprietà size per utilizzarla in seguito quando si determineranno le dimensioni di ogni forma.
2. Dichiarate le proprietà che impostano l'arancione come colore di sfondo e il grigio scuro come colore del bordo, che specificano la dimensione del bordo su 0 pixel e il raggio dell'angolo su 9 pixel e che impostano 5 pixel di distanza tra il bordo dello stage e gli altri oggetti.
3. Utilizzate le proprietà dichiarate in precedenza insieme ai metodi incorporati della classe Graphics per disegnare il cerchio, il rettangolo arrotondato e il quadrato in corrispondenza delle coordinate x = 0, y = 0.
4. Ridisegnate ognuna delle forme lungo la parte superiore dello stage, partendo da x = 5, y = 5 e con una spaziatura di 5 pixel tra le forme.

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);
        }
    }
}