Color.FromArgb Método

Definição

Cria uma estrutura Color dos quatro valores dos componentes ARGB de 8 bits (alfa, vermelhos, verdes e azuis).Creates a Color structure from the four 8-bit ARGB components (alpha, red, green, and blue) values.

Sobrecargas

FromArgb(Int32, Int32, Int32, Int32)

Cria uma estrutura Color dos quatro valores de componente ARGB (alfa, vermelho, verde e azul).Creates a Color structure from the four ARGB component (alpha, red, green, and blue) values. Embora esse método permita que um valor de 32 bits seja passado para cada componente, o valor de cada componente é limitado a 8 bits.Although this method allows a 32-bit value to be passed for each component, the value of each component is limited to 8 bits.

FromArgb(Int32, Int32, Int32)

Cria uma estrutura Color com os valores de cor de 8 bits (vermelho, verde e azul) especificados.Creates a Color structure from the specified 8-bit color values (red, green, and blue). O valor alfa é, implicitamente, 255 (completamente opaco).The alpha value is implicitly 255 (fully opaque). Embora esse método permita que um valor de 32 bits seja passado para cada componente de cor, o valor de cada componente é limitado a 8 bits.Although this method allows a 32-bit value to be passed for each color component, the value of each component is limited to 8 bits.

FromArgb(Int32, Color)

Cria uma estrutura Color da estrutura Color especificada, mas com o novo valor alfa especificado.Creates a Color structure from the specified Color structure, but with the new specified alpha value. Embora esse método permita que um valor de 32 bits seja passado para o valor alfa, o valor é limitado a 8 bits.Although this method allows a 32-bit value to be passed for the alpha value, the value is limited to 8 bits.

FromArgb(Int32)

Cria uma estrutura Color por meio de um valor ARGB de 32 bits.Creates a Color structure from a 32-bit ARGB value.

FromArgb(Int32, Int32, Int32, Int32)

Cria uma estrutura Color dos quatro valores de componente ARGB (alfa, vermelho, verde e azul).Creates a Color structure from the four ARGB component (alpha, red, green, and blue) values. Embora esse método permita que um valor de 32 bits seja passado para cada componente, o valor de cada componente é limitado a 8 bits.Although this method allows a 32-bit value to be passed for each component, the value of each component is limited to 8 bits.

public:
 static System::Drawing::Color FromArgb(int alpha, int red, int green, int blue);
public static System.Drawing.Color FromArgb (int alpha, int red, int green, int blue);
static member FromArgb : int * int * int * int -> System.Drawing.Color
Public Shared Function FromArgb (alpha As Integer, red As Integer, green As Integer, blue As Integer) As Color

Parâmetros

alpha
Int32

O componente alfa.The alpha component. Os valores válidos vão de 0 a 255.Valid values are 0 through 255.

red
Int32

O componente vermelho.The red component. Os valores válidos vão de 0 a 255.Valid values are 0 through 255.

green
Int32

O componente verde.The green component. Os valores válidos vão de 0 a 255.Valid values are 0 through 255.

blue
Int32

O componente azul.The blue component. Os valores válidos vão de 0 a 255.Valid values are 0 through 255.

Retornos

O Color criado por esse método.The Color that this method creates.

Exceções

alpha, red, green ou blue é menor que 0 ou maior que 255.alpha, red, green, or blue is less than 0 or greater than 255.

Exemplos

O exemplo de código a seguir foi projetado para uso com Windows Forms e requer PaintEventArgs e, que é um parâmetro do manipulador de eventos Paint.The following code example is designed for use with Windows Forms, and it requires PaintEventArgs e, which is a parameter of the Paint event handler. O código executa as seguintes ações:The code performs the following actions:

  • Cria três pincéis, cada uma com uma cor diferente.Creates three brushes, each a different color. Cada estrutura Color usada para criar um pincel é criada a partir de quatro valores de componente (alfa, vermelho, verde, azul).Each Color structure that is used to create a brush is created from four component values (alpha, red, green, blue).

  • Usa um triângulo imaginário para posicionar três círculos.Uses an imaginary triangle to position three circles.

  • Pinta três círculos sobrepostos, cada um centralizado em um vértice do triângulo, usando um pincel diferente para cada círculo.Paints three overlapping circles, each centered on one vertex of the triangle, using a different brush for each circle.

