mirror of https://github.com/dahall/Vanara.git
911 lines
43 KiB
C#
911 lines
43 KiB
C#
using System;
|
|
using System.Drawing;
|
|
using System.Runtime.InteropServices;
|
|
using Vanara.InteropServices;
|
|
|
|
namespace Vanara.PInvoke
|
|
{
|
|
public static partial class Gdi32
|
|
{
|
|
[PInvokeData("Wingdi.h")]
|
|
public const int LF_FACESIZE = 32;
|
|
|
|
/// <summary>The background mode used by the <see cref="SetBkMode"/> function.</summary>
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd162965")]
|
|
public enum BackgroundMode
|
|
{
|
|
/// <summary>Indicates that on return, the <see cref="SetBkMode"/> has failed.</summary>
|
|
ERROR = 0,
|
|
|
|
/// <summary>Background remains untouched.</summary>
|
|
TRANSPARENT = 1,
|
|
|
|
/// <summary>Background is filled with the current background color before the text, hatched brush, or pen is drawn.</summary>
|
|
OPAQUE = 2,
|
|
}
|
|
|
|
/// <summary>Brush style used by <see cref="LOGBRUSH.lbStyle"/>.</summary>
|
|
[PInvokeData("wingdi.h", MSDNShortId = "ded2c7a4-2248-4d01-95c6-ab4050719094")]
|
|
public enum BrushStyle : uint
|
|
{
|
|
/// <summary>
|
|
/// A pattern brush defined by a device-independent bitmap (DIB) specification. If lbStyle is BS_DIBPATTERN, the lbHatch member
|
|
/// contains a handle to a packed DIB. For more information, see discussion in lbHatch.
|
|
/// </summary>
|
|
BS_DIBPATTERN = 5,
|
|
|
|
/// <summary>See BS_DIBPATTERN.</summary>
|
|
BS_DIBPATTERN8X8 = 8,
|
|
|
|
/// <summary>
|
|
/// A pattern brush defined by a device-independent bitmap (DIB) specification. If lbStyle is BS_DIBPATTERNPT, the lbHatch member
|
|
/// contains a pointer to a packed DIB. For more information, see discussion in lbHatch.
|
|
/// </summary>
|
|
BS_DIBPATTERNPT = 6,
|
|
|
|
/// <summary>Hatched brush.</summary>
|
|
BS_HATCHED = 2,
|
|
|
|
/// <summary>Hollow brush.</summary>
|
|
BS_HOLLOW = 1,
|
|
|
|
/// <summary>Not supported.</summary>
|
|
BS_INDEXED = 4,
|
|
|
|
/// <summary>Not supported.</summary>
|
|
BS_MONOPATTERN = 9,
|
|
|
|
/// <summary>Same as BS_HOLLOW.</summary>
|
|
BS_NULL = 1,
|
|
|
|
/// <summary>Pattern brush defined by a memory bitmap.</summary>
|
|
BS_PATTERN = 3,
|
|
|
|
/// <summary>See BS_PATTERN.</summary>
|
|
BS_PATTERN8X8 = 7,
|
|
|
|
/// <summary>Solid brush.</summary>
|
|
BS_SOLID = 0
|
|
}
|
|
|
|
/// <summary>The DC layout used by the <see cref="SetLayout"/> function.</summary>
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd162979")]
|
|
public enum DCLayout
|
|
{
|
|
/// <summary>Indicates that on return, the <see cref="SetLayout"/> has failed.</summary>
|
|
GDI_ERROR = -1,
|
|
|
|
/// <summary>Sets the default horizontal layout to be right to left.</summary>
|
|
LAYOUT_RTL = 1,
|
|
|
|
/// <summary>Sets the default horizontal layout to be bottom to top.</summary>
|
|
LAYOUT_BTT = 2,
|
|
|
|
/// <summary>Sets the default horizontal layout to be vertical before horizontal.</summary>
|
|
LAYOUT_VBH = 4,
|
|
|
|
/// <summary>Disables any reflection during BitBlt and StretchBlt operations.</summary>
|
|
LAYOUT_BITMAPORIENTATIONPRESERVED = 8,
|
|
}
|
|
|
|
/// <summary>Values used by the <see cref="GetDeviceCaps"/> function.</summary>
|
|
public enum DeviceCap
|
|
{
|
|
/// <summary>Device driver version</summary>
|
|
DRIVERVERSION = 0,
|
|
|
|
/// <summary>Device classification</summary>
|
|
TECHNOLOGY = 2,
|
|
|
|
/// <summary>Horizontal size in millimeters</summary>
|
|
HORZSIZE = 4,
|
|
|
|
/// <summary>Vertical size in millimeters</summary>
|
|
VERTSIZE = 6,
|
|
|
|
/// <summary>Horizontal width in pixels</summary>
|
|
HORZRES = 8,
|
|
|
|
/// <summary>Vertical height in pixels</summary>
|
|
VERTRES = 10,
|
|
|
|
/// <summary>Number of bits per pixel</summary>
|
|
BITSPIXEL = 12,
|
|
|
|
/// <summary>Number of planes</summary>
|
|
PLANES = 14,
|
|
|
|
/// <summary>Number of brushes the device has</summary>
|
|
NUMBRUSHES = 16,
|
|
|
|
/// <summary>Number of pens the device has</summary>
|
|
NUMPENS = 18,
|
|
|
|
/// <summary>Number of markers the device has</summary>
|
|
NUMMARKERS = 20,
|
|
|
|
/// <summary>Number of fonts the device has</summary>
|
|
NUMFONTS = 22,
|
|
|
|
/// <summary>Number of colors the device supports</summary>
|
|
NUMCOLORS = 24,
|
|
|
|
/// <summary>Size required for device descriptor</summary>
|
|
PDEVICESIZE = 26,
|
|
|
|
/// <summary>Curve capabilities</summary>
|
|
CURVECAPS = 28,
|
|
|
|
/// <summary>Line capabilities</summary>
|
|
LINECAPS = 30,
|
|
|
|
/// <summary>Polygonal capabilities</summary>
|
|
POLYGONALCAPS = 32,
|
|
|
|
/// <summary>Text capabilities</summary>
|
|
TEXTCAPS = 34,
|
|
|
|
/// <summary>Clipping capabilities</summary>
|
|
CLIPCAPS = 36,
|
|
|
|
/// <summary>Bitblt capabilities</summary>
|
|
RASTERCAPS = 38,
|
|
|
|
/// <summary>Length of the X leg</summary>
|
|
ASPECTX = 40,
|
|
|
|
/// <summary>Length of the Y leg</summary>
|
|
ASPECTY = 42,
|
|
|
|
/// <summary>Length of the hypotenuse</summary>
|
|
ASPECTXY = 44,
|
|
|
|
/// <summary>Shading and Blending caps</summary>
|
|
SHADEBLENDCAPS = 45,
|
|
|
|
/// <summary>Logical pixels inch in X</summary>
|
|
LOGPIXELSX = 88,
|
|
|
|
/// <summary>Logical pixels inch in Y</summary>
|
|
LOGPIXELSY = 90,
|
|
|
|
/// <summary>Number of entries in physical palette</summary>
|
|
SIZEPALETTE = 104,
|
|
|
|
/// <summary>Number of reserved entries in palette</summary>
|
|
NUMRESERVED = 106,
|
|
|
|
/// <summary>Actual color resolution</summary>
|
|
COLORRES = 108,
|
|
|
|
// Printing related DeviceCaps. These replace the appropriate Escapes
|
|
/// <summary>Physical Width in device units</summary>
|
|
PHYSICALWIDTH = 110,
|
|
|
|
/// <summary>Physical Height in device units</summary>
|
|
PHYSICALHEIGHT = 111,
|
|
|
|
/// <summary>Physical Printable Area x margin</summary>
|
|
PHYSICALOFFSETX = 112,
|
|
|
|
/// <summary>Physical Printable Area y margin</summary>
|
|
PHYSICALOFFSETY = 113,
|
|
|
|
/// <summary>Scaling factor x</summary>
|
|
SCALINGFACTORX = 114,
|
|
|
|
/// <summary>Scaling factor y</summary>
|
|
SCALINGFACTORY = 115,
|
|
|
|
/// <summary>Current vertical refresh rate of the display device (for displays only) in Hz</summary>
|
|
VREFRESH = 116,
|
|
|
|
/// <summary>Vertical height of entire desktop in pixels</summary>
|
|
DESKTOPVERTRES = 117,
|
|
|
|
/// <summary>Horizontal width of entire desktop in pixels</summary>
|
|
DESKTOPHORZRES = 118,
|
|
|
|
/// <summary>Preferred blt alignment</summary>
|
|
BLTALIGNMENT = 119
|
|
}
|
|
|
|
/// <summary>Device state flags.</summary>
|
|
[PInvokeData("wingdi.h", MSDNShortId = "9a7813fe-358a-44eb-99da-c63f98d055c3")]
|
|
[Flags]
|
|
public enum DISPLAY_DEVICE_FLAGS
|
|
{
|
|
/// <summary>
|
|
/// The DISPLAY_DEVICE_ACTIVE specifies whether a monitor is presented as being "on" by the respective GDI view. Windows Vista:
|
|
/// EnumDisplayDevices will only enumerate monitors that can be presented as being "on."
|
|
/// </summary>
|
|
DISPLAY_DEVICE_ACTIVE = 0x00000001,
|
|
|
|
/// <summary>The display device is attached.</summary>
|
|
DISPLAY_DEVICE_ATTACHED = 0x00000002,
|
|
|
|
/// <summary>The display device attached to desktop</summary>
|
|
DISPLAY_DEVICE_ATTACHED_TO_DESKTOP = 0x00000001,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
DISPLAY_DEVICE_MULTI_DRIVER = 0x00000002,
|
|
|
|
/// <summary>
|
|
/// The primary desktop is on the device. For a system with a single display card, this is always set. For a system with multiple
|
|
/// display cards, only one device can have this set.
|
|
/// </summary>
|
|
DISPLAY_DEVICE_PRIMARY_DEVICE = 0x00000004,
|
|
|
|
/// <summary>
|
|
/// Represents a pseudo device used to mirror application drawing for remoting or other purposes. An invisible pseudo monitor is
|
|
/// associated with this device. For example, NetMeeting uses it. Note that GetSystemMetrics (SM_MONITORS) only accounts for
|
|
/// visible display monitors.
|
|
/// </summary>
|
|
DISPLAY_DEVICE_MIRRORING_DRIVER = 0x00000008,
|
|
|
|
/// <summary>The device is VGA compatible.</summary>
|
|
DISPLAY_DEVICE_VGA_COMPATIBLE = 0x00000010,
|
|
|
|
/// <summary>The device is removable; it cannot be the primary display.</summary>
|
|
DISPLAY_DEVICE_REMOVABLE = 0x00000020,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
DISPLAY_DEVICE_ACC_DRIVER = 0x00000040,
|
|
|
|
/// <summary>The device has more display modes than its output devices support.</summary>
|
|
DISPLAY_DEVICE_MODESPRUNED = 0x08000000,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
DISPLAY_DEVICE_RDPUDD = 0x01000000,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
DISPLAY_DEVICE_REMOTE = 0x04000000,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
DISPLAY_DEVICE_DISCONNECT = 0x02000000,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
DISPLAY_DEVICE_TS_COMPATIBLE = 0x00200000,
|
|
|
|
/// <summary>Undocumented.</summary>
|
|
DISPLAY_DEVICE_UNSAFE_MODES_ON = 0x00080000,
|
|
}
|
|
|
|
/// <summary>Hatch style used by <see cref="LOGBRUSH.lbHatchStyle"/>.</summary>
|
|
[PInvokeData("wingdi.h", MSDNShortId = "ded2c7a4-2248-4d01-95c6-ab4050719094")]
|
|
public enum HatchStyle : uint
|
|
{
|
|
/// <summary>A 45-degree upward, left-to-right hatch</summary>
|
|
HS_BDIAGONAL = 3,
|
|
|
|
/// <summary>Horizontal and vertical cross-hatch</summary>
|
|
HS_CROSS = 4,
|
|
|
|
/// <summary>45-degree crosshatch</summary>
|
|
HS_DIAGCROSS = 5,
|
|
|
|
/// <summary>A 45-degree downward, left-to-right hatch</summary>
|
|
HS_FDIAGONAL = 2,
|
|
|
|
/// <summary>Horizontal hatch</summary>
|
|
HS_HORIZONTAL = 0,
|
|
|
|
/// <summary>Vertical hatch</summary>
|
|
HS_VERTICAL = 1
|
|
}
|
|
|
|
/// <summary>
|
|
/// Defines how the color data for the source rectangle is to be combined with the color data for the destination rectangle to
|
|
/// achieve the final color when using the <see cref="BitBlt"/> function.
|
|
/// </summary>
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd183370")]
|
|
public enum RasterOperationMode
|
|
{
|
|
/// <summary>Copies the source rectangle directly to the destination rectangle.</summary>
|
|
SRCCOPY = 0x00CC0020,
|
|
|
|
/// <summary>Combines the colors of the source and destination rectangles by using the Boolean OR operator.</summary>
|
|
SRCPAINT = 0x00EE0086,
|
|
|
|
/// <summary>Combines the colors of the source and destination rectangles by using the Boolean AND operator.</summary>
|
|
SRCAND = 0x008800C6,
|
|
|
|
/// <summary>Combines the colors of the source and destination rectangles by using the Boolean XOR operator.</summary>
|
|
SRCINVERT = 0x00660046,
|
|
|
|
/// <summary>
|
|
/// Combines the inverted colors of the destination rectangle with the colors of the source rectangle by using the Boolean AND operator.
|
|
/// </summary>
|
|
SRCERASE = 0x00440328,
|
|
|
|
/// <summary></summary>
|
|
NOTSRCCOPY = 0x00330008,
|
|
|
|
/// <summary>Copies the inverted source rectangle to the destination.</summary>
|
|
NOTSRCERASE = 0x001100A6,
|
|
|
|
/// <summary>
|
|
/// Merges the colors of the source rectangle with the brush currently selected in hdcDest, by using the Boolean AND operator.
|
|
/// </summary>
|
|
MERGECOPY = 0x00C000CA,
|
|
|
|
/// <summary>
|
|
/// Merges the colors of the inverted source rectangle with the colors of the destination rectangle by using the Boolean OR operator.
|
|
/// </summary>
|
|
MERGEPAINT = 0x00BB0226,
|
|
|
|
/// <summary>Copies the brush currently selected in hdcDest, into the destination bitmap.</summary>
|
|
PATCOPY = 0x00F00021,
|
|
|
|
/// <summary>
|
|
/// Combines the colors of the brush currently selected in hdcDest, with the colors of the inverted source rectangle by using the
|
|
/// Boolean OR operator. The result of this operation is combined with the colors of the destination rectangle by using the
|
|
/// Boolean OR operator.
|
|
/// </summary>
|
|
PATPAINT = 0x00FB0A09,
|
|
|
|
/// <summary>
|
|
/// Combines the colors of the brush currently selected in hdcDest, with the colors of the destination rectangle by using the
|
|
/// Boolean XOR operator.
|
|
/// </summary>
|
|
PATINVERT = 0x005A0049,
|
|
|
|
/// <summary>Inverts the destination rectangle.</summary>
|
|
DSTINVERT = 0x00550009,
|
|
|
|
/// <summary>
|
|
/// Fills the destination rectangle using the color associated with index 0 in the physical palette. (This color is black for the
|
|
/// default physical palette.)
|
|
/// </summary>
|
|
BLACKNESS = 0x00000042,
|
|
|
|
/// <summary>
|
|
/// Fills the destination rectangle using the color associated with index 1 in the physical palette. (This color is white for the
|
|
/// default physical palette.)
|
|
/// </summary>
|
|
WHITENESS = 0x00FF0062,
|
|
|
|
/// <summary>Prevents the bitmap from being mirrored.</summary>
|
|
NOMIRRORBITMAP = -2147483648,
|
|
|
|
/// <summary>
|
|
/// Includes any windows that are layered on top of your window in the resulting image.By default, the image only contains your
|
|
/// window.Note that this generally cannot be used for printing device contexts.
|
|
/// </summary>
|
|
CAPTUREBLT = 0x40000000
|
|
}
|
|
|
|
/// <summary>Flags used with region functions.</summary>
|
|
[PInvokeData("wingdi.h")]
|
|
public enum RegionFlags
|
|
{
|
|
/// <summary>An error occurred.</summary>
|
|
ERROR = 0,
|
|
|
|
/// <summary>Region is empty.</summary>
|
|
NULLREGION = 1,
|
|
|
|
/// <summary>Region is a single rectangle.</summary>
|
|
SIMPLEREGION = 2,
|
|
|
|
/// <summary>Region consists of more than one rectangle.</summary>
|
|
COMPLEXREGION = 3,
|
|
}
|
|
|
|
/// <summary>The AlphaBlend function displays bitmaps that have transparent or semitransparent pixels.</summary>
|
|
/// <param name="hdcDest">A handle to the destination device context.</param>
|
|
/// <param name="nXOriginDest">The x-coordinate, in logical units, of the upper-left corner of the destination rectangle.</param>
|
|
/// <param name="nYOriginDest">The y-coordinate, in logical units, of the upper-left corner of the destination rectangle.</param>
|
|
/// <param name="nWidthDest">The width, in logical units, of the destination rectangle.</param>
|
|
/// <param name="nHeightDest">The height, in logical units, of the destination rectangle.</param>
|
|
/// <param name="hdcSrc">A handle to the source device context.</param>
|
|
/// <param name="nXOriginSrc">The x-coordinate, in logical units, of the upper-left corner of the source rectangle.</param>
|
|
/// <param name="nYOriginSrc">The y-coordinate, in logical units, of the upper-left corner of the source rectangle.</param>
|
|
/// <param name="nWidthSrc">The width, in logical units, of the source rectangle.</param>
|
|
/// <param name="nHeightSrc">The height, in logical units, of the source rectangle.</param>
|
|
/// <param name="blendFunction">
|
|
/// The alpha-blending function for source and destination bitmaps, a global alpha value to be applied to the entire source bitmap,
|
|
/// and format information for the source bitmap. The source and destination blend functions are currently limited to AC_SRC_OVER.
|
|
/// </param>
|
|
/// <returns>If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE.</returns>
|
|
/// <remarks>
|
|
/// If the source rectangle and destination rectangle are not the same size, the source bitmap is stretched to match the destination
|
|
/// rectangle. If the SetStretchBltMode function is used, the iStretchMode value is automatically converted to COLORONCOLOR for this
|
|
/// function (that is, BLACKONWHITE, WHITEONBLACK, and HALFTONE are changed to COLORONCOLOR).
|
|
/// <para>
|
|
/// The destination coordinates are transformed by using the transformation currently specified for the destination device context.
|
|
/// The source coordinates are transformed by using the transformation currently specified for the source device context.
|
|
/// </para>
|
|
/// <para>An error occurs (and the function returns FALSE) if the source device context identifies an enhanced metafile device context.</para>
|
|
/// <para>
|
|
/// If destination and source bitmaps do not have the same color format, AlphaBlend converts the source bitmap to match the
|
|
/// destination bitmap.
|
|
/// </para>
|
|
/// <para>
|
|
/// AlphaBlend does not support mirroring. If either the width or height of the source or destination is negative, this call will fail.
|
|
/// </para>
|
|
/// <para>
|
|
/// When rendering to a printer, first call GetDeviceCaps with SHADEBLENDCAPS to determine if the printer supports blending with
|
|
/// AlphaBlend. Note that, for a display DC, all blending operations are supported and these flags represent whether the operations
|
|
/// are accelerated.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the source and destination are the same surface that is, they are both the screen or the same memory bitmap and the source and
|
|
/// destination rectangles overlap, an error occurs and the function returns FALSE.
|
|
/// </para>
|
|
/// <para>
|
|
/// The source rectangle must lie completely within the source surface, otherwise an error occurs and the function returns FALSE.
|
|
/// </para>
|
|
/// <para>AlphaBlend fails if the width or height of the source or destination is negative.</para>
|
|
/// <para>
|
|
/// The SourceConstantAlpha member of BLENDFUNCTION specifies an alpha transparency value to be used on the entire source bitmap. The
|
|
/// SourceConstantAlpha value is combined with any per-pixel alpha values. If SourceConstantAlpha is 0, it is assumed that the image
|
|
/// is transparent. Set the SourceConstantAlpha value to 255 (which indicates that the image is opaque) when you only want to use
|
|
/// per-pixel alpha values.
|
|
/// </para>
|
|
/// </remarks>
|
|
[DllImport(Lib.Gdi32, SetLastError = true, EntryPoint = "GdiAlphaBlend")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd183351")]
|
|
public static extern bool AlphaBlend(HDC hdcDest, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, BLENDFUNCTION blendFunction);
|
|
|
|
/// <summary>
|
|
/// The BitBlt function performs a bit-block transfer of the color data corresponding to a rectangle of pixels from the specified
|
|
/// source device context into a destination device context.
|
|
/// </summary>
|
|
/// <param name="hdc">A handle to the destination device context.</param>
|
|
/// <param name="nXDest">The x-coordinate, in logical units, of the upper-left corner of the destination rectangle.</param>
|
|
/// <param name="nYDest">The y-coordinate, in logical units, of the upper-left corner of the destination rectangle.</param>
|
|
/// <param name="nWidth">The width, in logical units, of the destination rectangle.</param>
|
|
/// <param name="nHeight">The height, in logical units, of the destination rectangle.</param>
|
|
/// <param name="hdcSrc">A handle to the source device context.</param>
|
|
/// <param name="nXSrc">The x-coordinate, in logical units, of the upper-left corner of the source rectangle.</param>
|
|
/// <param name="nYSrc">The y-coordinate, in logical units, of the upper-left corner of the source rectangle.</param>
|
|
/// <param name="dwRop">
|
|
/// A raster-operation code. These codes define how the color data for the source rectangle is to be combined with the color data for
|
|
/// the destination rectangle to achieve the final color.
|
|
/// </param>
|
|
/// <returns>
|
|
/// If the function succeeds, the return value is nonzero.
|
|
/// <para>If the function fails, the return value is zero. To get extended error information, call GetLastError.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// BitBlt only does clipping on the destination DC.
|
|
/// <para>
|
|
/// If a rotation or shear transformation is in effect in the source device context, BitBlt returns an error. If other
|
|
/// transformations exist in the source device context (and a matching transformation is not in effect in the destination device
|
|
/// context), the rectangle in the destination device context is stretched, compressed, or rotated, as necessary.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the color formats of the source and destination device contexts do not match, the BitBlt function converts the source color
|
|
/// format to match the destination format.
|
|
/// </para>
|
|
/// <para>
|
|
/// When an enhanced metafile is being recorded, an error occurs if the source device context identifies an enhanced-metafile device context.
|
|
/// </para>
|
|
/// <para>
|
|
/// Not all devices support the BitBlt function. For more information, see the RC_BITBLT raster capability entry in the GetDeviceCaps
|
|
/// function as well as the following functions: MaskBlt, PlgBlt, and StretchBlt.
|
|
/// </para>
|
|
/// <para>
|
|
/// BitBlt returns an error if the source and destination device contexts represent different devices. To transfer data between DCs
|
|
/// for different devices, convert the memory bitmap to a DIB by calling GetDIBits. To display the DIB to the second device, call
|
|
/// SetDIBits or StretchDIBits.
|
|
/// </para>
|
|
/// <para>ICM: No color management is performed when blits occur.</para>
|
|
/// </remarks>
|
|
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd183370")]
|
|
public static extern bool BitBlt(HDC hdc, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, RasterOperationMode dwRop);
|
|
|
|
/// <summary>The CreateCompatibleDC function creates a memory device context (DC) compatible with the specified device.</summary>
|
|
/// <param name="hDC">
|
|
/// A handle to an existing DC. If this handle is NULL, the function creates a memory DC compatible with the application's current screen.
|
|
/// </param>
|
|
/// <returns>
|
|
/// If the function succeeds, the return value is the handle to a memory DC.
|
|
/// <para>If the function fails, the return value is NULL.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// A memory DC exists only in memory. When the memory DC is created, its display surface is exactly one monochrome pixel wide and
|
|
/// one monochrome pixel high. Before an application can use a memory DC for drawing operations, it must select a bitmap of the
|
|
/// correct width and height into the DC. To select a bitmap into a DC, use the CreateCompatibleBitmap function, specifying the
|
|
/// height, width, and color organization required.
|
|
/// <para>
|
|
/// When a memory DC is created, all attributes are set to normal default values. The memory DC can be used as a normal DC. You can
|
|
/// set the attributes; obtain the current settings of its attributes; and select pens, brushes, and regions.
|
|
/// </para>
|
|
/// <para>
|
|
/// The CreateCompatibleDC function can only be used with devices that support raster operations. An application can determine
|
|
/// whether a device supports these operations by calling the GetDeviceCaps function.
|
|
/// </para>
|
|
/// <para>
|
|
/// When you no longer need the memory DC, call the DeleteDC function. We recommend that you call DeleteDC to delete the DC. However,
|
|
/// you can also call DeleteObject with the HDC to delete the DC.
|
|
/// </para>
|
|
/// <para>
|
|
/// If hdc is NULL, the thread that calls CreateCompatibleDC owns the HDC that is created. When this thread is destroyed, the HDC is
|
|
/// no longer valid. Thus, if you create the HDC and pass it to another thread, then exit the first thread, the second thread will
|
|
/// not be able to use the HDC.
|
|
/// </para>
|
|
/// <para>
|
|
/// ICM: If the DC that is passed to this function is enabled for Image Color Management (ICM), the DC created by the function is
|
|
/// ICM-enabled. The source and destination color spaces are specified in the DC.
|
|
/// </para>
|
|
/// </remarks>
|
|
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd183489")]
|
|
public static extern SafeHDC CreateCompatibleDC(HDC hDC);
|
|
|
|
/// <summary>The DeleteDC function deletes the specified device context (DC).</summary>
|
|
/// <param name="hdc">A handle to the device context.</param>
|
|
/// <returns>If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.</returns>
|
|
/// <remarks>
|
|
/// An application must not delete a DC whose handle was obtained by calling the GetDC function. Instead, it must call the ReleaseDC
|
|
/// function to free the DC.
|
|
/// </remarks>
|
|
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
[System.Security.SecurityCritical]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd183533")]
|
|
public static extern bool DeleteDC(HDC hdc);
|
|
|
|
/// <summary>
|
|
/// The DeleteObject function deletes a logical pen, brush, font, bitmap, region, or palette, freeing all system resources associated
|
|
/// with the object. After the object is deleted, the specified handle is no longer valid.
|
|
/// </summary>
|
|
/// <param name="hObject">A handle to a logical pen, brush, font, bitmap, region, or palette.</param>
|
|
/// <returns>
|
|
/// If the function succeeds, the return value is nonzero. If the specified handle is not valid or is currently selected into a DC,
|
|
/// the return value is zero.
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// Do not delete a drawing object (pen or brush) while it is still selected into a DC.
|
|
/// <para>When a pattern brush is deleted, the bitmap associated with the brush is not deleted. The bitmap must be deleted independently.</para>
|
|
/// </remarks>
|
|
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd183539")]
|
|
public static extern bool DeleteObject(HGDIOBJ hObject);
|
|
|
|
/// <summary>The GdiFlush function flushes the calling thread's current batch.</summary>
|
|
/// <returns>
|
|
/// If all functions in the current batch succeed, the return value is nonzero.
|
|
/// <para>
|
|
/// If not all functions in the current batch succeed, the return value is zero, indicating that at least one function returned an error.
|
|
/// </para>
|
|
/// </returns>
|
|
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
[System.Security.SecurityCritical]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd144844")]
|
|
public static extern bool GdiFlush();
|
|
|
|
/// <summary>The GetDeviceCaps function retrieves device-specific information for the specified device.</summary>
|
|
/// <param name="hdc">A handle to the DC.</param>
|
|
/// <param name="index">The item to be returned.</param>
|
|
/// <returns>
|
|
/// The return value specifies the value of the desired item. When nIndex is BITSPIXEL and the device has 15bpp or 16bpp, the return
|
|
/// value is 16.
|
|
/// </returns>
|
|
// https://msdn.microsoft.com/en-us/library/windows/desktop/dd144877(v=vs.85).aspx
|
|
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd144877")]
|
|
public static extern int GetDeviceCaps(HDC hdc, DeviceCap index);
|
|
|
|
/// <summary>The GetObject function retrieves information for the specified graphics object.</summary>
|
|
/// <param name="hgdiobj">
|
|
/// A handle to the graphics object of interest. This can be a handle to one of the following: a logical bitmap, a brush, a font, a
|
|
/// palette, a pen, or a device independent bitmap created by calling the CreateDIBSection function.
|
|
/// </param>
|
|
/// <param name="cbBuffer">The number of bytes of information to be written to the buffer.</param>
|
|
/// <param name="lpvObject">
|
|
/// A pointer to a buffer that receives the information about the specified graphics object. If the <paramref name="lpvObject"/>
|
|
/// parameter is NULL, the function return value is the number of bytes required to store the information it writes to the buffer for
|
|
/// the specified graphics object.
|
|
/// </param>
|
|
/// <returns>
|
|
/// If the function succeeds, and <paramref name="lpvObject"/> is a valid pointer, the return value is the number of bytes stored
|
|
/// into the buffer.
|
|
/// <para>
|
|
/// If the function succeeds, and <paramref name="lpvObject"/> is NULL, the return value is the number of bytes required to hold the
|
|
/// information the function would store into the buffer.
|
|
/// </para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// The buffer pointed to by the <paramref name="lpvObject"/> parameter must be sufficiently large to receive the information about
|
|
/// the graphics object. Depending on the graphics object, the function uses a BITMAP, DIBSECTION, EXTLOGPEN, LOGBRUSH, LOGFONT, or
|
|
/// LOGPEN structure, or a count of table entries (for a logical palette).
|
|
/// <para>
|
|
/// If <paramref name="hgdiobj"/> is a handle to a bitmap created by calling CreateDIBSection, and the specified buffer is large
|
|
/// enough, the GetObject function returns a DIBSECTION structure. In addition, the bmBits member of the BITMAP structure contained
|
|
/// within the DIBSECTION will contain a pointer to the bitmap's bit values.
|
|
/// </para>
|
|
/// <para>
|
|
/// If <paramref name="hgdiobj"/> is a handle to a bitmap created by any other means, GetObject returns only the width, height, and
|
|
/// color format information of the bitmap. You can obtain the bitmap's bit values by calling the GetDIBits or GetBitmapBits function.
|
|
/// </para>
|
|
/// <para>
|
|
/// If <paramref name="hgdiobj"/> is a handle to a logical palette, GetObject retrieves a 2-byte integer that specifies the number of
|
|
/// entries in the palette. The function does not retrieve the LOGPALETTE structure defining the palette. To retrieve information
|
|
/// about palette entries, an application can call the GetPaletteEntries function.
|
|
/// </para>
|
|
/// <para>
|
|
/// If <paramref name="hgdiobj"/> is a handle to a font, the LOGFONT that is returned is the LOGFONT used to create the font. If
|
|
/// Windows had to make some interpolation of the font because the precise LOGFONT could not be represented, the interpolation will
|
|
/// not be reflected in the LOGFONT. For example, if you ask for a vertical version of a font that doesn't support vertical painting,
|
|
/// the LOGFONT indicates the font is vertical, but Windows will paint it horizontally.
|
|
/// </para>
|
|
/// </remarks>
|
|
[DllImport(Lib.Gdi32, CharSet = CharSet.Auto, SetLastError = true)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd144904")]
|
|
public static extern int GetObject(HGDIOBJ hgdiobj, int cbBuffer, IntPtr lpvObject);
|
|
|
|
/// <summary>The GetObject function retrieves information for the specified graphics object.</summary>
|
|
/// <typeparam name="T">The output structure type.</typeparam>
|
|
/// <param name="hgdiobj">
|
|
/// A handle to the graphics object of interest. This can be a handle to one of the following: a logical bitmap, a brush, a font, a
|
|
/// palette, a pen, or a device independent bitmap created by calling the CreateDIBSection function.
|
|
/// </param>
|
|
/// <returns>The output structure holding the information for the graphics object.</returns>
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd144904")]
|
|
public static T GetObject<T>(HGDIOBJ hgdiobj) where T : struct
|
|
{
|
|
using (var ptr = GetObject(hgdiobj))
|
|
return ptr.ToStructure<T>();
|
|
}
|
|
|
|
/// <summary>The GetObject function retrieves information for the specified graphics object.</summary>
|
|
/// <param name="hgdiobj">
|
|
/// A handle to the graphics object of interest. This can be a handle to one of the following: a logical bitmap, a brush, a font, a
|
|
/// palette, a pen, or a device independent bitmap created by calling the CreateDIBSection function.
|
|
/// </param>
|
|
/// <returns>Allocated memory holding the information for the graphics object.</returns>
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd144904")]
|
|
public static SafeHGlobalHandle GetObject(HGDIOBJ hgdiobj)
|
|
{
|
|
var sz = GetObject(hgdiobj, 0, IntPtr.Zero);
|
|
var ptr = new SafeHGlobalHandle(sz);
|
|
var ret = GetObject(hgdiobj, ptr.Size, (IntPtr)ptr);
|
|
if (ret == 0)
|
|
Win32Error.ThrowLastError();
|
|
return ptr;
|
|
}
|
|
|
|
/// <summary>Converts a height in logical units to pixels.</summary>
|
|
/// <param name="height">The height in logical units.</param>
|
|
/// <param name="hdc">The device context handle.</param>
|
|
/// <returns>The height in pixels.</returns>
|
|
public static int LogicalHeightToDeviceWidth(int height, HDC hdc = default)
|
|
{
|
|
var pts = new[] { new Point(0, height) };
|
|
LPtoDP(hdc.IsNull ? SafeHDC.ScreenCompatibleDCHandle : hdc, pts, 1);
|
|
return pts[0].Y;
|
|
}
|
|
|
|
/// <summary>Converts a width in logical units to pixels.</summary>
|
|
/// <param name="width">The width in logical units.</param>
|
|
/// <param name="hdc">The device context handle.</param>
|
|
/// <returns>The width in pixels.</returns>
|
|
public static int LogicalWidthToDeviceWidth(int width, HDC hdc = default)
|
|
{
|
|
var pts = new[] { new Point(width, 0) };
|
|
LPtoDP(hdc.IsNull ? SafeHDC.ScreenCompatibleDCHandle : hdc, pts, 1);
|
|
return pts[0].X;
|
|
}
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>LPtoDP</c> function converts logical coordinates into device coordinates. The conversion depends on the mapping mode of
|
|
/// the device context, the settings of the origins and extents for the window and viewport, and the world transformation.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hdc">
|
|
/// <para>A handle to the device context.</para>
|
|
/// </param>
|
|
/// <param name="lppt">
|
|
/// <para>
|
|
/// A pointer to an array of POINT structures. The x-coordinates and y-coordinates contained in each of the <c>POINT</c> structures
|
|
/// will be transformed.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="c">
|
|
/// <para>The number of points in the array.</para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is nonzero.</para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The <c>LPtoDP</c> function fails if the logical coordinates exceed 32 bits, or if the converted device coordinates exceed 27
|
|
/// bits. In the case of such an overflow, the results for all the points are undefined.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>LPtoDP</c> calculates complex floating-point arithmetic, and it has a caching system for efficiency. Therefore, the conversion
|
|
/// result of an initial call to <c>LPtoDP</c> might not exactly match the conversion result of a later call to <c>LPtoDP</c>. We
|
|
/// recommend not to write code that relies on the exact match of the conversion results from multiple calls to <c>LPtoDP</c> even if
|
|
/// the parameters that are passed to each call are identical.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-lptodp
|
|
// BOOL LPtoDP( HDC hdc, LPPOINT lppt, int c );
|
|
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "670a16fb-842e-4250-9ad7-dc08e849c2ba")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool LPtoDP(HDC hdc, [In, Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] Point[] lppt, int c);
|
|
|
|
/// <summary>
|
|
/// The SelectObject function selects an object into the specified device context (DC). The new object replaces the previous object
|
|
/// of the same type.
|
|
/// </summary>
|
|
/// <param name="hDC">A handle to the DC.</param>
|
|
/// <param name="hObject">
|
|
/// A handle to the object to be selected. The specified object must have been created by using one of the following functions.
|
|
/// </param>
|
|
/// <returns>
|
|
/// If the selected object is not a region and the function succeeds, the return value is a handle to the object being replaced. If
|
|
/// the selected object is a region and the function succeeds, the return value is one of the following values.
|
|
/// </returns>
|
|
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd162957")]
|
|
public static extern HGDIOBJ SelectObject(HDC hDC, HGDIOBJ hObject);
|
|
|
|
/// <summary>
|
|
/// The SetBkMode function sets the background mix mode of the specified device context. The background mix mode is used with text,
|
|
/// hatched brushes, and pen styles that are not solid lines.
|
|
/// </summary>
|
|
/// <param name="hdc">A handle to the device context.</param>
|
|
/// <param name="mode">The background mode.</param>
|
|
/// <returns>
|
|
/// If the function succeeds, the return value specifies the previous background mode. If the function fails, the return value is zero.
|
|
/// </returns>
|
|
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd162965")]
|
|
public static extern BackgroundMode SetBkMode(HDC hdc, BackgroundMode mode);
|
|
|
|
/// <summary>The SetLayout function changes the layout of a device context (DC).</summary>
|
|
/// <param name="hdc">A handle to the DC.</param>
|
|
/// <param name="dwLayout">The DC layout.</param>
|
|
/// <returns>If the function succeeds, it returns the previous layout of the DC. If the function fails, it returns GDI_ERROR.</returns>
|
|
/// <remarks>
|
|
/// The layout specifies the order in which text and graphics are revealed in a window or a device context. The default is left to
|
|
/// right. The SetLayout function changes this to be right to left, which is the standard in Arabic and Hebrew cultures.
|
|
/// </remarks>
|
|
[DllImport(Lib.Gdi32, ExactSpelling = true, SetLastError = true)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd162979")]
|
|
public static extern DCLayout SetLayout(HDC hdc, DCLayout dwLayout);
|
|
|
|
/// <summary>
|
|
/// The TransparentBlt function performs a bit-block transfer of the color data corresponding to a rectangle of pixels from the
|
|
/// specified source device context into a destination device context.
|
|
/// </summary>
|
|
/// <param name="hdcDest">A handle to the destination device context.</param>
|
|
/// <param name="xOriginDest">The x-coordinate, in logical units, of the upper-left corner of the destination rectangle.</param>
|
|
/// <param name="yOriginDest">The y-coordinate, in logical units, of the upper-left corner of the destination rectangle.</param>
|
|
/// <param name="wDest">The width, in logical units, of the destination rectangle.</param>
|
|
/// <param name="hDest">The height, in logical units, of the destination rectangle.</param>
|
|
/// <param name="hdcSrc">A handle to the source device context.</param>
|
|
/// <param name="xOriginSrc">The x-coordinate, in logical units, of the upper-left corner of the source rectangle.</param>
|
|
/// <param name="yOriginSrc">The y-coordinate, in logical units, of the upper-left corner of the source rectangle.</param>
|
|
/// <param name="wSrc">The width, in logical units, of the source rectangle.</param>
|
|
/// <param name="hSrc">The height, in logical units, of the source rectangle.</param>
|
|
/// <param name="crTransparent">The RGB color in the source bitmap to treat as transparent.</param>
|
|
/// <returns>If the function succeeds, the return value is TRUE. If the function fails, the return value is FALSE.</returns>
|
|
/// <remarks>
|
|
/// The TransparentBlt function works with compatible bitmaps (DDBs).
|
|
/// <para>
|
|
/// The TransparentBlt function supports all formats of source bitmaps. However, for 32 bpp bitmaps, it just copies the alpha value
|
|
/// over. Use AlphaBlend to specify 32 bits-per-pixel bitmaps with transparency.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the source and destination rectangles are not the same size, the source bitmap is stretched to match the destination
|
|
/// rectangle. When the SetStretchBltMode function is used, the iStretchMode modes of BLACKONWHITE and WHITEONBLACK are converted to
|
|
/// COLORONCOLOR for the TransparentBlt function.
|
|
/// </para>
|
|
/// <para>
|
|
/// The destination device context specifies the transformation type for the destination coordinates. The source device context
|
|
/// specifies the transformation type for the source coordinates.
|
|
/// </para>
|
|
/// <para>TransparentBlt does not mirror a bitmap if either the width or height, of either the source or destination, is negative.</para>
|
|
/// <para>
|
|
/// When used in a multiple monitor system, both hdcSrc and hdcDest must refer to the same device or the function will fail. To
|
|
/// transfer data between DCs for different devices, convert the memory bitmap to a DIB by calling GetDIBits. To display the DIB to
|
|
/// the second device, call SetDIBits or StretchDIBits.
|
|
/// </para>
|
|
/// </remarks>
|
|
[DllImport(Lib.Gdi32, SetLastError = true, EntryPoint = "GdiTransparentBlt")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
[PInvokeData("Wingdi.h", MSDNShortId = "dd145141")]
|
|
public static extern bool TransparentBlt(HDC hdcDest, int xOriginDest, int yOriginDest, int wDest, int hDest, HDC hdcSrc, int xOriginSrc, int yOriginSrc, int wSrc, int hSrc, int crTransparent);
|
|
|
|
/// <summary>
|
|
/// The <c>DISPLAY_DEVICE</c> structure receives information about the display device specified by the iDevNum parameter of the
|
|
/// EnumDisplayDevices function.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The four string members are set based on the parameters passed to EnumDisplayDevices. If the lpDevice param is <c>NULL</c>, then
|
|
/// DISPLAY_DEVICE is filled in with information about the display adapter(s). If it is a valid device name, then it is filled in
|
|
/// with information about the monitor(s) for that device.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/ns-wingdi-_display_devicea typedef struct _DISPLAY_DEVICEA { DWORD cb;
|
|
// CHAR DeviceName[32]; CHAR DeviceString[128]; DWORD StateFlags; CHAR DeviceID[128]; CHAR DeviceKey[128]; } DISPLAY_DEVICEA,
|
|
// *PDISPLAY_DEVICEA, *LPDISPLAY_DEVICEA;
|
|
[PInvokeData("wingdi.h", MSDNShortId = "9a7813fe-358a-44eb-99da-c63f98d055c3")]
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
public struct DISPLAY_DEVICE
|
|
{
|
|
/// <summary>Size, in bytes, of the <c>DISPLAY_DEVICE</c> structure. This must be initialized prior to calling EnumDisplayDevices.</summary>
|
|
public uint cb;
|
|
|
|
/// <summary>An array of characters identifying the device name. This is either the adapter device or the monitor device.</summary>
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
|
|
public string DeviceName;
|
|
|
|
/// <summary>
|
|
/// An array of characters containing the device context string. This is either a description of the display adapter or of the
|
|
/// display monitor.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
|
|
public string DeviceString;
|
|
|
|
/// <summary>
|
|
/// <para>Device state flags. It can be any reasonable combination of the following.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>DISPLAY_DEVICE_ACTIVE</term>
|
|
/// <term>
|
|
/// DISPLAY_DEVICE_ACTIVE specifies whether a monitor is presented as being "on" by the respective GDI view. Windows Vista:
|
|
/// EnumDisplayDevices will only enumerate monitors that can be presented as being "on."
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DISPLAY_DEVICE_MIRRORING_DRIVER</term>
|
|
/// <term>
|
|
/// Represents a pseudo device used to mirror application drawing for remoting or other purposes. An invisible pseudo monitor is
|
|
/// associated with this device. For example, NetMeeting uses it. Note that GetSystemMetrics (SM_MONITORS) only accounts for
|
|
/// visible display monitors.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DISPLAY_DEVICE_MODESPRUNED</term>
|
|
/// <term>The device has more display modes than its output devices support.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DISPLAY_DEVICE_PRIMARY_DEVICE</term>
|
|
/// <term>
|
|
/// The primary desktop is on the device. For a system with a single display card, this is always set. For a system with multiple
|
|
/// display cards, only one device can have this set.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DISPLAY_DEVICE_REMOVABLE</term>
|
|
/// <term>The device is removable; it cannot be the primary display.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DISPLAY_DEVICE_VGA_COMPATIBLE</term>
|
|
/// <term>The device is VGA compatible.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public DISPLAY_DEVICE_FLAGS StateFlags;
|
|
|
|
/// <summary>Not used.</summary>
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
|
|
public string DeviceID;
|
|
|
|
/// <summary>Reserved.</summary>
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
|
|
public string DeviceKey;
|
|
|
|
/// <summary>Gets an empty structure with the <see cref="cb"/> set to the size of the structure.</summary>
|
|
public static readonly DISPLAY_DEVICE Default = new DISPLAY_DEVICE { cb = (uint)Marshal.SizeOf(typeof(DISPLAY_DEVICE)) };
|
|
}
|
|
}
|
|
} |