Color.FromArgb Method

Definition

Namespace:

System.Drawing

Assemblies:

netstandard.dll, System.Drawing.Primitives.dll

Creates a Color structure from the four 8-bit ARGB components (alpha, red, green, and blue) values.

Overloads

FromArgb(Int32, Int32, Int32, Int32)	Creates a Color structure from the four ARGB component (alpha, red, green, and blue) values. 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)	Creates a Color structure from the specified 8-bit color values (red, green, and blue). The alpha value is implicitly 255 (fully opaque). 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)	Creates a Color structure from the specified Color structure, but with the new specified alpha value. Although this method allows a 32-bit value to be passed for the alpha value, the value is limited to 8 bits.
FromArgb(Int32)	Creates a Color structure from a 32-bit ARGB value.

FromArgb(Int32, Int32, Int32, Int32)

Source:

Color.cs

Creates a Color structure from the four ARGB component (alpha, red, green, and blue) values. Although this method allows a 32-bit value to be passed for each component, the value of each component is limited to 8 bits.

C#

public static System.Drawing.Color FromArgb(int alpha, int red, int green, int blue);

Parameters

alpha

Int32

The alpha component. Valid values are 0 through 255.

red

Int32

The red component. Valid values are 0 through 255.

green

Int32

The green component. Valid values are 0 through 255.

blue

Int32

The blue component. Valid values are 0 through 255.

Returns

Color

The Color that this method creates.

Exceptions

ArgumentException

alpha, red, green, or blue is less than 0 or greater than 255.

Examples

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. The code performs the following actions:

• Creates three brushes, each a different color. Each Color structure that is used to create a brush is created from four component values (alpha, red, green, blue).

• Uses an imaginary triangle to position three circles.

• Paints three overlapping circles, each centered on one vertex of the triangle, using a different brush for each circle.

C#

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

Remarks

To create an opaque color, set alpha to 255. To create a semitransparent color, set alpha to any value from 1 through 254.

FromArgb(Int32, Int32, Int32)

Source:

Color.cs

Creates a Color structure from the specified 8-bit color values (red, green, and blue). The alpha value is implicitly 255 (fully opaque). 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.

C#

public static System.Drawing.Color FromArgb(int red, int green, int blue);

Parameters

red

Int32

The red component value for the new Color. Valid values are 0 through 255.

green

Int32

The green component value for the new Color. Valid values are 0 through 255.

blue

Int32

The blue component value for the new Color. Valid values are 0 through 255.

Returns

Color

The Color that this method creates.

Exceptions

ArgumentException

red, green, or blue is less than 0 or greater than 255.

Examples

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. The code performs the following actions:

1. Creates Color structures from the three color component values (red, green, blue). Three Color structures are created, one for each primary color.

2. Iterates through a range of alpha values, changing the alpha value of a color.

3. During each iteration, sets the color of a brush to the modified color and paints a rectangle to show the color.

4. Repeats steps 2 and 3 for each primary color.

The alpha value is never fully opaque and the rectangles overlap so you get color-combination effects.

C#

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

FromArgb(Int32, Color)

Source:

Color.cs

Creates a Color structure from the specified Color structure, but with the new specified alpha value. Although this method allows a 32-bit value to be passed for the alpha value, the value is limited to 8 bits.

C#

public static System.Drawing.Color FromArgb(int alpha, System.Drawing.Color baseColor);

Parameters

alpha

Int32

The alpha value for the new Color. Valid values are 0 through 255.

baseColor

Color

The Color from which to create the new Color.

Returns

Color

The Color that this method creates.

Exceptions

ArgumentException

alpha is less than 0 or greater than 255.

Examples

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. The code performs the following actions:

1. Creates Color structures from the three color component values (red, green, blue). Three Color structures are created, one for each primary color.

2. Iterates through a range of alpha values, changing the alpha value of a color.

3. During each iteration, sets the color of a brush to the modified color and paints a rectangle to show the color.

4. Repeats steps 2 and 3 for each primary color.

The alpha value is never fully opaque and the rectangles overlap so you get color-combination effects.

C#

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

Remarks

To create an opaque color, set alpha to 255. To create a semitransparent color, set alpha to any value from 1 through 254.

FromArgb(Int32)

Source:

Color.cs

Creates a Color structure from a 32-bit ARGB value.

C#

public static System.Drawing.Color FromArgb(int argb);

Parameters

argb

Int32

A value specifying the 32-bit ARGB value.

Returns

Color

The Color structure that this method creates.

Examples

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. The code performs the following actions:

• Creates three brushes, each a different color. Each Color structure that is used to create a brush is created from a 32-bit ARGB value.

• Uses an imaginary triangle to position three circles.

• Paints three overlapping circles, each centered on one vertex of the triangle, using a different brush for each circle.

C#

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

Remarks

The byte-ordering of the 32-bit ARGB value is AARRGGBB. The most significant byte (MSB), represented by AA, is the alpha component value. The second, third, and fourth bytes, represented by RR, GG, and BB, respectively, are the color components red, green, and blue, respectively.