void FromArgb1( PaintEventArgs^ e )
{
   Graphics^ g = e->Graphics;

   // Transparent red, green, and blue brushes.
   SolidBrush^ trnsRedBrush = gcnew SolidBrush( Color::FromArgb( 120, 255, 0, 0 ) );
   SolidBrush^ trnsGreenBrush = gcnew SolidBrush( Color::FromArgb( 120, 0, 255, 0 ) );
   SolidBrush^ trnsBlueBrush = gcnew SolidBrush( Color::FromArgb( 120, 0, 0, 255 ) );

   // Base and height of the triangle that is used to position the
   // circles. Each vertex of the triangle is at the center of one of the
   // 3 circles. The base is equal to the diameter of the circles.
   float triBase = 100;
   float triHeight = (float)Math::Sqrt( 3 * (triBase * triBase) / 4 );

   // Coordinates of first circle's bounding rectangle.
   float x1 = 40;
   float y1 = 40;

   // Fill 3 over-lapping circles. Each circle is a different color.
   g->FillEllipse( trnsRedBrush, x1, y1, 2 * triHeight, 2 * triHeight );
   g->FillEllipse( trnsGreenBrush, x1 + triBase / 2, y1 + triHeight, 2 * triHeight, 2 * triHeight );
   g->FillEllipse( trnsBlueBrush, x1 + triBase, y1, 2 * triHeight, 2 * triHeight );
}
public void FromArgb1(PaintEventArgs e)
{
    Graphics     g = e.Graphics;
             
    // Transparent red, green, and blue brushes.
    SolidBrush trnsRedBrush = new SolidBrush(Color.FromArgb(120, 255, 0, 0));
    SolidBrush trnsGreenBrush = new SolidBrush(Color.FromArgb(120, 0, 255, 0));
    SolidBrush trnsBlueBrush = new SolidBrush(Color.FromArgb(120, 0, 0, 255));
             
    // Base and height of the triangle that is used to position the
    // circles. Each vertex of the triangle is at the center of one of the
    // 3 circles. The base is equal to the diameter of the circles.
    float   triBase = 100;
    float   triHeight = (float)Math.Sqrt(3*(triBase*triBase)/4);
             
    // Coordinates of first circle's bounding rectangle.
    float   x1 = 40;
    float   y1 = 40;
             
    // Fill 3 over-lapping circles. Each circle is a different color.
    g.FillEllipse(trnsRedBrush, x1, y1, 2*triHeight, 2*triHeight);
    g.FillEllipse(trnsGreenBrush, x1 + triBase/2, y1 + triHeight,
        2*triHeight, 2*triHeight);
    g.FillEllipse(trnsBlueBrush, x1 + triBase, y1, 2*triHeight, 2*triHeight);
}
Public Sub FromArgb1(ByVal e As PaintEventArgs)
    Dim g As Graphics = e.Graphics

    ' Transparent red, green, and blue brushes.
    Dim trnsRedBrush As New SolidBrush(Color.FromArgb(120, 255, 0, 0))
    Dim trnsGreenBrush As New SolidBrush(Color.FromArgb(120, 0, _
    255, 0))
    Dim trnsBlueBrush As New SolidBrush(Color.FromArgb(120, 0, 0, 255))

    ' Base and height of the triangle that is used to position the
    ' circles. Each vertex of the triangle is at the center of one of
    ' the 3 circles. The base is equal to the diameter of the circle.
    Dim triBase As Single = 100
    Dim triHeight As Single = CSng(Math.Sqrt((3 * (triBase * _
    triBase) / 4)))

    ' Coordinates of first circle's bounding rectangle.
    Dim x1 As Single = 40
    Dim y1 As Single = 40

    ' Fill 3 over-lapping circles. Each circle is a different color.
    g.FillEllipse(trnsRedBrush, x1, y1, 2 * triHeight, 2 * triHeight)
    g.FillEllipse(trnsGreenBrush, x1 + triBase / 2, y1 + triHeight, _
    2 * triHeight, 2 * triHeight)
    g.FillEllipse(trnsBlueBrush, x1 + triBase, y1, 2 * triHeight, _
    2 * triHeight)
