Remplit une zone de dessin d'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);

Voir aussi

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

Voir aussi

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 — Un tableau de valeurs alpha pour les couleurs correspondantes du tableau de couleurs ; les valeurs valides vont de 0 à 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 :

Voir aussi

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.

Paramètres

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

Voir aussi

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

Dessine une courbe en utilisant le style de trait actuel à partir de la position actuelle jusqu'à (anchorX, anchorY) en utilisant le point de contrôle spécifié par (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

Voir aussi

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

Voir aussi

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

Voir aussi

Soumet une série de commandes pour le dessin. La méthode drawPath() utilise les tableaux vectoriels pour regrouper les commandes de dessin individuelles moveTo(), lineTo() et curveTo() 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 valeurs issues de 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 de méthodes individuelles 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

Voir aussi

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] = 1;
    star_commands[1] = 2;
    star_commands[2] = 2;
    star_commands[3] = 2;
    star_commands[4] = 2;

    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

Voir aussi

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

Voir aussi

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

Voir aussi

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.

Voir aussi

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

Voir aussi

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 — Un tableau de valeurs alpha pour les couleurs correspondantes du tableau de couleurs ; les valeurs valides vont de 0 à 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 :

Voir aussi

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

Voir aussi

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 lineStyle() au cours du traçage afin de spécifier des styles différents pour les divers segments de ligne dans le tracé.

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

Paramètres

Voir aussi

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

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