Graphics  - AS3

Preenche uma área de desenho com uma imagem bitmap. O bitmap pode ser repetido ou colocado lado a lado para preencher a área. O preenchimento permanece em vigor até você chamar os métodos beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Chamar o método clear() irá limpar o preenchimento.

O aplicativo renderiza o preenchimento sempre que três ou mais pontos são desenhados, ou quando o método endFill() é chamado.

Parâmetros

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

Elementos da 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 um preenchimento simples de uma cor para chamadas subsequentes a outros métodos Graphics (como lineTo() ou drawCircle()) usados para desenhar. O preenchimento permanece em vigor até você chamar os métodos beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Chamar o método clear() irá limpar o preenchimento.

O aplicativo renderiza o preenchimento sempre que três ou mais pontos são desenhados, ou quando o método endFill() é chamado.

Parâmetros

Elementos da API relacionados

Especifica um preenchimento de gradiente usado nas chamadas subsequentes de outros métodos Graphics (por exemplo, lineTo() ou drawCircle()) do objeto. O preenchimento permanece em vigor até você chamar os métodos beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Chamar o método clear() irá limpar o preenchimento.

O aplicativo renderiza o preenchimento sempre que três ou mais pontos são desenhados, ou quando o método endFill() é chamado.

Parâmetros

	type:String — Um valor a partir da classe SpreadMethod que especifica o modo de dispersão a ser usado. GradientType.LINEAR ou GradientType.RADIAL.
	colors:Array — Uma matriz de valores de cor hexadecimais RGB usada no gradiente, por exemplo, vermelho é 0xFF0000, azul é 0x0000FF, e assim por diante. É possível especificar até 15 cores. Para cada uma, especifique um valor correspondente nos parâmetros de alfas e proporções.
	alphas:Array — Uma matriz de valores alfa para as cores correspondentes na matriz de cores. Os valores válidos são de 0 a 1. Se o valor for menor do que 0, o padrão será 0. Se o valor for maior do que 1, o padrão será 1.
	ratios:Array — Uma matriz de proporções de distribuição de cores. Os valores válidos são de 0 a 255. Esse valor define a porcentagem da largura na qual a cor é classificada em 100%. O valor 0 representa a posição à esquerda na caixa de gradiente, enquanto 255 representa a posição à direita nessa caixa. Observação: Esse valor representa posições na caixa de gradiente e não o espaço de coordenadas do gradiente final, que pode ser mais amplo ou estreito do que a caixa de gradiente. Especifique um valor para valor no parâmetro cores. Por exemplo, para um gradiente linear que inclui duas cores, azul e verde, o exemplo a seguir ilustra a disposição das cores nesse gradiente com base em diferentes valores na matriz de proporções: proporções Gradiente [0, 127] [0, 255] [127, 255] Os valores na matriz devem aumentar sequencialmente; por exemplo, [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — Uma matriz de transformação é definida pela classe flash.geom.Matrix. A classe flash.geom.Matrix inclui um método createGradientBox(), que permite configurar convenientemente a matriz para uso com o método beginGradientFill().
	spreadMethod:String (default = "pad") — Um valor a partir da classe SpreadMethod que especifica o modo de dispersão a ser usado. SpreadMethod.PAD, SpreadMethod.REFLECT ouSpreadMethod.REPEAT. Por exemplo, considere um gradiente linear simples entre duas cores: 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); Esse exemplo usa SpreadMethod.PAD para o método de dispersão e o preenchimento de gradiente tem a seguinte aparência: Se você usar SpreadMethod.REFLECT para o método de dispersão, o preenchimento de gradiente terá a seguinte aparência: Se você usar SpreadMethod.REPEAT para o método de dispersão, o preenchimento de gradiente terá a seguinte aparência:
	interpolationMethod:String (default = "rgb") — Um valor da classe InterpolationMethod que especifica o valor a ser usado: InterpolationMethod.LINEAR_RGB ou InterpolationMethod.RGB Por exemplo, considere um gradiente linear simples entre duas cores (com o parâmetro métodoDifusão definido como SpreadMethod.REFLECT). Os diferentes métodos de interpolação afetam a aparência da seguinte maneira: InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Um número que controla a localização do ponto focal do gradiente. 0 significa que o ponto focal está no centro. 1 significa que o ponto focal está em uma borda do círculo do gradiente. -1 significa que o ponto focal está na outra borda do círculo do gradiente. Um valor menor que -1 ou maior que 1 é arredondado para -1 ou 1. Por exemplo, o exemplo a seguir mostra focalPointRatio definido como 0,75:

