Graphics  - AS3

Remplit une zone de tracé en utilisant une image bitmap. L’image bitmap peut être répétée ou former une mosaïque afin de remplir la zone. Le remplissage demeure actif jusqu’à ce que vous appeliez la méthode beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Appeler la méthode clear() permet d’effacer le remplissage.

L’application effectue le remplissage lorsque trois points ou plus sont dessinés, ou lorsque la méthode endFill() est appelée.

Paramètres

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

Eléments de l’API associés

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

Spécifie un remplissage simple d’une couleur que des appels ultérieurs à d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) utilisent lors du dessin. Le remplissage demeure actif jusqu’à ce que vous appeliez la méthode beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Appeler la méthode clear() permet d’effacer le remplissage.

L’application effectue le remplissage lorsque trois points ou plus sont dessinés, ou lorsque la méthode endFill() est appelée.

Paramètres

Eléments de l’API associés

Spécifie un remplissage en dégradé utilisé lors des appels suivants d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) associées à l’objet. Le remplissage demeure actif jusqu’à ce que vous appeliez la méthode beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Appeler la méthode clear() permet d’effacer le remplissage.

L’application effectue le remplissage lorsque trois points ou plus sont dessinés, ou lorsque la méthode endFill() est appelée.

Paramètres

	type:String — Valeur de la classe GradientType qui spécifie le type de dégradé à utiliser : GradientType.LINEAR ou GradientType.RADIAL.
	colors:Array — Tableau de valeurs de couleurs RVB hexadécimales utilisé pour le dégradé (par exemple, rouge correspond à 0xFF0000, bleu à 0x0000FF, etc.). Vous pouvez définir jusqu’à 15 couleurs. Pour chaque couleur, définissez une valeur correspondante dans les paramètres alphas et ratios.
	alphas:Array — Tableau de valeurs alpha pour les couleurs correspondantes du tableau de couleurs ; les valeurs disponibles sont comprises entre 0 et 1. Si la valeur est inférieure à 0, la valeur par défaut est de 0. Si la valeur est supérieure à 1, la valeur par défaut est de 1.
	ratios:Array — Tableau de taux de distribution des couleurs ; les valeurs disponibles sont comprises entre 0 et 255. Cette valeur définit le pourcentage de la largeur où la couleur est échantillonnée sur 100 %. La valeur 0 représente la position de gauche dans la zone de dégradés, tandis que 255 représente la position de droite. Remarque : cette valeur représente les positions de la zone de dégradés, plutôt que l’espace de coordonnées du dégradé final, susceptible d’être plus large ou plus étroit que la zone de dégradés. Spécifiez une valeur pour chaque valeur dans le paramètre colors. Par exemple, pour un dégradé linéaire qui comprend deux couleurs, bleu et vert, l’exemple suivant illustre l’emplacement des couleurs dans le dégradé selon les différentes valeurs du tableau ratios : ratios Dégradé [0, 127] [0, 255] [127, 255] Les valeurs du tableau doivent augmenter de manière séquentielle ; par exemple, [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — Matrice de transformation définie par la classe flash.geom.Matrix. La classe flash.geom.Matrix inclut une méthode createGradientBox(), qui permet de configurer facilement la matrice en vue de son utilisation avec la méthode beginGradientFill().
	spreadMethod:String (default = "pad") — Valeur de la classe SpreadMethod qui spécifie la méthode d’étalement à utiliser : SpreadMethod.PAD, SpreadMethod.REFLECT ou SpreadMethod.REPEAT. Par exemple, considérons un dégradé linéaire simple entre deux couleurs : 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); Cet exemple utilise SpreadMethod.PAD comme méthode d’étalement, et le remplissage en dégradé prend l’aspect suivant : Si vous utilisez SpreadMethod.REFLECT comme méthode d’étalement, le remplissage en dégradé prend l’aspect suivant : Si vous utilisez SpreadMethod.REPEAT comme méthode d’étalement, le remplissage en dégradé prend l’aspect suivant :
	interpolationMethod:String (default = "rgb") — Valeur de la classe InterpolationMethod qui spécifie la valeur à utiliser : InterpolationMethod.LINEAR_RGB ou InterpolationMethod.RGB Prenons, par exemple, un dégradé linéaire simple entre deux couleurs (le paramètre spreadMethod étant réglé sur SpreadMethod.REFLECT). Les différentes méthodes d’interpolation influent sur l’aspect de la façon suivante : InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Nombre qui contrôle l’emplacement du point focal du dégradé. La valeur 0 signifie que le point focal est au centre. La valeur 1 signifie que le point focal est au bord du cercle du dégradé. La valeur -1 signifie que le point focal est sur l’autre bord du cercle du dégradé. Toute valeur inférieure à -1 ou supérieure à 1 est arrondie à -1 ou 1. Par exemple, l’exemple suivant affiche un paramètre focalPointRatio défini sur 0,75 :

