Graphics  - AS3

Rellena un área de dibujo con una imagen de mapa de bits. El mapa de bits rellena el área a base de repeticiones o mosaicos. El relleno surte efecto hasta que llame al método beginFill(), beginBitmapFill(), beginGradientFill() o beginShaderFill(). Al llamar al método clear(), se borra el relleno.

La aplicación representa el relleno cada vez que se dibujan tres o más puntos, o bien cuando se llama al método endFill().

Parámetros

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

Elementos de API relacionados

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

Especifica un relleno simple monocolor que se utiliza en sucesivas llamadas a otros métodos Graphics (como lineTo() o drawCircle()). El relleno surte efecto hasta que llame al método beginFill(), beginBitmapFill(), beginGradientFill() o beginShaderFill(). Al llamar al método clear(), se borra el relleno.

La aplicación representa el relleno cada vez que se dibujan tres o más puntos, o bien cuando se llama al método endFill().

Parámetros

Elementos de API relacionados

Especifica un relleno degradado para utilizarlo en las posteriores llamadas a otros métodos de Graphics (como lineTo() o drawCircle()) para el objeto. El relleno surte efecto hasta que llame al método beginFill(), beginBitmapFill(), beginGradientFill() o beginShaderFill(). Al llamar al método clear(), se borra el relleno.

La aplicación representa el relleno cada vez que se dibujan tres o más puntos, o bien cuando se llama al método endFill().

Parámetros

	type:String — Un valor de la clase GradientType que especifica el tipo de degradado que debe utilizarse: GradientType.LINEAR o GradientType.RADIAL.
	colors:Array — Conjunto de valores de color RGB hexadecimales que se utiliza en el degradado; por ejemplo, rojo es 0xFF0000, azul es 0x0000FF, etc. Puede utilizar hasta 15 colores. Para cada color, especifique un valor correspondiente en los parámetros alphas y ratios.
	alphas:Array — Conjunto de valores alfa para los colores correspondientes del conjunto de colores; los valores válidos son del 0 al 100. Si el valor es inferior a 0, el valor predeterminado es 0. Si el valor es superior a 1, el valor predeterminado es 1.
	ratios:Array — Conjunto de proporciones de distribución de color; los valores válidos van de 0 a 255. Este valor define el porcentaje de la anchura donde el color se muestrea al 100%. El valor 0 representa la posición izquierda del cuadro de degradado, mientras que 255 representa la posición derecha del cuadro de degradado. Nota: este valor representa posiciones del cuadro de degradado, no el espacio de coordenadas del degradado final, que podría ser más ancho o más delgado que el cuadro de degradado. Introduzca un valor con el parámetro colors. Por ejemplo, en el caso de un degradado lineal con dos colores, azul y verde, el siguiente ejemplo ilustra la colocación de los colores en el degradado en función de los diferentes valores en el conjunto ratios: ratios Degradado [0, 127] [0, 255] [127, 255] Los valores del conjunto deben aumentar secuencialmente; por ejemplo, [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — Matriz de transformación definida por la clase flash.geom.Matrix. La clase flash.geom.Matrix incluye un método createGradientBox() que permite configurar cómodamente la matriz para utilizarla con el método beginGradientFill().
	spreadMethod:String (default = "pad") — Un valor de la clase SpreadMethod que especifica el modo de extensión que debe utilizarse: SpreadMethod.PAD, SpreadMethod.REFLECT o SpreadMethod.REPEAT. Por ejemplo, imagine un degradado lineal sencillo entre dos colores: 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); En este caso se utiliza SpreadMethod.PAD como método de extensión, por lo que el relleno con degradado tendrá este aspecto: Si utiliza SpreadMethod.REFLECT como método de extensión, el relleno con degradado tendrá este aspecto: Si utiliza SpreadMethod.REPEAT como método de extensión, el relleno con degradado tendrá este aspecto:
	interpolationMethod:String (default = "rgb") — Valor de la clase InterpolationMethod que especifica el valor que debe utilizarse: InterpolationMethod.LINEAR_RGB o InterpolationMethod.RGB Por ejemplo, imagine un degradado lineal sencillo entre dos colores (con el parámetro spreadMethod definido como SpreadMethod.REFLECT). Los diferentes métodos de interpolación afectan al aspecto de este modo: InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Número que controla la ubicación del punto focal del degradado. El valor 0 significa que el punto focal está en el centro. El valor 1 significa que el punto focal se encuentra en un borde del círculo del degradado. El valor -1 significa que el punto focal se encuentra en el otro borde del círculo del degradado. Un valor menor que -1 o mayor que 1 se redondea a -1 o 1. Por ejemplo, en el ejemplo siguiente, se muestra focalPointRatio definido en 0,75:

Elementos de API relacionados

Especifica un relleno de sombreado para utilizarlo en las posteriores llamadas a otros métodos de Graphics (como lineTo() o drawCircle()) para el objeto. El relleno surte efecto hasta que llame al método beginFill(), beginBitmapFill(), beginGradientFill() o beginShaderFill(). Al llamar al método clear(), se borra el relleno.

La aplicación representa el relleno cada vez que se dibujan tres o más puntos, o bien cuando se llama al método endFill().

Los rellenos de sombreado no se admiten en procesamiento de GPU; las áreas rellenas se colorearán de cián.

Parámetros

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

Elementos de API relacionados

Borra el gráfico que se había dibujado en este objeto Graphics y restablece la configuración de relleno y estilo de línea.

Copia todos los comandos de dibujo del objeto Graphics de origen en el objeto Graphics que realiza la llamada.

Parámetros

Dibuja una curva de Bezier desde la posición de dibujo actual hasta el punto de ancla especificado. Las curvas cúbicas de Bézier constan de dos puntos de anclaje y dos puntos de control. La curva interpola los dos puntos de anclaje y se dirige a los dos puntos de control.

Los cuatro puntos que se utilizan para dibujar una curva de Bezier con el método cubicCurveTo() son los siguientes:

• La posición de dibujo actual es el primer punto de ancla.
• Los parámetros anchorX y anchorY especifican el segundo punto de ancla.
• Los parámetros controlX1 y controlY1 especifican el primer punto de control.
• Los parámetros controlX2 y controlY2 especifican el segundo punto de control.

Si llama al método cubicCurveTo() antes de llamar al método moveTo() método, la curva comienza en posición (0, 0).

Si el método cubicCurveTo() se ejecuta correctamente, el motor de ejecución de Flash establece la posición de dibujo actual en (anchorX, anchorY). Si el método cubicCurveTo() falla, la posición de dibujo actual permanece sin cambios.

Si el clip de película contiene contenido creado con las herramientas de dibujo de Flash, los resultados de las llamadas al método cubicCurveTo() se dibujarán debajo de dicho contenido.

Parámetros

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

Dibuja una curva cuadrática de Bézier con el estilo de línea actual desde la posición de dibujo actual hasta (anchorX, anchorY) utilizando el punto de control especificado con (controlX, controlY). La posición de dibujo actual se establece entonces como (anchorX, anchorY). Si el clip de película en el que está dibujando incluye contenido creado con las herramientas de dibujo de Flash, las llamadas al método curveTo() se dibujarán debajo de este contenido. Si llama al método curveTo() antes de realizar ninguna llamada al método moveTo(), la posición predeterminada para el dibujo actual será (0, 0). Si falta alguno de los parámetros, este método fallará y la posición del dibujo actual no cambiará.

La curva dibujada es una curva cuadrática de Bézier. Las curvas cuadráticas de Bézier constan de dos puntos de anclaje y un punto de control. La curva interpola los dos puntos de anclaje y se dirige al punto de control.

Parámetros

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

Dibuja un círculo. Establezca el estilo de línea, el relleno o ambos antes de llamar al método drawCircle() llamando al método linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() o beginBitmapFill().

Parámetros

Elementos de API relacionados

Dibuja una elipse. Establezca el estilo de línea, el relleno o ambos antes de llamar al método drawEllipse() llamando al método linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() o beginBitmapFill().

Parámetros

Elementos de API relacionados

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

Envía una serie de instancias de IGraphicsData para dibujo. Este método acepta un vector con objetos, incluidos trazados, rellenos y trazos, que implementan la interfaz IGraphicsData. Un vector de instancias de IGraphicsData puede hacer referencia a un fragmento de una forma o a un conjunto totalmente definido de datos para representar una forma completa.