Elementos da API relacionados

Especifica um preenchimento de shader usado nas chamadas subsequentes de outros métodos Graphics (por exemplo, lineTo() ou drawCircle()) do objeto. O preenchimento permanece em vigor até você chamar os métodos beginFill(), beginBitmapFill(), beginGradientFill() ou beginShaderFill(). Chamar o método clear() irá limpar o preenchimento.

O aplicativo renderiza o preenchimento sempre que três ou mais pontos são desenhados, ou quando o método endFill() é chamado.

Os preenchimentos com sombreamento não são compatíveis com a renderização pela GPU. Áreas preenchidas serão pintadas de ciano.

Parâmetros

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

Elementos da API relacionados

Limpa os gráficos que foram desenhados para este objeto Graphics e redefine as configurações de preenchimento e estilo de linha.

Copia todos os comandos de desenho do objeto Graphics de origem para o objeto Graphics de chamada.

Parâmetros

Desenha uma curva de Bezier cúbica a partir da posição de desenho atual ao ponto de ancoragem especificado. Curvas de Bezier cúbicas consistem em dois pontos de ancoragem e dois pontos de controle. A curva interpola os dois pontos de ancoragem e resulta em um encurvamento em direção aos pontos de controle.

Os quatro pontos utilizados para desenhar uma curva de Bezier cúbica com o métodocubicCurveTo () são os seguintes:

• A posição de desenho atual é o primeiro ponto de ancoragem.
• O anchorX e os parâmetros anchorY especificam o segundo ponto de ancoragem.
• O controlX1 e os parâmetros controlY1 especificam o primeiro ponto de controle.
• O controlX2 e os parâmetros controlY2 especificam o segundo ponto de controle.

Se você chamar o método cubicCurveTo () antes da chamada do método moveTo (), sua curva será iniciada na posição (0, 0).

Se o método cubicCurveTo () for bem-sucedido, o tempo de execução do Flash definirá a posição de desenho atual em (anchorX, anchorY). Se o método cubicCurveTo () falhar, a posição de desenho atual permanecerá inalterada.

Se seu clipe de filme contiver o conteúdo criado com as ferramentas de desenho do Flash, os resultados de chamadas para o método cubicCurveTo () serão desenhados embaixo daquele conteúdo.

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

Desenha uma curva Bezier quadrática utilizando o estilo de linha atual a partir da posição de desenho atual até (anchorX, anchorY) e utilizando o ponto de controle especificado por (controlX, controlY). A posição de desenho atual é então definida como (anchorX, anchorY). Se o clipe de filme no qual você está desenhando tiver um conteúdo criado com as ferramentas de desenho do Flash, as chamadas para o método curveTo() serão desenhadas abaixo desse conteúdo. Se você chamar curveTo() antes de qualquer chamada ao método moveTo(), o padrão da posição de desenho atual será (0, 0). Se qualquer um dos parâmetros estiver ausente, esse método falhará e a posição do desenho atual não será alterada.

A curva desenhada é uma curva de Bezier quadrática. Curvas de Bezier quadráticas consistem em dois pontos de ancoragem e um ponto de controle. A curva interpola os dois pontos de ancoragem e resulta em um encurvamento em direção ao ponto de controle.

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

Desenha um círculo. Defina o estilo de linha, o preenchimento, ou ambos, antes de chamar o método drawCircle(). Para tanto, chame o método linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Parâmetros

Elementos da API relacionados

Desenha uma elipse. Defina o estilo de linha, o preenchimento, ou ambos, antes de chamar o método drawEllipse(). Para tanto, chame o método linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Parâmetros

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

Envia uma série de ocorrências de IGraphicsData para desenho. O método aceita um Vector que contém objetos, inclusive caminhos, preenchimentos e traçados, que implementam a interface IGraphicsData. Um Vector de ocorrências de IGraphicsData pode se referir a uma parte de uma forma ou a um conjunto de dados complexos totalmente definido para renderização de uma forma completa.