Plus d’exemples

Eléments de l’API associés

Spécifie un remplissage de shader utilisé lors des appels suivants d’autres méthodes Graphics (telles que lineTo() ou drawCircle()) associées à l’objet. Le remplissage demeure actif jusqu’à ce que vous appeliez la méthode beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Appeler la méthode clear() permet d’effacer le remplissage.

L’application effectue le remplissage lorsque trois points ou plus sont dessinés, ou lorsque la méthode endFill() est appelée.

Les remplissages de shader ne sont pas pris en charge sous le rendu sur GPU ; les zones remplies prendront la couleur cyan.

Paramètres

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

Plus d’exemples

Eléments de l’API associés

Efface les graphiques dessinés dans l’objet Graphics et réinitialise les réglages de style de trait et de remplissage.

Copie toutes les commandes de dessin de l’objet Graphics source dans l’objet Graphics appelant.

Paramètres

Trace une courbe de Bézier cubique de la position de dessin actuelle au point d’ancrage spécifié. Les courbes de Bézier cubiques comprennent deux points d’ancrage et deux points de contrôle. La courbe interpole les deux points d’ancrage et s’incurve en direction des points de contrôle.

Les quatre points à utiliser pour tracer une courbe de Bézier cubique avec la méthode cubicCurveTo() sont les suivants :

• La position de dessin actuelle est le premier point d’ancrage.
• Les paramètres anchorX et anchorY spécifient le deuxième point d’ancrage.
• Les paramètres controlX1 et controlY1 spécifient le premier point de contrôle.
• Les paramètres controlX2 et controlY2 spécifient le deuxième point de contrôle.

Si vous appelez la méthode cubicCurveTo() avant d’appeler la méthode moveTo(), votre courbe commence à la position (0, 0).

Si l’appel de la méthode cubicCurveTo() aboutit, le moteur d’exécution de Flash définit la position de dessin actuelle sur (anchorX, anchorY). Si l’appel de la méthode cubicCurveTo() échoue, la position de dessin actuelle n’est pas modifiée.

Si votre clip contient du contenu créé à l’aide des outils de dessin de Flash, les résultats d’appels des méthodes cubicCurveTo() sont tracés sous ce contenu.

Paramètres

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

Trace une courbe de Bézier quadratique entre la position actuelle et la position (anchorX, anchorY), en utilisant le style de trait actuel et le point de contrôle spécifié par les coordonnées (controlX, controlY). La position de dessin actuelle est ensuite définie sur (anchorX, anchorY). Si le clip dans lequel vous dessinez intègre du contenu créé à l’aide des outils de dessin Flash, les appels de la méthode curveTo() sont tracés sous le contenu. Si vous appelez la méthode curveTo() avant d’appeler la méthode moveTo(), la position de dessin actuelle prend par défaut la valeur (0, 0). Si l’un des paramètres n’est pas spécifié, cette méthode échoue et la position de dessin actuelle n’est pas modifiée.

La courbe dessinée est une courbe de Bézier quadratique. Les courbes de Bézier quadratiques comprennent deux points d’ancrage et un point de contrôle. La courbe interpole les deux points d’ancrage et s’incurve en direction du point de contrôle.

Paramètres

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

Dessine un cercle. Vous devez définir le remplissage et/ou le style de ligne avant d’appeler la méthode drawCircle(), à l’aide de la méthode linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Paramètres

Eléments de l’API associés

Dessine une ellipse. Vous devez définir le remplissage et/ou le style de ligne avant d’appeler la méthode drawEllipse(), à l’aide de la méthode linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Paramètres

Eléments de l’API associés

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

Soumet une série d’occurrences IGraphicsData pour le dessin. Cette méthode accepte un objet Vector contenant des objets, y compris des tracés, des remplissages et des traits, qui implémentent l’interface IGraphicsData. Un objet Vector des occurrences IGraphicsData peut se reporter à une forme ou à un jeu de données complexe et complètement défini pour restituer une forme complète.

Les tracés des graphiques peuvent contenir d’autres tracés de graphiques. Si le vecteur graphicsData inclut un tracé, ce dernier et tous ses sous-tracés sont restitués au cours de cette opération.