End Sub

Comentários

Para criar uma cor opaca, defina alpha como 255.To create an opaque color, set alpha to 255. Para criar uma cor semitransparente, defina alpha para qualquer valor de 1 a 254.To create a semitransparent color, set alpha to any value from 1 through 254.

FromArgb(Int32, Int32, Int32)

Cria uma estrutura Color com os valores de cor de 8 bits (vermelho, verde e azul) especificados.Creates a Color structure from the specified 8-bit color values (red, green, and blue). O valor alfa é, implicitamente, 255 (completamente opaco).The alpha value is implicitly 255 (fully opaque). Embora esse método permita que um valor de 32 bits seja passado para cada componente de cor, o valor de cada componente é limitado a 8 bits.Although this method allows a 32-bit value to be passed for each color component, the value of each component is limited to 8 bits.

public:
 static System::Drawing::Color FromArgb(int red, int green, int blue);
public static System.Drawing.Color FromArgb (int red, int green, int blue);
static member FromArgb : int * int * int -> System.Drawing.Color
Public Shared Function FromArgb (red As Integer, green As Integer, blue As Integer) As Color

Parâmetros

red
Int32

O valor do componente vermelho para o novo Color.The red component value for the new Color. Os valores válidos vão de 0 a 255.Valid values are 0 through 255.

green
Int32

O valor do componente verde para o novo Color.The green component value for the new Color. Os valores válidos vão de 0 a 255.Valid values are 0 through 255.

blue
Int32

O valor do componente azul para o novo Color.The blue component value for the new Color. Os valores válidos vão de 0 a 255.Valid values are 0 through 255.

Retornos

O Color criado por esse método.The Color that this method creates.

Exceções

red, green ou blue é menor que 0 ou maior que 255.red, green, or blue is less than 0 or greater than 255.

Exemplos

O exemplo de código a seguir foi projetado para uso com Windows Forms e requer PaintEventArgs e, que é um parâmetro do manipulador de eventos Paint.The following code example is designed for use with Windows Forms, and it requires PaintEventArgs e, which is a parameter of the Paint event handler. O código executa as seguintes ações:The code performs the following actions:

  1. Cria estruturas Color a partir dos três valores de componentes de cor (vermelho, verde, azul).Creates Color structures from the three color component values (red, green, blue). Três estruturas Color são criadas, uma para cada cor primária.Three Color structures are created, one for each primary color.

  2. Itera em um intervalo de valores Alfa, alterando o valor alfa de uma cor.Iterates through a range of alpha values, changing the alpha value of a color.

  3. Durante cada iteração, define a cor de um pincel para a cor modificada e pinta um retângulo para mostrar a cor.During each iteration, sets the color of a brush to the modified color and paints a rectangle to show the color.

  4. Repete as etapas 2 e 3 para cada cor primária.Repeats steps 2 and 3 for each primary color.

O valor alfa nunca é totalmente opaco e os retângulos se sobrepõem para que você obtenha efeitos de combinação de cores.The alpha value is never fully opaque and the rectangles overlap so you get color-combination effects.