Os caminhos gráficos podem conter outros caminhos gráficos. Se o Vector graphicsData incluir um caminho, este e todos os subcaminhos serão renderizados durante a operação.

Parâmetros

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

Envia uma série de comandos para desenho. O método drawPath() aceita um vetor dos comandos de desenho moveTo(), lineTo() e curveTo() individuais, combinando-os em uma única chamada. Os parâmetros do método drawPath() combinam comandos de desenho com pares de valores de coordenadas x e y e uma direção do desenho. Os comandos de desenho são inteiros, representados como constantes definidas na classe GraphicsPathCommand. Os pares de valores de coordenadas x e y são números em uma matriz, sendo que cada par define a localização de uma coordenada. A direção do desenho é um valor da classe GraphicsPathWinding.

Geralmente, os desenhos são renderizados mais rapidamente com drawPath() do que com uma série de chamadas de métodos individuais lineTo() e curveTo().

O método drawPath() usa um cálculo de flutuação para que a rotação e o dimensionamento de formas sejam mais precisos e produzam melhores resultados. No entanto, as curvas enviadas através do método drawPath() podem ter pequenos erros de alinhamento de subpixel quando usadas em conjunto com os métodos lineTo() e curveTo().

O método drawPath() também usa regras levemente diferentes para preencher e desenhar as linhas. São as seguintes:

• Quando se aplica um preenchimento para renderizar um caminho:
  • Um subcaminho de menos de três pontos não é renderizado. (Mas observe que a renderização do traçado ainda vai ocorrer, em consonância com as regras dos traçados abaixo.)
  • Um subcaminho que não está fechado (o ponto final não é igual ao ponto inicial) é implicitamente fechado.
• Quando se aplica um traçado para renderizar um caminho:
  • Os subcaminhos podem ser compostos por um número qualquer de pontos.
  • O subcaminho nunca é implicitamente fechado.

Parâmetros

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

Desenha um retângulo. Defina o estilo de linha, o preenchimento, ou ambos, antes de chamar o método drawRect(). Para tanto, chame o método linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Parâmetros

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

Desenha um retângulo arredondado. Defina o estilo de linha, o preenchimento, ou ambos, antes de chamar o método drawRoundRect(). Para tanto, chame o método linestyle(), lineGradientStyle(), beginFill(), beginGradientFill() ou beginBitmapFill().

Parâmetros

Elementos da API relacionados

Renderiza um conjunto de triângulos, geralmente para distorcer bitmaps e dar uma aparência tridimensional. O método drawTriangles() mapeia o preenchimento atual ou um preenchimento de bitmap para as faces do triângulo usando um conjunto de coordenadas (u,v).

Você pode usar qualquer tipo de preenchimento, mas se o preenchimento tiver uma matriz de transformação, ela será ignorada.

O parâmetro uvtData melhora o mapeamento de textura quando é usado um preenchimento de bitmap.

Parâmetros

Elementos da API relacionados

Aplica um preenchimento às linhas e curvas que foram adicionadas desde a última chamada ao método beginFill(), beginGradientFill() ou beginBitmapFill(). O Flash usa o preenchimento especificado na chamada anterior ao método beginFill(), beginGradientFill() ou beginBitmapFill(). Se a posição de desenho atual não for igual à posição anterior especificada em um método moveTo() e um preenchimento for definido, o caminho será fechado com uma linha e então preenchido.

Elementos da API relacionados

Especifica um bitmap a ser usado no traçado da linha durante o desenho de linhas.

O estilo de linha do bitmap a ser usado nas chamadas subsequentes de métodos Graphics, por exemplo, lineTo() ou drawCircle(). O estilo de linha permanecerá em vigor até você chamar o método lineStyle() ou lineGradientStyle(), ou o método lineBitmapStyle() novamente com parâmetros diferentes.

É possível chamar o método lineBitmapStyle() em meio ao desenho de um caminho para especificar diferentes estilos para diferentes segmentos de linha em um caminho.

Chame o método lineStyle() antes de chamar o método lineBitmapStyle() para ativar um traçado, ou o valor do estilo de linha será undefined.

As chamadas para o método clear() redefinem o estilo de linha como undefined.

Parâmetros