Los trazados de gráficos pueden contener a su vez otros trazados de gráficos. Si el vector graphicsData incluye un trazado, este trazado y todos sus subtrazados se representan durante la operación.

Parámetros

Elementos de API relacionados

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

Envía un número de comandos para dibujo. El método drawPath() acepta un Vector de comandos de dibujo individuales moveTo(), lineTo() y curveTo(), y los combina en una sola llamada. Los parámetros del método drawPath() combinan comandos de dibujo con una dirección de dibujo y pares de valores de coordenadas “x” e “y”. Los comandos de dibujo son números enteros representados como constantes definidas en la clase GraphicsPathCommand. Los pares de valores de coordenadas x, y son objetos Number de un conjunto donde cada par define una ubicación de coordenadas. La dirección de dibujo es un valor de la clase GraphicsPathWinding.

Por lo general, los dibujos se representan más rápidamente mediante drawPath() que con una serie de llamadas a método lineTo() y curveTo() individuales.

El método drawPath() utiliza un cálculo de coma flotante, por lo que la rotación y el cambio de escala de las formas es más preciso y proporciona mejores resultados. Sin embargo, las curvas enviadas con el método drawPath() pueden contener pequeños errores de alineación de subpíxeles si se utiliza con los métodos lineTo() y curveTo().

El método drawPath() también utiliza reglas distintas para rellenar y dibujar líneas. Estas reglas son:

• Si se aplica un relleno para representar un trazado:
  • No se representan subtrazados de menos de 3 puntos. (Tenga en cuenta, no obstante, que la representación sí se realiza, aunque siempre según las reglas de trazos siguientes.)
  • Los subtrazados no cerrados (el punto final no coincide con el punto inicial) se cierran de forma implícita.
• Si se aplica un trazo para representar un trazado:
  • Los subtrazados pueden estar formados por cualquier número de puntos.
  • El subtrazado nunca se cierra de forma implícita.

Parámetros

Elementos de API relacionados

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

Dibuja un rectángulo. Establezca el estilo de línea, el relleno o ambos antes de llamar al método drawRect() llamando al método linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() o beginBitmapFill().

Parámetros

Elementos de API relacionados

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

Dibuja un rectángulo redondeado. Establezca el estilo de línea, el relleno o ambos antes de llamar al método drawRoundRect() llamando al método linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() o beginBitmapFill().

Parámetros

Elementos de API relacionados

Representa un conjunto de triángulos, normalmente para distorsionar mapas de bits, y le da una apariencia tridimensional. El método drawTriangles() asigna o bien el relleno actual, o un relleno de mapa de bits a las caras del triángulo mediante un conjunto de coordenadas (u,v).

Se puede utilizar cualquier tipo de relleno, pero si el relleno tiene una matriz, ésta se omite.

Un parámetro uvtData mejora la asignación de texturas cuando se utiliza relleno de mapa de bits.

Parámetros

Elementos de API relacionados

Aplica un relleno a las líneas y curvas añadidas desde la última llamada al método beginFill(), beginGradientFill() o beginBitmapFill(). Flash utiliza el relleno especificado en la anterior llamada al método beginFill(), beginGradientFill() o beginBitmapFill(). Si la posición de dibujo actual no es la misma que la posición anterior especificada en un método moveTo() y se ha definido un relleno, el trazado se cerrará con una línea y luego se rellenará.

Elementos de API relacionados

Especifica un mapa de bits para utilizar en el trazo de líneas de dibujo.

El estilo de línea de mapa de bits se utiliza en las siguientes llamadas a métodos Graphics, como el método lineTo() o drawCircle(). El estilo de línea surte efecto hasta que llame a los métodos lineStyle() o lineGradientStyle(), o vuelva a llamar al método lineBitmapStyle() con distintos parámetros.

Puede efectuar una llamada al método lineBitmapStyle() en mitad de un trazado para especificar diferentes estilos para los distintos segmentos de línea de un trazado.

Llame al método lineStyle() antes de llamar al método lineBitmapStyle() para habilitar el trazo; si no lo hace, el estilo de línea es undefined.

Las llamadas al método clear() volverán a establecer el estilo de línea con el valor undefined.

Parámetros

Elementos de API relacionados