void FromArgb2( PaintEventArgs^ e )
{
   Graphics^ g = e->Graphics;

   // Opaque colors (alpha value defaults to 255 -- max value).
   Color red = Color::FromArgb( 255, 0, 0 );
   Color green = Color::FromArgb( 0, 255, 0 );
   Color blue = Color::FromArgb( 0, 0, 255 );

   // Solid brush initialized to red.
   SolidBrush^ myBrush = gcnew SolidBrush( red );
   int alpha;

   // x coordinate of first red rectangle
   int x = 50;

   // y coordinate of first red rectangle
   int y = 50;

   // Fill rectangles with red, varying the alpha value from 25 to 250.
   for ( alpha = 25; alpha <= 250; alpha += 25 )
   {
      myBrush->Color = Color::FromArgb( alpha, red );
      g->FillRectangle( myBrush, x, y, 50, 100 );
      g->FillRectangle( myBrush, x, y + 250, 50, 50 );
      x += 50;
   }
   x = 50;

   // y coordinate of first green rectangle.
   y += 50;

   // Fill rectangles with green, varying the alpha value from 25 to 250.
   for ( alpha = 25; alpha <= 250; alpha += 25 )
   {
      myBrush->Color = Color::FromArgb( alpha, green );
      g->FillRectangle( myBrush, x, y, 50, 150 );
      x += 50;
   }
   x = 50;

   // y coordinate of first blue rectangle.
   y += 100;

   // Fill rectangles with blue, varying the alpha value from 25 to 250.
   for ( alpha = 25; alpha <= 250; alpha += 25 )
   {
      myBrush->Color = Color::FromArgb( alpha, blue );
      g->FillRectangle( myBrush, x, y, 50, 150 );
      x += 50;
   }
}
public void FromArgb2(PaintEventArgs e)
{
    Graphics     g = e.Graphics;
             
    // Opaque colors (alpha value defaults to 255 -- max value).
    Color red = Color.FromArgb(255, 0, 0);
    Color green = Color.FromArgb(0, 255, 0);
    Color blue = Color.FromArgb(0, 0, 255);
             
    // Solid brush initialized to red.
    SolidBrush  myBrush = new SolidBrush(red);
    int alpha;

    // x coordinate of first red rectangle
    int x = 50;         
    
    // y coordinate of first red rectangle
    int y = 50;         
                   
    // Fill rectangles with red, varying the alpha value from 25 to 250.
    for (alpha = 25; alpha <= 250; alpha += 25)
    {
        myBrush.Color = Color.FromArgb(alpha, red);
        g.FillRectangle(myBrush, x, y, 50, 100);
        g.FillRectangle(myBrush, x, y + 250, 50, 50);
        x += 50;
    }
    // x coordinate of first green rectangle.
    x = 50;             
    
    // y coordinate of first green rectangle.
    y += 50;            
                      
    // Fill rectangles with green, varying the alpha value from 25 to 250.
    for (alpha = 25; alpha <= 250; alpha += 25)
    {
        myBrush.Color = Color.FromArgb(alpha, green);
        g.FillRectangle(myBrush, x, y, 50, 150);
        x += 50;
    }
    // x coordinate of first blue rectangle.
    x = 50;             
    
    // y coordinate of first blue rectangle.
    y += 100;           
             
    // Fill rectangles with blue, varying the alpha value from 25 to 250.
    for (alpha = 25; alpha <= 250; alpha += 25)
    {
        myBrush.Color = Color.FromArgb(alpha, blue);
        g.FillRectangle(myBrush, x, y, 50, 150);
        x += 50;
    }
}
Public Sub FromArgb2(ByVal e As PaintEventArgs)
    Dim g As Graphics = e.Graphics

    ' Opaque colors (alpha value defaults to 255 -- max value).
    Dim red As Color = Color.FromArgb(255, 0, 0)
    Dim green As Color = Color.FromArgb(0, 255, 0)
    Dim blue As Color = Color.FromArgb(0, 0, 255)

    ' Solid brush initialized to red.
    Dim myBrush As New SolidBrush(red)
    Dim alpha As Integer

    ' x coordinate of first red rectangle.
    Dim x As Integer = 50

    ' y coordinate of first red rectangle.
    Dim y As Integer = 50

    ' Fill rectangles with red, varying the alpha value from 25 to 250.
    For alpha = 25 To 250 Step 25
        myBrush.Color = Color.FromArgb(alpha, red)
        g.FillRectangle(myBrush, x, y, 50, 100)
        g.FillRectangle(myBrush, x, y + 250, 50, 50)
        x += 50
    Next alpha

    ' x coordinate of first green rectangle.
    x = 50

    ' y coordinate of first green rectangle.
    y += 50


    ' Fill rectangles with green, varying alpha value from 25 to 250.
    For alpha = 25 To 250 Step 25
        myBrush.Color = Color.FromArgb(alpha, green)
        g.FillRectangle(myBrush, x, y, 50, 150)
        x += 50
    Next alpha

    ' x coordinate of first blue rectangle.
    x = 50

    ' y coordinate of first blue rectangle.
    y += 100

    ' Fill rectangles with blue, varying alpha value from 25 to 250.
    For alpha = 25 To 250 Step 25
        myBrush.Color = Color.FromArgb(alpha, blue)
        g.FillRectangle(myBrush, x, y, 50, 150)
        x += 50
    Next alpha