Elementos da API relacionados

Especifica um gradiente a ser usado no traçado durante o desenho de linhas.

O estilo de linha do gradiente é usado nas chamadas subsequentes de métodos Graphic, por exemplo, lineTo() ou drawCircle(). O estilo de linha permanecerá em vigor até você chamar o método lineStyle() ou lineBitmapStyle(), ou o método lineGradientStyle() novamente com parâmetros diferentes.

É possível chamar o método lineGradientStyle() em meio ao desenho de um caminho para especificar diferentes estilos para diferentes segmentos de linha em um caminho.

Chame o método lineStyle() antes de chamar o método lineGradientStyle() para ativar um traçado, ou o valor do estilo de linha será undefined.

As chamadas para o método clear() redefinem o estilo de linha como undefined.

Parâmetros

	type:String — Um valor da classe GradientType que especifica o tipo de gradiente a ser usado: GradientType.LINEAR ou GradientType.RADIAL.
	colors:Array — Uma matriz de valores de cor hexadecimais RGB a ser usada no gradiente (por exemplo, vermelho é 0xFF0000, azul é 0x0000FF e assim por diante).
	alphas:Array — Uma matriz de valores alfa para as cores correspondentes na matriz de cores. Os valores válidos são de 0 a 1. Se o valor for menor do que 0, o padrão será 0. Se o valor for maior do que 1, o padrão será 1.
	ratios:Array — Uma matriz de proporções de distribuição de cores. Os valores válidos são de 0 a 255. Esse valor define a porcentagem da largura na qual a cor é classificada em 100%. O valor 0 representa a posição à esquerda na caixa de gradiente, enquanto 255 representa a posição à direita nessa caixa. Esse valor representa posições na caixa de gradiente e não o espaço de coordenadas do gradiente final, que pode ser mais amplo ou estreito do que a caixa de gradiente. Especifique um valor para valor no parâmetro cores. Por exemplo, para um gradiente linear que inclui duas cores, azul e verde, a figura a seguir ilustra a disposição das cores nesse gradiente com base em diferentes valores na matriz de proporções: proporções Gradiente [0, 127] [0, 255] [127, 255] Os valores na matriz devem aumentar sequencialmente; por exemplo, [0, 63, 127, 190, 255].
	matrix:Matrix (default = null) — Uma matriz de transformação é definida pela classe flash.geom.Matrix. A classe flash.geom.Matrix inclui um método createGradientBox(), que permite configurar convenientemente a matriz para uso com o método lineGradientStyle().
	spreadMethod:String (default = "pad") — Um valor a partir da classe SpreadMethod que especifica o modo de dispersão a ser usado. SpreadMethod.PAD SpreadMethod.REFLECT SpreadMethod.REPEAT
	interpolationMethod:String (default = "rgb") — Um valor da classe InterpolationMethod que especifica o valor a ser usado. Por exemplo, considere um gradiente linear simples entre duas cores (com o parâmetro métodoDifusão definido como SpreadMethod.REFLECT). Os diferentes métodos de interpolação afetam a aparência da seguinte maneira: InterpolationMethod.LINEAR_RGB InterpolationMethod.RGB
	focalPointRatio:Number (default = 0) — Um número que controla a localização do ponto focal do gradiente. O valor 0 significa que o ponto focal está no centro. O valor 1 significa que o ponto focal está em uma borda do círculo do gradiente. O valor -1 significa que o ponto focal está na outra borda do círculo do gradiente. Valores menores que -1 ou maiores que 1 são arredondados para -1 ou 1. A imagem a seguir mostra um gradiente com focalPointRatio de -0,75:

Elementos da 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 um shader a ser usado no traçado da linha durante o desenho de linhas.

O estilo de linha do shader a ser usado nas chamadas subsequentes de métodos Graphics, por exemplo, lineTo() ou drawCircle(). O estilo de linha permanecerá em vigor até você chamar o método lineStyle() ou lineGradientStyle(), ou o método lineBitmapStyle() novamente com parâmetros diferentes.

Você pode chamar o método lineShaderStyle() durante o desenho de um caminho para especificar estilos diferentes para diversos segmentos de linha em um caminho.

Chame o método lineStyle() antes de chamar o método lineShaderStyle() para ativar um traçado, ou o valor do estilo de linha será undefined.