Especifica un degradado para utilizar en el trazo de líneas de dibujo.

El estilo de línea de degradado se utilizará en las siguientes llamadas a métodos Graphics, como el método lineTo() o drawCircle(). El estilo de línea surte efecto hasta que llame a los métodos lineStyle() o lineBitmapStyle(), o vuelva a llamar al método lineGradientStyle() con distintos parámetros.

Puede efectuar una llamada al método lineGradientStyle() en mitad de un trazado para especificar diferentes estilos para los distintos segmentos de línea de un trazado.

Llame al método lineStyle() antes de llamar al método lineGradientStyle() para habilitar el trazo; si no lo hace, el estilo de línea es undefined.

Las llamadas al método clear() volverán a establecer el estilo de línea con el valor undefined.

Parámetros

	type:String — Un valor de la clase GradientType que especifica el tipo de degradado que debe utilizarse, GradientType.LINEAR o GradientType.RADIAL.
	colors:Array — Conjunto de valores de color RGB hexadecimales que se utiliza en el degradado (por ejemplo, rojo es 0xFF0000, azul es 0x0000FF, etc.).
	alphas:Array — Conjunto de valores alfa para los colores correspondientes del conjunto de colores; los valores válidos son del 0 al 100. Si el valor es inferior a 0, el valor predeterminado es 0. Si el valor es superior a 1, el valor predeterminado es 1.
	ratios:Array — Conjunto de proporciones de distribución de color; los valores válidos van de 0 a 255. Este valor define el porcentaje de la anchura donde el color se muestrea al 100%. El valor 0 representa la posición izquierda del cuadro de degradado, mientras que 255 representa la posición derecha del cuadro de degradado. Este valor representa posiciones del cuadro de degradado, no el espacio de coordenadas del degradado final, que podría ser más ancho o más delgado que el cuadro de degradado. Introduzca un valor con el parámetro colors. Por ejemplo, en el caso de un degradado lineal con dos colores, azul y verde, la siguiente figura ilustra la colocación de los colores en el degradado en función de los diferentes valores en el conjunto ratios: ratios Degradado [0, 127] [0, 255] [127, 255] Los valores del conjunto deben aumentar secuencialmente; por ejemplo, [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — Matriz de transformación definida por la clase flash.geom.Matrix. La clase flash.geom.Matrix incluye un método createGradientBox(), que permite configurar cómodamente la matriz para utilizarla con el método lineGradientStyle().
	spreadMethod:String (default = "pad") — Un valor de la clase SpreadMethod que especifica el modo de extensión que debe utilizarse: SpreadMethod.PAD SpreadMethod.REFLECT SpreadMethod.REPEAT
	interpolationMethod:String (default = "rgb") — Valor de la clase InterpolationMethod que especifica el valor que debe utilizarse. Por ejemplo, imagine un degradado lineal sencillo entre dos colores (con el parámetro spreadMethod definido como SpreadMethod.REFLECT). Los diferentes métodos de interpolación afectan al aspecto de este modo: InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Número que controla la ubicación del punto focal del degradado. El valor 0 significa que el punto focal está en el centro. El valor 1 significa que el punto focal se encuentra en un borde del círculo del degradado. El valor -1 significa que el punto focal se encuentra en el otro borde del círculo del degradado. Los valores menores que -1 o mayores que 1 se redondean a -1 o 1. En el ejemplo siguiente, se muestra un degradado con focalPointRatio como -0,75:

Elementos de API relacionados

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

Especifica un sombreado para utilizar en el trazo de líneas de dibujo.

El estilo de línea de sombreado se utiliza en las siguientes llamadas a métodos Graphics, como el método lineTo() o drawCircle(). El estilo de línea surte efecto hasta que llame a los métodos lineStyle() o lineGradientStyle(), o vuelva a llamar al método lineBitmapStyle() con distintos parámetros.

Puede efectuar una llamada al método lineShaderStyle() en mitad de un trazado para especificar diferentes estilos para los distintos segmentos de línea de un trazado.

Llame al método lineStyle() antes de llamar al método lineShaderStyle() para habilitar el trazo; si no lo hace, el estilo de línea es undefined.

Las llamadas al método clear() volverán a establecer el estilo de línea con el valor undefined.

Parámetros

Elementos de API relacionados

Especifica un estilo de línea de degradado que se utilizará en las siguientes llamadas a métodos Graphics como lineTo() o drawCircle(). El estilo de línea surte efecto hasta que llame a los métodos lineGradientStyle() o lineBitmapStyle(), o al método lineStyle() con distintos parámetros.

Puede efectuar una llamada al método lineStyle() en mitad de un trazado para especificar diferentes estilos para los distintos segmentos de línea de un trazado.

Nota: las llamadas al método clear() volverán a establecer el estilo de línea con el valor undefined.

Nota: Flash Lite 4 sólo admite los primeros tres parámetros (thickness, colory alpha).

Parámetros

Elementos de API relacionados

Dibuja una línea utilizando el estilo de línea actual desde la posición de dibujo actual hasta (x, y); la posición de dibujo actual se establece posteriormente como (x, y). Si el objeto de visualización en el que está dibujando incluye contenido creado con las herramientas de dibujo de Flash, las llamadas al método lineTo() se dibujarán debajo de este contenido. Si llama a lineTo() antes de realizar ninguna llamada al método moveTo(), la posición de predeterminada para el dibujo actual será (0, 0). Si falta alguno de los parámetros, este método fallará y la posición del dibujo actual no cambiará.

Parámetros

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

Mueve la posición de dibujo actual a (x, y). Si falta alguno de los parámetros, este método fallará y la posición del dibujo actual no cambiará.

Parámetros

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

Realiza una consulta de un objeto Sprite o Shape (y de sus elementos secundarios, opcionalmente) sobre el contenido de gráficos vectoriales. El resultado es un Vector de objetos IGraphicsData. Se aplican transformaciones al objeto de visualización antes de la consulta, por lo que todas las rutas devueltas se encuentran en el mismo espacio de coordenadas. Las coordenadas del conjunto de datos de resultados son relativas al escenario, no al objeto de visualización que se está muestreando.

El resultado incluye los siguientes tipos de objetos, con las limitaciones especificadas:

• GraphicsSolidFill
• GraphicsGradientFill
  • Todas las propiedades de relleno con degradado se devuelven mediante readGraphicsData().
  • La matriz devuelta es muy similar, pero no exactamente igual, a la matriz de entrada.
• GraphicsEndFill
• GraphicsBitmapFill
  • La matriz devuelta es muy similar, pero no exactamente igual, a la matriz de entrada.
  • repeat es siempre true.
  • smooth es siempre false.
• GraphicsStroke
  • thickness es un valor admitido.
  • fill admite GraphicsSolidFill, GraphicsGradientFill y GraphicsBitmapFill como se ha descrito anteriormente
  • Las demás propiedades tienen los valores predeterminados.
• GraphicsPath
  • Los únicos comandos admitidos son MOVE_TO, CURVE_TO y LINE_TO.

Los siguientes elementos y transformaciones visuales no se pueden representar y no se incluyen en el resultado:

• Máscaras
• Texto, con una excepción: el texto estático definido con tipo de suavizado "Suavizado para animación" se representa como formas vectoriales y por tanto no se incluye en el resultado.
• Rellenos de sombreado
• Modos de mezcla
• Escala de 9 divisiones
• Triángulos (creados con el método drawTriangles())
• Fondo opaco
• Configuración scrollrect
• Transformaciones 2.5D
• Objetos no visibles (objetos cuya propiedad visible tiene el valor false)

Parámetros

Elementos de API relacionados

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. Declare una propiedad size para utilizarla posteriormente en la determinación del tamaño de cada forma.
2. Declare propiedades que establezcan el color de fondo en naranja, el color del borde en gris oscuro, el tamaño del borde en 0 píxeles, el radio de la esquina en 9 píxeles y defina el espacio entre el borde del escenario y los demás objetos en 5 píxeles.
3. Utilice las propiedades declaradas en los pasos anteriores junto con los métodos incorporados de la clase Graphics para dibujar el círculo, el rectángulo redondeado y el cuadrado en las coordenadas x = 0, y = 0.
4. Vuelva a dibujar cada una de las formas en la parte superior del escenario, comenzando en x = 5, y = 5, con un espaciado de 5 píxeles entre las formas.

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