End Sub

FromArgb(Int32, Color)

Cria uma estrutura Color da estrutura Color especificada, mas com o novo valor alfa especificado.Creates a Color structure from the specified Color structure, but with the new specified alpha value. Embora esse método permita que um valor de 32 bits seja passado para o valor alfa, o valor é limitado a 8 bits.Although this method allows a 32-bit value to be passed for the alpha value, the value is limited to 8 bits.

public:
 static System::Drawing::Color FromArgb(int alpha, System::Drawing::Color baseColor);
public static System.Drawing.Color FromArgb (int alpha, System.Drawing.Color baseColor);
static member FromArgb : int * System.Drawing.Color -> System.Drawing.Color
Public Shared Function FromArgb (alpha As Integer, baseColor As Color) As Color

Parâmetros

alpha
Int32

O valor alfa para o novo Color.The alpha value for the new Color. Os valores válidos vão de 0 a 255.Valid values are 0 through 255.

baseColor
Color

O Color por meio do qual o novo Color será criado.The Color from which to create the new Color.

Retornos

O Color criado por esse método.The Color that this method creates.

Exceções

alpha é menor que 0 ou maior que 255.alpha is less than 0 or greater than 255.

Exemplos

O exemplo de código a seguir foi projetado para uso com Windows Forms e requer PaintEventArgs e, que é um parâmetro do manipulador de eventos Paint.The following code example is designed for use with Windows Forms, and it requires PaintEventArgs e, which is a parameter of the Paint event handler. O código executa as seguintes ações:The code performs the following actions:

  1. Cria estruturas Color a partir dos três valores de componentes de cor (vermelho, verde, azul).Creates Color structures from the three color component values (red, green, blue). Três estruturas Color são criadas, uma para cada cor primária.Three Color structures are created, one for each primary color.

  2. Itera em um intervalo de valores Alfa, alterando o valor alfa de uma cor.Iterates through a range of alpha values, changing the alpha value of a color.

  3. Durante cada iteração, define a cor de um pincel para a cor modificada e pinta um retângulo para mostrar a cor.During each iteration, sets the color of a brush to the modified color and paints a rectangle to show the color.

  4. Repete as etapas 2 e 3 para cada cor primária.Repeats steps 2 and 3 for each primary color.

O valor alfa nunca é totalmente opaco e os retângulos se sobrepõem para que você obtenha efeitos de combinação de cores.The alpha value is never fully opaque and the rectangles overlap so you get color-combination effects.