As chamadas para o método clear() redefinem o estilo de linha como undefined.

Parâmetros

Elementos da API relacionados

Especifica um estilo de linha a ser usado nas chamadas subsequentes de métodos Graphics, por exemplo, lineTo() ou drawCircle(). O estilo de linha permanecerá em vigor até você chamar os métodos lineGradientStyle(), lineBitmapStyle(), ou o método lineStyle() com parâmetros diferentes.

É possível chamar o método lineStyle() em meio ao desenho de um caminho para especificar diferentes estilos para diferentes segmentos de linha no caminho.

Observação: Chamadas ao método clear() redefinem o estilo de linha para undefined.

Nota: o Flash Lite 4 suporta só os três primeiros parâmetros (espessura, cor, e alfa).

Parâmetros

Elementos da API relacionados

Desenha uma linha usando o estilo de linha atual a partir da posição de desenho atual até (x, y); a posição de desenho atual é então definida como (x, y). Se o objeto de exibição no qual você está desenhando tiver um conteúdo criado com as ferramentas de desenho do Flash, as chamadas para o método lineTo() serão desenhadas abaixo desse conteúdo. Se você chamar lineTo() antes de qualquer chamada ao método moveTo(), a posição padrão do desenho atual será (0, 0). Se qualquer um dos parâmetros estiver ausente, esse método falhará e a posição do desenho atual não será alterada.

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

Move a posição do desenho atual até (x, y). Se qualquer um dos parâmetros estiver ausente, esse método falhará e a posição do desenho atual não será alterada.

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

Consulte um objeto Sprite ou Shape (e, opcionalmente, seus filhos) para o conteúdo do vetor do gráfico. O resultado é um vetor de objetos IGraphicsData. As transformações são aplicadas ao objeto de exibição antes da consulta. Assim, todos os caminhos retornados estão no mesmo espaço coordenado. As coordenadas no conjunto de dados de resultados são relativas ao palco, não ao objeto de exibição de amostra.

O resultado inclui os seguintes tipos de objetos, com as limitações especificadas:

• GraphicsSolidFill
• GraphicsGradientFill
  • Todas as propriedades do preenchimento de gradiente são retornadas pelo readGraphicsData().
  • A matriz retornada é parecida, mas não exatamente a mesma matriz de entrada.
• GraphicsEndFill
• GraphicsBitmapFill
  • A matriz retornada é parecida, mas não exatamente a mesma matriz de entrada.
  • repeat é sempre true.
  • smooth é sempre false.
• GraphicsStroke
  • thickness é suportado.
  • fill suporta GraphicsSolidFill, GraphicsGradientFill e GraphicsBitmapFill, como descrito anteriormente
  • Todas as outras propriedades possuem valores padrão.
• GraphicsPath
  • Os únicos comandos suportados são MOVE_TO, CURVE_TO e LINE_TO.

Os seguintes elementos e transformações visuais podem ser representados e não são incluídos nos resultados:

• Máscaras
• Texto, com uma exceção: texto estático que é definido com o tipo de suavização de borda "suavização de borda para animação" é renderizado como formas do vetor e incluído no resultado.
• Preenchimentos com sombreamentos
• Modos de mesclagem
• Dimensionamento de 9 fatias
• Triângulos (criados com o método drawTriangles())
• Plano de fundo opaco
• Configurações scrollrect
• Transformações 2.5D
• Objetos não visíveis (objetos cuja propriedade visible é false)

Parâmetros

Elementos da 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 uma propriedade size para uso posterior na determinação do tamanho de cada forma.
2. Declare propriedades que definam a cor do plano de fundo como laranja, a cor da borda como cinza escuro, o tamanho da borda como 0 pixels, o raio do vértice como 9 pixels e que definam como 5 pixels o espaço entre a borda do palco e os outros objetos.
3. Use as propriedades declaradas nas etapas anteriores junto com os métodos embutidos da classe Graphics para desenhar o círculo, o retângulo arredondado e o quadrado nas coordenadas x = 0, y = 0.
4. Redesenhe cada uma das formas na parte superior do palco, começando em x = 5, y = 5, com um espaçamento de 5 pixels entre as 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);
        }
    }
}