Paramètres

Plus d’exemples

Eléments de l’API associés

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

Soumet une série de commandes pour le dessin. La méthode drawPath() accepte un vecteur de commandes de dessin individuelles moveTo(), lineTo() et curveTo() et les combine dans un seul appel. Les paramètres de la méthode drawPath() associent des commandes de dessin comportant des paires de valeurs de coordonnées x et y à une direction de dessin. Les commandes de dessin sont des entiers, représentés comme des constantes définies par la classe GraphicsPathCommand. Les paires de valeurs des coordonnées x et y sont des nombres dans un tableau où chaque paire définit un emplacement de coordonnée. La direction de dessin est une valeur issue de la classe GraphicsPathWinding.

En général, le rendu des dessins sera plus rapide avec la méthode drawPath() qu’avec une série d’appels de méthode individuels lineTo() et curveTo().

La méthode drawPath() utilise un calcul en virgule flottante afin que la rotation et la mise à l’échelle des formes soient plus précises et donnent de meilleurs résultats. Toutefois, les courbes soumises à l’aide de la méthode drawPath() peuvent comporter de petites erreurs d’alignement des sous-pixels lorsqu’elles sont utilisées en conjonction avec les méthodes lineTo() et curveTo().

La méthode drawPath() utilise également des règles légèrement différentes pour le remplissage et le dessin des lignes. Voici ces règles :

• Lorsqu’un remplissage est appliqué au rendu d’un tracé :
  • Tout sous-tracé de moins de 3 points n’est pas rendu (cependant, le rendu du trait se produira tout de même, en respectant les règles des traits ci-dessous).
  • Tout sous-tracé qui n’est pas clos (le point de fin n’est pas égal au point de début) est fermé implicitement.
• Lorsqu’un trait est appliqué au rendu d’un tracé :
  • Les sous-tracés peuvent être composés de tout nombre de points.
  • Le sous-tracé n’est jamais implicitement fermé.

Paramètres

Plus d’exemples

Eléments de l’API associés

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

Dessine un rectangle. Vous devez définir le remplissage et/ou le style de ligne avant d’appeler la méthode drawRect(), à l’aide de la méthode linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Paramètres

Eléments de l’API associés

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

Dessine un rectangle arrondi. Vous devez définir le remplissage et/ou le style de ligne avant d’appeler la méthode drawRoundRect(), à l’aide de la méthode linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Paramètres

Eléments de l’API associés

Restitue un ensemble de triangles, généralement pour déformer les images bitmap et leur donner un aspect tridimensionnel. La méthode drawTriangles() mappe le remplissage actuel ou un remplissage sur les faces des triangles à l’aide d’un jeu de coordonnées (u,v).

Tous les types de remplissage peuvent être utilisés, mais si le remplissage possède une matrice de transformation, celle-ci est ignorée.

Un paramètre uvtData permet d’améliorer le mappage des textures lorsqu’un remplissage bitmap est utilisé.

Paramètres

Plus d’exemples

Eléments de l’API associés

Applique un remplissage aux lignes et aux courbes ajoutées depuis le dernier appel de la méthode beginFill(), beginGradientFill() ou beginBitmapFill(). Flash utilise le remplissage spécifié lors de l’appel précédent de la méthode beginFill(), beginGradientFill() ou beginBitmapFill(). Si la position de dessin actuelle n’est pas égale à la position précédente spécifiée dans une méthode moveTo() et si un remplissage est défini, le tracé est fermé à l’aide d’une ligne, puis rempli.

Eléments de l’API associés

Spécifie une image bitmap à utiliser pour le trait lors du traçage des lignes.

Le style de ligne de l’image bitmap est utilisé pour les prochains appels aux méthodes Graphics, telles que lineTo() ou drawCircle(). Le style de ligne demeure en vigueur jusqu’à ce que vous appeliez les méthodes lineStyle() ou lineGradientStyle(), ou de nouveau la méthode lineBitmapStyle() en spécifiant d’autres paramètres.

Vous pouvez appeler la méthode lineBitmapStyle() au cours du traçage pour spécifier différents styles pour divers segments de ligne dans un tracé.

Appelez la méthode lineStyle() avant d’appeler la méthode lineBitmapStyle() pour activer un trait, sinon la valeur du style de ligne est undefined.

les appels de la méthode clear() redéfinissent le style de trait sur undefined.

Paramètres

Eléments de l’API associés