void FromArgb3( PaintEventArgs^ e )
{
   Graphics^ g = e->Graphics;

   // Opaque colors (alpha value defaults to 255 -- max value).
   Color red = Color::FromArgb( 255, 0, 0 );
   Color green = Color::FromArgb( 0, 255, 0 );
   Color blue = Color::FromArgb( 0, 0, 255 );

   // Solid brush initialized to red.
   SolidBrush^ myBrush = gcnew SolidBrush( red );
   int alpha;

   // x coordinate of first red rectangle
   int x = 50;

   // y coordinate of first red rectangle
   int y = 50;

   // Fill rectangles with red, varying the alpha value from 25 to 250.
   for ( alpha = 25; alpha <= 250; alpha += 25 )
   {
      myBrush->Color = Color::FromArgb( alpha, red );
      g->FillRectangle( myBrush, x, y, 50, 100 );
      g->FillRectangle( myBrush, x, y + 250, 50, 50 );
      x += 50;
   }
   x = 50;

   // y coordinate of first green rectangle
   y += 50;

   // Fill rectangles with green, varying the alpha value from 25 to 250.
   for ( alpha = 25; alpha <= 250; alpha += 25 )
   {
      myBrush->Color = Color::FromArgb( alpha, green );
      g->FillRectangle( myBrush, x, y, 50, 150 );
      x += 50;
   }
   x = 50;

   // y coordinate of first blue rectangle
   y += 100;

   // Fill rectangles with blue, varying the alpha value from 25 to 250.
   for ( alpha = 25; alpha <= 250; alpha += 25 )
   {
      myBrush->Color = Color::FromArgb( alpha, blue );
      g->FillRectangle( myBrush, x, y, 50, 150 );
      x += 50;
   }
}
public void FromArgb3(PaintEventArgs e)
{
    Graphics     g = e.Graphics;
             
    // Opaque colors (alpha value defaults to 255 -- max value).
    Color red = Color.FromArgb(255, 0, 0);
    Color green = Color.FromArgb(0, 255, 0);
    Color blue = Color.FromArgb(0, 0, 255);
             
    // Solid brush initialized to red.
    SolidBrush  myBrush = new SolidBrush(red);
    int alpha;
    
    // x coordinate of first red rectangle
    int x = 50;         
    
    // y coordinate of first red rectangle
    int y = 50;         
    
    // Fill rectangles with red, varying the alpha value from 25 to 250.
    for (alpha = 25; alpha <= 250; alpha += 25)
    {
        myBrush.Color = Color.FromArgb(alpha, red);
        g.FillRectangle(myBrush, x, y, 50, 100);
        g.FillRectangle(myBrush, x, y + 250, 50, 50);
        x += 50;
    }
    // x coordinate of first green rectangle
    x = 50;             
    
    // y coordinate of first green rectangle
    y += 50;            
    
    // Fill rectangles with green, varying the alpha value from 25 to 250.
    for (alpha = 25; alpha <= 250; alpha += 25)
    {
        myBrush.Color = Color.FromArgb(alpha, green);
        g.FillRectangle(myBrush, x, y, 50, 150);
        x += 50;
    }
    // x coordinate of first blue rectangle.
    x = 50; 
    
     // y coordinate of first blue rectangle
    y += 100;           
   
             
    // Fill rectangles with blue, varying the alpha value from 25 to 250.
    for (alpha = 25; alpha <= 250; alpha += 25)
    {
        myBrush.Color = Color.FromArgb(alpha, blue);
        g.FillRectangle(myBrush, x, y, 50, 150);
        x += 50;
    }
}
Public Sub FromArgb3(ByVal e As PaintEventArgs)
    Dim g As Graphics = e.Graphics

    ' Opaque colors (alpha value defaults to 255 -- max value).
    Dim red As Color = Color.FromArgb(255, 0, 0)
    Dim green As Color = Color.FromArgb(0, 255, 0)
    Dim blue As Color = Color.FromArgb(0, 0, 255)

    ' Solid brush initialized to red.
    Dim myBrush As New SolidBrush(red)
    Dim alpha As Integer

    ' x coordinate of first red rectangle.
    Dim x As Integer = 50

    ' y coordinate of first red rectangle.
    Dim y As Integer = 50

    ' Fill rectangles with red, varying the alpha value from 25 to 250.
    For alpha = 25 To 250 Step 25
        myBrush.Color = Color.FromArgb(alpha, red)
        g.FillRectangle(myBrush, x, y, 50, 100)
        g.FillRectangle(myBrush, x, y + 250, 50, 50)
        x += 50
    Next alpha

    ' x coordinate of first green rectangle.
    x = 50

    ' y coordinate of first green rectangle.
    y += 50

    ' Fill rectangles with green, varying alpha value from 25 to 250.
    For alpha = 25 To 250 Step 25
        myBrush.Color = Color.FromArgb(alpha, green)
        g.FillRectangle(myBrush, x, y, 50, 150)
        x += 50
    Next alpha

    ' x coordinate of first blue rectangle.
    x = 50

    ' y coordinate of first blue rectangle.
    y += 100

    ' Fill rectangles with blue, varying alpha value from 25 to 250.
    For alpha = 25 To 250 Step 25
        myBrush.Color = Color.FromArgb(alpha, blue)
        g.FillRectangle(myBrush, x, y, 50, 150)
        x += 50
    Next alpha
