using System;
using System.Runtime.InteropServices;
namespace Vanara.PInvoke
{
public static partial class Gdi32
{
/// The type of compression for a compressed bottom-up bitmap (top-down DIBs cannot be compressed). Used in .
[PInvokeData("Wingdi.h", MSDNShortId = "dd183376")]
public enum BitmapCompressionMode : uint
{
/// An uncompressed format.
BI_RGB = 0,
///
/// A run-length encoded (RLE) format for bitmaps with 8 bpp. The compression format is a 2-byte format consisting of a count byte followed by a byte
/// containing a color index.
///
BI_RLE8 = 1,
///
/// An RLE format for bitmaps with 4 bpp. The compression format is a 2-byte format consisting of a count byte followed by two word-length color indexes.
///
BI_RLE4 = 2,
///
/// Specifies that the bitmap is not compressed and that the color table consists of three DWORD color masks that specify the red, green, and blue
/// components, respectively, of each pixel. This is valid when used with 16- and 32-bpp bitmaps.
///
BI_BITFIELDS = 3,
/// Indicates that the image is a JPEG image.
BI_JPEG = 4,
/// Indicates that the image is a PNG image.
BI_PNG = 5
}
[PInvokeData("Wingdi.h", MSDNShortId = "dd183494")]
public enum DIBColorMode : int
{
/// The BITMAPINFO structure contains an array of literal RGB values.
DIB_RGB_COLORS = 0,
///
/// The bmiColors member of the BITMAPINFO structure is an array of 16-bit indexes into the logical palette of the device context specified by hdc.
///
DIB_PAL_COLORS = 1
}
///
/// The CreateDIBSection function creates a DIB that applications can write to directly. The function gives you a pointer to the location of the bitmap
/// bit values. You can supply a handle to a file-mapping object that the function will use to create the bitmap, or you can let the system allocate the
/// memory for the bitmap.
///
///
/// A handle to a device context. If the value of iUsage is DIB_PAL_COLORS, the function uses this device context's logical palette to initialize the DIB colors.
///
/// A pointer to a BITMAPINFO structure that specifies various attributes of the DIB, including the bitmap dimensions and colors.
///
/// The type of data contained in the bmiColors array member of the BITMAPINFO structure pointed to by pbmi (either logical palette indexes or literal
/// RGB values).
///
/// A pointer to a variable that receives a pointer to the location of the DIB bit values.
///
/// A handle to a file-mapping object that the function will use to create the DIB. This parameter can be NULL.
///
/// If hSection is not NULL, it must be a handle to a file-mapping object created by calling the CreateFileMapping function with the PAGE_READWRITE or
/// PAGE_WRITECOPY flag. Read-only DIB sections are not supported. Handles created by other means will cause CreateDIBSection to fail.
///
///
/// If hSection is not NULL, the CreateDIBSection function locates the bitmap bit values at offset dwOffset in the file-mapping object referred to by
/// hSection. An application can later retrieve the hSection handle by calling the GetObject function with the HBITMAP returned by CreateDIBSection.
///
///
/// If hSection is NULL, the system allocates memory for the DIB. In this case, the CreateDIBSection function ignores the dwOffset parameter. An
/// application cannot later obtain a handle to this memory. The dshSection member of the DIBSECTION structure filled in by calling the GetObject
/// function will be NULL.
///
///
///
/// The offset from the beginning of the file-mapping object referenced by hSection where storage for the bitmap bit values is to begin. This value is
/// ignored if hSection is NULL. The bitmap bit values are aligned on doubleword boundaries, so dwOffset must be a multiple of the size of a DWORD.
///
///
/// If the function succeeds, the return value is a handle to the newly created DIB, and *ppvBits points to the bitmap bit values.
/// If the function fails, the return value is NULL, and *ppvBits is NULL.
///
///
/// As noted above, if hSection is NULL, the system allocates memory for the DIB. The system closes the handle to that memory when you later delete the
/// DIB by calling the DeleteObject function. If hSection is not NULL, you must close the hSection memory handle yourself after calling DeleteObject to
/// delete the bitmap.
/// You cannot paste a DIB section from one application into another application.
///
/// CreateDIBSection does not use the BITMAPINFOHEADER parameters biXPelsPerMeter or biYPelsPerMeter and will not provide resolution information in the
/// BITMAPINFO structure.
///
///
/// You need to guarantee that the GDI subsystem has completed any drawing to a bitmap created by CreateDIBSection before you draw to the bitmap
/// yourself. Access to the bitmap must be synchronized. Do this by calling the GdiFlush function. This applies to any use of the pointer to the bitmap
/// bit values, including passing the pointer in calls to functions such as SetDIBits.
///
/// ICM: No color management is done.
///
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
[PInvokeData("Wingdi.h", MSDNShortId = "dd183494")]
public static extern SafeHBITMAP CreateDIBSection(HDC hdc, ref BITMAPINFO pbmi, DIBColorMode iUsage, out IntPtr ppvBits, IntPtr hSection, int dwOffset);
///
/// The GetDIBits function retrieves the bits of the specified compatible bitmap and copies them into a buffer as a DIB using the specified format.
///
/// A handle to the device context.
/// A handle to the bitmap. This must be a compatible bitmap (DDB).
/// The first scan line to retrieve.
/// The number of scan lines to retrieve.
///
/// A pointer to a buffer to receive the bitmap data. If this parameter is NULL, the function passes the dimensions and format of the bitmap to the
/// BITMAPINFO structure pointed to by the lpbi parameter.
///
/// A pointer to a BITMAPINFO structure that specifies the desired format for the DIB data.
/// The format of the bmiColors member of the BITMAPINFO structure.
///
/// If the lpvBits parameter is non-NULL and the function succeeds, the return value is the number of scan lines copied from the bitmap.
/// If the lpvBits parameter is NULL and GetDIBits successfully fills the BITMAPINFO structure, the return value is nonzero.
/// If the function fails, the return value is zero.
///
///
/// If the requested format for the DIB matches its internal format, the RGB values for the bitmap are copied. If the requested format doesn't match the
/// internal format, a color table is synthesized. The following table describes the color table synthesized for each format.
///
///
/// Value
/// Meaning
///
/// -
/// 1_BPP
/// The color table consists of a black and a white entry.
///
/// -
/// 4_BPP
/// The color table consists of a mix of colors identical to the standard VGA palette.
///
/// -
/// 8_BPP
///
/// The color table consists of a general mix of 256 colors defined by GDI. (Included in these 256 colors are the 20 colors found in the default logical palette.)
///
///
/// -
/// 24_BPP
/// No color table is returned.
///
///
///
/// If the lpvBits parameter is a valid pointer, the first six members of the BITMAPINFOHEADER structure must be initialized to specify the size and
/// format of the DIB. The scan lines must be aligned on a DWORD except for RLE compressed bitmaps.
///
///
/// A bottom-up DIB is specified by setting the height to a positive number, while a top-down DIB is specified by setting the height to a negative
/// number. The bitmap color table will be appended to the BITMAPINFO structure.
///
///
/// If lpvBits is NULL, GetDIBits examines the first member of the first structure pointed to by lpbi. This member must specify the size, in bytes, of a
/// BITMAPCOREHEADER or a BITMAPINFOHEADER structure. The function uses the specified size to determine how the remaining members should be initialized.
///
///
/// If lpvBits is NULL and the bit count member of BITMAPINFO is initialized to zero, GetDIBits fills in a BITMAPINFOHEADER structure or BITMAPCOREHEADER
/// without the color table. This technique can be used to query bitmap attributes.
///
/// The bitmap identified by the hbmp parameter must not be selected into a device context when the application calls this function.
/// The origin for a bottom-up DIB is the lower-left corner of the bitmap; the origin for a top-down DIB is the upper-left corner.
///
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
[PInvokeData("Wingdi.h", MSDNShortId = "dd144879")]
public static extern int GetDIBits(HDC hdc, HBITMAP hbmp, int uStartScan, int cScanLines, ref byte[] lpvBits, ref BITMAPINFO lpbi, DIBColorMode uUsage);
///
/// The GetDIBits function retrieves the bits of the specified compatible bitmap and copies them into a buffer as a DIB using the specified format.
///
/// A handle to the device context.
/// A handle to the bitmap. This must be a compatible bitmap (DDB).
/// The first scan line to retrieve.
/// The number of scan lines to retrieve.
///
/// A pointer to a buffer to receive the bitmap data. If this parameter is NULL, the function passes the dimensions and format of the bitmap to the
/// BITMAPINFO structure pointed to by the lpbi parameter.
///
/// A pointer to a BITMAPINFO structure that specifies the desired format for the DIB data.
/// The format of the bmiColors member of the BITMAPINFO structure.
///
/// If the lpvBits parameter is non-NULL and the function succeeds, the return value is the number of scan lines copied from the bitmap.
/// If the lpvBits parameter is NULL and GetDIBits successfully fills the BITMAPINFO structure, the return value is nonzero.
/// If the function fails, the return value is zero.
///
///
/// If the requested format for the DIB matches its internal format, the RGB values for the bitmap are copied. If the requested format doesn't match the
/// internal format, a color table is synthesized. The following table describes the color table synthesized for each format.
///
///
/// Value
/// Meaning
///
/// -
/// 1_BPP
/// The color table consists of a black and a white entry.
///
/// -
/// 4_BPP
/// The color table consists of a mix of colors identical to the standard VGA palette.
///
/// -
/// 8_BPP
///
/// The color table consists of a general mix of 256 colors defined by GDI. (Included in these 256 colors are the 20 colors found in the default logical palette.)
///
///
/// -
/// 24_BPP
/// No color table is returned.
///
///
///
/// If the lpvBits parameter is a valid pointer, the first six members of the BITMAPINFOHEADER structure must be initialized to specify the size and
/// format of the DIB. The scan lines must be aligned on a DWORD except for RLE compressed bitmaps.
///
///
/// A bottom-up DIB is specified by setting the height to a positive number, while a top-down DIB is specified by setting the height to a negative
/// number. The bitmap color table will be appended to the BITMAPINFO structure.
///
///
/// If lpvBits is NULL, GetDIBits examines the first member of the first structure pointed to by lpbi. This member must specify the size, in bytes, of a
/// BITMAPCOREHEADER or a BITMAPINFOHEADER structure. The function uses the specified size to determine how the remaining members should be initialized.
///
///
/// If lpvBits is NULL and the bit count member of BITMAPINFO is initialized to zero, GetDIBits fills in a BITMAPINFOHEADER structure or BITMAPCOREHEADER
/// without the color table. This technique can be used to query bitmap attributes.
///
/// The bitmap identified by the hbmp parameter must not be selected into a device context when the application calls this function.
/// The origin for a bottom-up DIB is the lower-left corner of the bitmap; the origin for a top-down DIB is the upper-left corner.
///
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
[PInvokeData("Wingdi.h", MSDNShortId = "dd144879")]
public static extern int GetDIBits(HDC hdc, HBITMAP hbmp, int uStartScan, int cScanLines, IntPtr lpvBits, ref BITMAPINFO lpbi, DIBColorMode uUsage);
/// The BITMAP structure defines the type, width, height, color format, and bit values of a bitmap.
[StructLayout(LayoutKind.Sequential)]
[PInvokeData("Wingdi.h", MSDNShortId = "dd183371")]
public struct BITMAP
{
/// The bitmap type. This member must be zero.
public int bmType;
/// The width, in pixels, of the bitmap. The width must be greater than zero.
public int bmWidth;
/// The height, in pixels, of the bitmap. The height must be greater than zero.
public int bmHeight;
///
/// The number of bytes in each scan line. This value must be divisible by 2, because the system assumes that the bit values of a bitmap form an
/// array that is word aligned.
///
public int bmWidthBytes;
/// The count of color planes.
public ushort bmPlanes;
/// The number of bits required to indicate the color of a pixel.
public ushort bmBitsPixel;
///
/// A pointer to the location of the bit values for the bitmap. The bmBits member must be a pointer to an array of character (1-byte) values.
///
public IntPtr bmBits;
}
/// The BITMAPINFO structure defines the dimensions and color information for a DIB.
///
/// A DIB consists of two distinct parts: a BITMAPINFO structure describing the dimensions and colors of the bitmap, and an array of bytes defining the
/// pixels of the bitmap. The bits in the array are packed together, but each scan line must be padded with zeros to end on a LONG data-type boundary. If
/// the height of the bitmap is positive, the bitmap is a bottom-up DIB and its origin is the lower-left corner. If the height is negative, the bitmap is
/// a top-down DIB and its origin is the upper left corner.
///
/// A bitmap is packed when the bitmap array immediately follows the BITMAPINFO header. Packed bitmaps are referenced by a single pointer. For packed
/// bitmaps, the biClrUsed member must be set to an even number when using the DIB_PAL_COLORS mode so that the DIB bitmap array starts on a DWORD boundary.
///
/// Note
/// The bmiColors member should not contain palette indexes if the bitmap is to be stored in a file or transferred to another application.
/// Unless the application has exclusive use and control of the bitmap, the bitmap color table should contain explicit RGB values.
///
[StructLayout(LayoutKind.Sequential)]
[PInvokeData("Wingdi.h", MSDNShortId = "dd183375")]
public struct BITMAPINFO
{
/// A BITMAPINFOHEADER structure that contains information about the dimensions of color format.
public BITMAPINFOHEADER bmiHeader;
///
/// The bmiColors member contains one of the following:
///
/// -
/// An array of RGBQUAD. The elements of the array that make up the color table.
///
/// -
///
/// An array of 16-bit unsigned integers that specifies indexes into the currently realized logical palette. This use of bmiColors is allowed for
/// functions that use DIBs. When bmiColors elements contain indexes to a realized logical palette, they must also call the following bitmap
/// functions: CreateDIBitmap, CreateDIBPatternBrush, CreateDIBSection (The iUsage parameter of CreateDIBSection must be set to DIB_PAL_COLORS.)
///
///
///
/// The number of entries in the array depends on the values of the biBitCount and biClrUsed members of the BITMAPINFOHEADER structure.
/// The colors in the bmiColors table appear in order of importance. For more information, see the Remarks section.
///
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1, ArraySubType = UnmanagedType.Struct)]
public RGBQUAD[] bmiColors;
/// Initializes a new instance of the structure.
/// The width.
/// The height.
/// The bit count.
public BITMAPINFO(int width, int height, ushort bitCount = 32)
: this()
{
bmiHeader.biSize = Marshal.SizeOf(typeof(BITMAPINFO));
bmiHeader.biWidth = width;
bmiHeader.biHeight = height;
bmiHeader.biPlanes = 1;
bmiHeader.biBitCount = bitCount;
bmiHeader.biCompression = BitmapCompressionMode.BI_RGB;
bmiHeader.biSizeImage = 0; // (uint)width * (uint)height * bitCount / 8;
}
}
/// The BITMAPINFOHEADER structure contains information about the dimensions and color format of a DIB.
[StructLayout(LayoutKind.Sequential)]
[PInvokeData("Wingdi.h", MSDNShortId = "dd183376")]
public struct BITMAPINFOHEADER
{
/// The number of bytes required by the structure.
public int biSize;
///
/// The width of the bitmap, in pixels. If biCompression is BI_JPEG or BI_PNG, the biWidth member specifies the width of the decompressed JPEG or PNG
/// image file, respectively.
///
public int biWidth;
///
/// The height of the bitmap, in pixels. If biHeight is positive, the bitmap is a bottom-up DIB and its origin is the lower-left corner. If biHeight
/// is negative, the bitmap is a top-down DIB and its origin is the upper-left corner.
/// If biHeight is negative, indicating a top-down DIB, biCompression must be either BI_RGB or BI_BITFIELDS. Top-down DIBs cannot be compressed.
/// If biCompression is BI_JPEG or BI_PNG, the biHeight member specifies the height of the decompressed JPEG or PNG image file, respectively.
///
public int biHeight;
/// The number of planes for the target device. This value must be set to 1.
public ushort biPlanes;
///
/// The number of bits-per-pixel. The biBitCount member of the BITMAPINFOHEADER structure determines the number of bits that define each pixel and
/// the maximum number of colors in the bitmap. This member must be one of the following values.
///
///
/// Value
/// Meaning
///
/// -
/// 0
/// The number of bits-per-pixel is specified or is implied by the JPEG or PNG format.
///
/// -
/// 1
///
/// The bitmap is monochrome, and the bmiColors member of BITMAPINFO contains two entries. Each bit in the bitmap array represents a pixel. If the
/// bit is clear, the pixel is displayed with the color of the first entry in the bmiColors table; if the bit is set, the pixel has the color of the
/// second entry in the table.
///
///
/// -
/// 4
///
/// The bitmap has a maximum of 16 colors, and the bmiColors member of BITMAPINFO contains up to 16 entries. Each pixel in the bitmap is represented
/// by a 4-bit index into the color table. For example, if the first byte in the bitmap is 0x1F, the byte represents two pixels. The first pixel
/// contains the color in the second table entry, and the second pixel contains the color in the sixteenth table entry.
///
///
/// -
/// 8
///
/// The bitmap has a maximum of 256 colors, and the bmiColors member of BITMAPINFO contains up to 256 entries. In this case, each byte in the array
/// represents a single pixel.
///
///
/// -
/// 16
///
/// The bitmap has a maximum of 2^16 colors. If the biCompression member of the BITMAPINFOHEADER is BI_RGB, the bmiColors member of BITMAPINFO is
/// NULL. Each WORD in the bitmap array represents a single pixel. The relative intensities of red, green, and blue are represented with five bits
/// for each color component. The value for blue is in the least significant five bits, followed by five bits each for green and red. The most
/// significant bit is not used. The bmiColors color table is used for optimizing colors used on palette-based devices, and must contain the number
/// of entries specified by the biClrUsed member of the BITMAPINFOHEADER.
///
/// If the biCompression member of the BITMAPINFOHEADER is BI_BITFIELDS, the bmiColors member contains three DWORD color masks that specify the red,
/// green, and blue components, respectively, of each pixel. Each WORD in the bitmap array represents a single pixel.
///
///
/// When the biCompression member is BI_BITFIELDS, bits set in each DWORD mask must be contiguous and should not overlap the bits of another mask.
/// All the bits in the pixel do not have to be used.
///
///
///
/// -
/// 24
///
/// The bitmap has a maximum of 2^24 colors, and the bmiColors member of BITMAPINFO is NULL. Each 3-byte triplet in the bitmap array represents the
/// relative intensities of blue, green, and red, respectively, for a pixel. The bmiColors color table is used for optimizing colors used on
/// palette-based devices, and must contain the number of entries specified by the biClrUsed member of the BITMAPINFOHEADER.
///
///
/// -
/// 32
///
/// The bitmap has a maximum of 2^32 colors. If the biCompression member of the BITMAPINFOHEADER is BI_RGB, the bmiColors member of BITMAPINFO is
/// NULL. Each DWORD in the bitmap array represents the relative intensities of blue, green, and red for a pixel. The value for blue is in the least
/// significant 8 bits, followed by 8 bits each for green and red. The high byte in each DWORD is not used. The bmiColors color table is used for
/// optimizing colors used on palette-based devices, and must contain the number of entries specified by the biClrUsed member of the BITMAPINFOHEADER.
///
/// If the biCompression member of the BITMAPINFOHEADER is BI_BITFIELDS, the bmiColors member contains three DWORD color masks that specify the red,
/// green, and blue components, respectively, of each pixel. Each DWORD in the bitmap array represents a single pixel.
///
///
/// When the biCompression member is BI_BITFIELDS, bits set in each DWORD mask must be contiguous and should not overlap the bits of another mask.
/// All the bits in the pixel do not need to be used.
///
///
///
///
///
public ushort biBitCount;
/// The type of compression for a compressed bottom-up bitmap (top-down DIBs cannot be compressed).
public BitmapCompressionMode biCompression;
///
/// The size, in bytes, of the image. This may be set to zero for BI_RGB bitmaps. If biCompression is BI_JPEG or BI_PNG, biSizeImage indicates the
/// size of the JPEG or PNG image buffer, respectively.
///
public uint biSizeImage;
///
/// The horizontal resolution, in pixels-per-meter, of the target device for the bitmap. An application can use this value to select a bitmap from a
/// resource group that best matches the characteristics of the current device.
///
public int biXPelsPerMeter;
/// The vertical resolution, in pixels-per-meter, of the target device for the bitmap.
public int biYPelsPerMeter;
///
/// The number of color indexes in the color table that are actually used by the bitmap. If this value is zero, the bitmap uses the maximum number of
/// colors corresponding to the value of the biBitCount member for the compression mode specified by biCompression.
///
/// If biClrUsed is nonzero and the biBitCount member is less than 16, the biClrUsed member specifies the actual number of colors the graphics engine
/// or device driver accesses. If biBitCount is 16 or greater, the biClrUsed member specifies the size of the color table used to optimize
/// performance of the system color palettes. If biBitCount equals 16 or 32, the optimal color palette starts immediately following the three DWORD masks.
///
///
/// When the bitmap array immediately follows the BITMAPINFO structure, it is a packed bitmap. Packed bitmaps are referenced by a single pointer.
/// Packed bitmaps require that the biClrUsed member must be either zero or the actual size of the color table.
///
///
public uint biClrUsed;
/// The number of color indexes that are required for displaying the bitmap. If this value is zero, all colors are required.
public uint biClrImportant;
}
///
/// The DIBSECTION structure contains information about a DIB created by calling the CreateDIBSection function. A DIBSECTION structure includes
/// information about the bitmap's dimensions, color format, color masks, optional file mapping object, and optional bit values storage offset. An
/// application can obtain a filled-in DIBSECTION structure for a given DIB by calling the GetObject function.
///
[StructLayout(LayoutKind.Sequential)]
[PInvokeData("Wingdi.h", MSDNShortId = "dd183567")]
public struct DIBSECTION
{
///
/// A BITMAP data structure that contains information about the DIB: its type, its dimensions, its color capacities, and a pointer to its bit values.
///
public BITMAP dsBm;
/// A BITMAPINFOHEADER structure that contains information about the color format of the DIB.
public BITMAPINFOHEADER dsBmih;
private uint dsBitField1;
private uint dsBitField2;
private uint dsBitField3;
///
/// The DSH sectionContains a handle to the file mapping object that the CreateDIBSection function used to create the DIB. If CreateDIBSection was
/// called with a NULL value for its hSection parameter, causing the system to allocate memory for the bitmap, the dshSection member will be NULL.
///
public IntPtr dshSection;
///
/// The offset to the bitmap's bit values within the file mapping object referenced by dshSection. If dshSection is NULL, the dsOffset value has no meaning.
///
public uint dsOffset;
///
/// Specifies three color masks for the DIB. This field is only valid when the BitCount member of the BITMAPINFOHEADER structure has a value greater
/// than 8. Each color mask indicates the bits that are used to encode one of the three color channels (red, green, and blue).
///
public uint[] dsBitFields
{
get => new[] { dsBitField1, dsBitField2, dsBitField3 };
set { dsBitField1 = value[0]; dsBitField2 = value[1]; dsBitField3 = value[2]; }
}
}
/// The RGBQUAD structure describes a color consisting of relative intensities of red, green, and blue.
[StructLayout(LayoutKind.Sequential)]
[PInvokeData("Wingdi.h", MSDNShortId = "dd162938")]
public struct RGBQUAD
{
/// The intensity of blue in the color.
public byte rgbBlue;
/// The intensity of green in the color.
public byte rgbGreen;
/// The intensity of red in the color.
public byte rgbRed;
/// This member is reserved and must be zero.
public byte rgbReserved;
/// Gets or sets the color associated with the structure.
/// The color.
public System.Drawing.Color Color
{
get => System.Drawing.Color.FromArgb(rgbReserved, rgbRed, rgbGreen, rgbBlue);
set { rgbReserved = value.A; rgbBlue = value.B; rgbGreen = value.G; rgbRed = value.R; }
}
/// Performs an implicit conversion from to .
/// The c.
/// The result of the conversion.
public static implicit operator RGBQUAD(System.Drawing.Color c) => new RGBQUAD() { Color = c };
/// Performs an implicit conversion from to .
/// The c.
/// The result of the conversion.
public static implicit operator System.Drawing.Color(RGBQUAD c) => c.Color;
}
}
}