Spécifie le dégradé à utiliser pour le trait lors du tracé des lignes.

Le style de ligne dégradée est utilisé pour tous les appels suivants aux méthodes Graphics, telles que les méthodes lineTo() ou drawCircle(). Le style de ligne demeure en vigueur jusqu’à ce que vous appeliez les méthodes lineStyle() ou lineBitmapStyle(), ou de nouveau la méthode lineGradientStyle() en spécifiant d’autres paramètres.

Vous pouvez appeler la méthode lineGradientStyle() au cours du dessin pour spécifier différents styles pour divers segments de ligne dans un tracé.

Appelez la méthode lineStyle() avant d’appeler la méthode lineGradientStyle() pour activer un trait, sinon la valeur du style de ligne est undefined.

Les appels de la méthode clear() redéfinissent le style de trait sur undefined.

Paramètres

	type:String — Valeur de la classe GradientType qui spécifie le type de dégradé à utiliser, GradientType.LINEAR ou GradientType.RADIAL.
	colors:Array — Tableau de valeurs de couleurs RVB hexadécimales à utiliser pour le dégradé (par exemple, rouge correspond à 0xFF0000, bleu à 0x0000FF, etc.).
	alphas:Array — Tableau de valeurs alpha pour les couleurs correspondantes du tableau de couleurs ; les valeurs disponibles sont comprises entre 0 et 1. Si la valeur est inférieure à 0, la valeur par défaut est de 0. Si la valeur est supérieure à 1, la valeur par défaut est de 1.
	ratios:Array — Tableau de taux de distribution des couleurs ; les valeurs valides sont comprises entre 0 et 255. Cette valeur définit le pourcentage de la largeur où la couleur est échantillonnée sur 100 %. La valeur 0 représente la position de gauche dans la zone de dégradés, tandis que 255 représente la position de droite. Cette valeur représente les positions de la zone de dégradés, plutôt que l’espace de coordonnées du dégradé final, pouvant être plus large ou plus étroit que la zone de dégradés. Spécifiez une valeur pour chaque valeur dans le paramètre colors. Par exemple, pour un dégradé linéaire qui comprend deux couleurs, bleu et vert, la figure suivante illustre l’emplacement des couleurs dans le dégradé selon les différentes valeurs du tableau ratios : ratios Dégradé [0, 127] [0, 255] [127, 255] Les valeurs du tableau doivent augmenter de manière séquentielle ; par exemple, [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — Matrice de transformation définie par la classe flash.geom.Matrix. La classe flash.geom.Matrix inclut une méthode createGradientBox(), qui permet de configurer facilement la matrice en vue de son utilisation avec la méthode lineGradientStyle().
	spreadMethod:String (default = "pad") — Valeur de la classe SpreadMethod qui spécifie la méthode d’étalement à utiliser : SpreadMethod.PAD SpreadMethod.REFLECT SpreadMethod.REPEAT
	interpolationMethod:String (default = "rgb") — Valeur de la classe InterpolationMethod qui spécifie la valeur à utiliser. Prenons, par exemple, un dégradé linéaire simple entre deux couleurs (le paramètre spreadMethod étant réglé sur SpreadMethod.REFLECT). Les différentes méthodes d’interpolation influent sur l’aspect de la façon suivante : InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Nombre qui contrôle l’emplacement du point focal du dégradé. La valeur 0 signifie que le point focal est au centre. La valeur 1 signifie que le point focal est au bord du cercle du dégradé. La valeur -1 signifie que le point focal est sur l’autre bord du cercle du dégradé. Toute valeur inférieure à -1 ou supérieure à 1 est arrondie à -1 ou 1. L’image suivante affiche un dégradé avec le paramètre focalPointRatio défini sur -0,75 :

Plus d’exemples

Eléments de l’API associés

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

Spécifie un shader à utiliser pour le trait lors du traçage des lignes.

Le style de ligne du shader est utilisé pour les prochains appels aux méthodes Graphics, telles que lineTo() ou drawCircle(). Le style de ligne demeure en vigueur jusqu’à ce que vous appeliez les méthodes lineStyle() ou lineGradientStyle(), ou de nouveau la méthode lineBitmapStyle() en spécifiant d’autres paramètres.

Vous pouvez appeler la méthode lineShaderStyle() au cours du tracé afin de spécifier différents styles pour divers segments de ligne dans un tracé.

Appelez la méthode lineStyle() avant d’appeler la méthode lineShaderStyle() pour activer un trait, sinon la valeur du style de ligne est undefined.

les appels de la méthode clear() redéfinissent le style de trait sur undefined.

Paramètres

Eléments de l’API associés

Spécifie le style de ligne utilisé pour les prochains appels aux méthodes Graphics, telles que lineTo() ou drawCircle(). Le style de trait demeure en vigueur jusqu’à l’appel de la méthode lineGradientStyle(), lineBitmapStyle() ou lineStyle() en spécifiant d’autres paramètres.

Vous pouvez appeler la méthode lineGradientStyle() au cours du dessin pour spécifier différents styles pour divers segments de ligne dans un tracé.

Remarque : les appels de la méthode clear() redéfinissent le style de trait sur undefined.

Remarque : Flash Lite 4 prend en charge uniquement les trois premiers paramètres (thickness, color et alpha).

Paramètres

Eléments de l’API associés

Trace une ligne en utilisant le style de trait actuel à partir de la position de dessin actuelle jusqu’à (x, y) ; la position de dessin actuelle est ensuite réglée sur (x, y). Si l’objet d’affichage dans lequel vous effectuez le traçage possède un contenu créé à l’aide des outils de dessin Flash, les appels de la méthode lineTo() sont tracés sous le contenu. Si vous appelez lineTo() avant d’appeler la méthode moveTo(), la position de dessin par défaut prend la valeur (0, 0). Si l’un des paramètres n’est pas spécifié, cette méthode échoue et la position de dessin actuelle n’est pas modifiée.

Paramètres

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

Déplace la position de dessin actuelle vers (x, y). Si l’un des paramètres n’est pas spécifié, cette méthode échoue et la position de dessin actuelle n’est pas modifiée.

Paramètres

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

Interroge un objet Sprite ou Shape (et éventuellement ses enfants) sur son contenu graphique vectoriel. Le résultat est un vecteur d’objets IGraphicsData. Des transformations sont appliquées à l’objet d’affichage avant la requête, afin que tous les chemins renvoyés se trouvent dans le même espace de coordonnées. Les coordonnées dans les données du jeu de résultats sont relatives à la scène, pas à l’objet d’affichage échantillonné.

Le résultat inclut les types d’objets, avec les limitations spécifiées :

• GraphicsSolidFill
• GraphicsGradientFill
  • Toutes les propriétés du remplissage en dégradé sont renvoyées par readGraphicsData().
  • La matrice renvoyée est proche de la matrice d’entrée, mais pas exactement identique.
• GraphicsEndFill
• GraphicsBitmapFill
  • La matrice renvoyée est proche de la matrice d’entrée, mais pas exactement identique.
  • repeat a toujours la valeur true.
  • smooth a toujours la valeur false.
• GraphicsStroke
  • thickness est pris en charge.
  • fill prend en charge GraphicsSolidFill, GraphicsGradientFill et GraphicsBitmapFill comme décrit plus haut.
  • Toutes les autres propriétés ont des valeurs par défaut.
• GraphicsPath
  • Les seules commandes prises en charge sont MOVE_TO, CURVE_TO et LINE_TO.

Les transformations et éléments visuels suivants ne peuvent pas être représentés et ne sont pas inclus dans le résultat :

• Masques
• Texte, à une exception : le texte statique défini avec type d’anticrènelage « Anticrènelage pour l’animation » est rendu comme des formes vectorielles et est donc inclus dans le résultat
• Remplissages de shader
• Modes de fusion
• Mise à l’échelle à 9 découpes
• Triangles (créés à l’aide de la méthode drawTriangles())
• Arrière-plan opaque
• Paramètres de scrollrect
• Transformations 2.5D
• Objets non visibles (dont la propriété visible est définie sur false)

Paramètres

Eléments de l’API associés

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. Elle déclare la propriété size qui servira par la suite à déterminer la taille de chaque forme.
2. Elle déclare les propriétés qui définissent la couleur de fond sur orange, la couleur de bordure sur gris foncé, la taille de la bordure sur 0 pixel, le rayon de l’angle sur 9 pixels et définit l’espace entre le bord de la scène et les autres objets sur 5 pixels.
3. Elle utilise les propriétés déclarées au cours des étapes précédentes, ainsi que les méthodes intégrées de la classe Graphics pour dessiner le cercle, le rectangle arrondi et le carré aux coordonnées x = 0, y = 0.
4. Elle redessine les formes situées le long de la partie supérieure de la scène, en commençant par x = 5, y = 5, avec un espacement de 5 pixels entre les formes.

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