End Sub

Comentários

Para criar uma cor opaca, defina alpha como 255.To create an opaque color, set alpha to 255. Para criar uma cor semitransparente, defina alpha para qualquer valor de 1 a 254.To create a semitransparent color, set alpha to any value from 1 through 254.

FromArgb(Int32)

Cria uma estrutura Color por meio de um valor ARGB de 32 bits.Creates a Color structure from a 32-bit ARGB value.

public:
 static System::Drawing::Color FromArgb(int argb);
public static System.Drawing.Color FromArgb (int argb);
static member FromArgb : int -> System.Drawing.Color
Public Shared Function FromArgb (argb As Integer) As Color

Parâmetros

argb
Int32

Um valor que especifica o valor ARGB de 32 bits.A value specifying the 32-bit ARGB value.

Retornos

A estrutura Color criada por esse método.The Color structure that this method creates.

Exemplos

O exemplo de código a seguir foi projetado para uso com Windows Forms e requer PaintEventArgs e, que é um parâmetro do manipulador de eventos Paint.The following code example is designed for use with Windows Forms, and it requires PaintEventArgs e, which is a parameter of the Paint event handler. O código executa as seguintes ações:The code performs the following actions:

  • Cria três pincéis, cada uma com uma cor diferente.Creates three brushes, each a different color. Cada estrutura Color usada para criar um pincel é criada a partir de um valor ARGB de 32 bits.Each Color structure that is used to create a brush is created from a 32-bit ARGB value.

  • Usa um triângulo imaginário para posicionar três círculos.Uses an imaginary triangle to position three circles.

  • Pinta três círculos sobrepostos, cada um centralizado em um vértice do triângulo, usando um pincel diferente para cada círculo.Paints three overlapping circles, each centered on one vertex of the triangle, using a different brush for each circle.

void FromArgb4( PaintEventArgs^ e )
{
   Graphics^ g = e->Graphics;

   // Transparent red, green, and blue brushes.
   SolidBrush^ trnsRedBrush = gcnew SolidBrush( Color::FromArgb( 0x78FF0000 ) );
   SolidBrush^ trnsGreenBrush = gcnew SolidBrush( Color::FromArgb( 0x7800FF00 ) );
   SolidBrush^ trnsBlueBrush = gcnew SolidBrush( Color::FromArgb( 0x780000FF ) );

   // Base and height of the triangle that is used to position the
   // circles. Each vertex of the triangle is at the center of one of the
   // 3 circles. The base is equal to the diameter of the circles.
   float triBase = 100;
   float triHeight = (float)Math::Sqrt( 3 * (triBase * triBase) / 4 );

   // coordinates of first circle's bounding rectangle.
   float x1 = 40;
   float y1 = 40;

   // Fill 3 over-lapping circles. Each circle is a different color.
   g->FillEllipse( trnsRedBrush, x1, y1, 2 * triHeight, 2 * triHeight );
   g->FillEllipse( trnsGreenBrush, x1 + triBase / 2, y1 + triHeight, 2 * triHeight, 2 * triHeight );
   g->FillEllipse( trnsBlueBrush, x1 + triBase, y1, 2 * triHeight, 2 * triHeight );
}
public void FromArgb4(PaintEventArgs e)
{
    Graphics     g = e.Graphics;
             
    // Transparent red, green, and blue brushes.
    SolidBrush trnsRedBrush = new SolidBrush(Color.FromArgb(0x78FF0000));
    SolidBrush trnsGreenBrush = new SolidBrush(Color.FromArgb(0x7800FF00));
    SolidBrush trnsBlueBrush = new SolidBrush(Color.FromArgb(0x780000FF));
             
    // Base and height of the triangle that is used to position the
    // circles. Each vertex of the triangle is at the center of one of the
    // 3 circles. The base is equal to the diameter of the circles.
    float   triBase = 100;
    float   triHeight = (float)Math.Sqrt(3*(triBase*triBase)/4);
             
    // coordinates of first circle's bounding rectangle.
    float   x1 = 40;
    float   y1 = 40;
             
    // Fill 3 over-lapping circles. Each circle is a different color.
    g.FillEllipse(trnsRedBrush, x1, y1, 2*triHeight, 2*triHeight);
    g.FillEllipse(trnsGreenBrush, x1 + triBase/2, y1 + triHeight,
        2*triHeight, 2*triHeight);
    g.FillEllipse(trnsBlueBrush, x1 + triBase, y1, 2*triHeight, 2*triHeight);
}
Public Sub FromArgb4(ByVal e As PaintEventArgs)
    Dim g As Graphics = e.Graphics

    ' Transparent red, green, and blue brushes.
    Dim trnsRedBrush As New SolidBrush(Color.FromArgb(&H78FF0000))
    Dim trnsGreenBrush As New SolidBrush(Color.FromArgb(&H7800FF00))
    Dim trnsBlueBrush As New SolidBrush(Color.FromArgb(&H780000FF))

    ' Base and height of the triangle that is used to position the
    ' circles. Each vertex of the triangle is at the center of one of
    ' the 3 circles. The base is equal to the diameter of the circle.
    Dim triBase As Single = 100
    Dim triHeight As Single = CSng(Math.Sqrt((3 * (triBase * _
    triBase) / 4)))

    ' Coordinates of first circle
    's bounding rectangle.
    Dim x1 As Single = 40
    Dim y1 As Single = 40

    ' Fill 3 over-lapping circles. Each circle is a different color.
    g.FillEllipse(trnsRedBrush, x1, y1, 2 * triHeight, 2 * triHeight)
    g.FillEllipse(trnsGreenBrush, x1 + triBase / 2, y1 + triHeight, _
    2 * triHeight, 2 * triHeight)
    g.FillEllipse(trnsBlueBrush, x1 + triBase, y1, 2 * triHeight, _
    2 * triHeight)
End Sub

Comentários

A ordenação de byte do valor ARGB de 32 bits é AARRGGBB.The byte-ordering of the 32-bit ARGB value is AARRGGBB. O byte mais significativo (MSB), representado por AA, é o valor do componente alfa.The most significant byte (MSB), represented by AA, is the alpha component value. O segundo, terceiro e quarto bytes, representados por RR, GG e BB, respectivamente, são os componentes de cor vermelho, verde e azul, respectivamente.The second, third, and fourth bytes, represented by RR, GG, and BB, respectively, are the color components red, green, and blue, respectively.

Aplica-se a