mirror of https://github.com/dahall/Vanara.git
1840 lines
98 KiB
C#
1840 lines
98 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using Vanara.Extensions;
|
|
using Vanara.InteropServices;
|
|
|
|
namespace Vanara.PInvoke
|
|
{
|
|
public static partial class Gdi32
|
|
{
|
|
/// <summary>
|
|
/// The <c>EnhMetaFileProc</c> function is an application-defined callback function used with the EnumEnhMetaFile function. The
|
|
/// <c>ENHMFENUMPROC</c> type defines a pointer to this callback function. <c>EnhMetaFileProc</c> is a placeholder for the
|
|
/// application-defined function name.
|
|
/// </summary>
|
|
/// <param name="hdc">Handle to the device context passed to EnumEnhMetaFile.</param>
|
|
/// <param name="lpht">
|
|
/// Pointer to a HANDLETABLE structure representing the table of handles associated with the graphics objects (pens, brushes, and so
|
|
/// on) in the metafile. The first entry contains the enhanced-metafile handle.
|
|
/// </param>
|
|
/// <param name="lpmr">
|
|
/// Pointer to one of the records in the metafile. This record should not be modified. (If modification is necessary, it should be
|
|
/// performed on a copy of the record.)
|
|
/// </param>
|
|
/// <param name="nHandles">Specifies the number of objects with associated handles in the handle table.</param>
|
|
/// <param name="data">Pointer to optional data.</param>
|
|
/// <returns>This function must return a nonzero value to continue enumeration; to stop enumeration, it must return zero.</returns>
|
|
/// <remarks>An application must register the callback function by passing its address to the EnumEnhMetaFile function.</remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nc-wingdi-enhmfenumproc ENHMFENUMPROC Enhmfenumproc; int Enhmfenumproc(
|
|
// HDC hdc, HANDLETABLE *lpht, const ENHMETARECORD *lpmr, int nHandles, LPARAM data ) {...}
|
|
[PInvokeData("wingdi.h", MSDNShortId = "c9f04b38-18bc-4b52-8c56-d9475bc30202")]
|
|
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
|
|
public delegate int EnhMetaFileProc(HDC hdc, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] HGDIOBJ[] lpht, [In] IntPtr lpmr, int nHandles, IntPtr data);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>EnumMetaFileProc</c> function is an application-defined callback function that processes Windows-format metafile records.
|
|
/// This function is called by the EnumMetaFile function. The <c>MFENUMPROC</c> type defines a pointer to this callback function.
|
|
/// <c>EnumMetaFileProc</c> is a placeholder for the application-defined function name.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is EnhMetaFileProc.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>An application must register the callback function by passing its address to the EnumMetaFile function.</para>
|
|
/// <para><c>EnumMetaFileProc</c> is a placeholder for the application-supplied function name.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nc-wingdi-mfenumproc MFENUMPROC Mfenumproc; int Mfenumproc( HDC hdc,
|
|
// HANDLETABLE *lpht, METARECORD *lpMR, int nObj, LPARAM param ) {...}
|
|
[PInvokeData("wingdi.h", MSDNShortId = "ebef5a3f-0dd7-49df-a07d-c55c5e8c868c")]
|
|
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
|
|
public delegate int EnumMetaFileProc(HDC hdc, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] HGDIOBJ[] lpht, [In] IntPtr lpMR, int nObj, IntPtr param);
|
|
|
|
/// <summary>
|
|
/// The RecordType enumeration defines values that uniquely identify records in an EMF metafile. These values are specified in the
|
|
/// Type fields of EMF records (section 2.3).
|
|
/// </summary>
|
|
[PInvokeData("wingdi.h")]
|
|
public enum RecordType : uint
|
|
{
|
|
/// <summary>
|
|
/// This record defines the start of the metafile and specifies its characteristics; its contents, including the dimensions of
|
|
/// the embedded image; the number of records in the metafile; and the resolution of the device on which the embedded image was
|
|
/// created. These values make it possible for the metafile to be device-independent.
|
|
/// </summary>
|
|
EMR_HEADER = 1,
|
|
|
|
/// <summary>
|
|
/// This record defines one or more Bezier curves. Cubic Bezier curves are defined using specified endpoints and control points,
|
|
/// and are stroked with the current pen.
|
|
/// </summary>
|
|
EMR_POLYBEZIER = 2,
|
|
|
|
/// <summary>
|
|
/// This record defines a polygon consisting of two or more vertexes connected by straight lines. The polygon is outlined by
|
|
/// using the current pen and filled by using the current brush and polygon fill mode. The polygon is closed automatically by
|
|
/// drawing a line from the last vertex to the first.
|
|
/// </summary>
|
|
EMR_POLYGON = 3,
|
|
|
|
/// <summary>This record defines a series of line segments by connecting the points in the specified array.</summary>
|
|
EMR_POLYLINE = 4,
|
|
|
|
/// <summary>This record defines one or more Bezier curves based upon the current drawing position.</summary>
|
|
EMR_POLYBEZIERTO = 5,
|
|
|
|
/// <summary>
|
|
/// This record defines one or more straight lines based upon the current drawing position. A line is drawn from the current
|
|
/// drawing position to the first point specified by the points field by using the current pen. For each additional line, drawing
|
|
/// is performed from the ending point of the previous line to the next point specified by points.
|
|
/// </summary>
|
|
EMR_POLYLINETO = 6,
|
|
|
|
/// <summary>
|
|
/// This record defines multiple series of connected line segments. The line segments are drawn by using the current pen. The
|
|
/// figures formed by the segments are not filled. The current position is neither used nor updated by this record.
|
|
/// </summary>
|
|
EMR_POLYPOLYLINE = 7,
|
|
|
|
/// <summary>
|
|
/// This record defines a series of closed polygons. Each polygon is outlined by using the current pen and filled by using the
|
|
/// current brush and polygon fill mode. The polygons defined by this record can overlap.
|
|
/// </summary>
|
|
EMR_POLYPOLYGON = 8,
|
|
|
|
/// <summary>This record defines the window extent.</summary>
|
|
EMR_SETWINDOWEXTEX = 9,
|
|
|
|
/// <summary>This record defines the window origin.</summary>
|
|
EMR_SETWINDOWORGEX = 10,
|
|
|
|
/// <summary>This record defines the viewport extent.</summary>
|
|
EMR_SETVIEWPORTEXTEX = 11,
|
|
|
|
/// <summary>This record defines the viewport origin.</summary>
|
|
EMR_SETVIEWPORTORGEX = 12,
|
|
|
|
/// <summary>This record defines the origin of the current brush.</summary>
|
|
EMR_SETBRUSHORGEX = 13,
|
|
|
|
/// <summary>This record indicates the end of the metafile.</summary>
|
|
EMR_EOF = 14,
|
|
|
|
/// <summary>This record defines the color of the pixel at the specified logical coordinates.</summary>
|
|
EMR_SETPIXELV = 15,
|
|
|
|
/// <summary>
|
|
/// This record specifies parameters for the process of matching logical fonts to physical fonts, which is performed by the font mapper.
|
|
/// </summary>
|
|
EMR_SETMAPPERFLAGS = 16,
|
|
|
|
/// <summary>
|
|
/// This record defines the mapping mode, which defines the unit of measure used to transform page space units into device space
|
|
/// units, and defines the orientation of the device's X and Y axes.
|
|
/// </summary>
|
|
EMR_SETMAPMODE = 17,
|
|
|
|
/// <summary>
|
|
/// This record defines the background mix mode, which is used with text, hatched brushes, and pen styles that are not solid lines.
|
|
/// </summary>
|
|
EMR_SETBKMODE = 18,
|
|
|
|
/// <summary>This record defines polygon fill mode.</summary>
|
|
EMR_SETPOLYFILLMODE = 19,
|
|
|
|
/// <summary>This record defines binary raster operation mode.</summary>
|
|
EMR_SETROP2 = 20,
|
|
|
|
/// <summary>This record defines bitmap stretch mode.</summary>
|
|
EMR_SETSTRETCHBLTMODE = 21,
|
|
|
|
/// <summary>This record defines text alignment.</summary>
|
|
EMR_SETTEXTALIGN = 22,
|
|
|
|
/// <summary>This record defines the color adjustment values using the specified values.</summary>
|
|
EMR_SETCOLORADJUSTMENT = 23,
|
|
|
|
/// <summary>This record defines the current text color.</summary>
|
|
EMR_SETTEXTCOLOR = 24,
|
|
|
|
/// <summary>This record defines the background color.</summary>
|
|
EMR_SETBKCOLOR = 25,
|
|
|
|
/// <summary>This record redefines the current clipping region by the specified offsets.</summary>
|
|
EMR_OFFSETCLIPRGN = 26,
|
|
|
|
/// <summary>This record defines coordinates of the new drawing position in logical units.</summary>
|
|
EMR_MOVETOEX = 27,
|
|
|
|
/// <summary>
|
|
/// This record intersects the current clipping region with the current metaregion and saves the combined region as the new
|
|
/// current metaregion.
|
|
/// </summary>
|
|
EMR_SETMETARGN = 28,
|
|
|
|
/// <summary>
|
|
/// This record defines a new clipping region that consists of the current clipping region intersected with the specified rectangle.
|
|
/// </summary>
|
|
EMR_EXCLUDECLIPRECT = 29,
|
|
|
|
/// <summary>
|
|
/// This record defines a new clipping region from the intersection of the current clipping region and the specified rectangle.
|
|
/// </summary>
|
|
EMR_INTERSECTCLIPRECT = 30,
|
|
|
|
/// <summary>This record redefines the viewport using the ratios formed by the specified multiplicands and divisors.</summary>
|
|
EMR_SCALEVIEWPORTEXTEX = 31,
|
|
|
|
/// <summary>This record redefines the window using the ratios formed by the specified multiplicands and divisors.</summary>
|
|
EMR_SCALEWINDOWEXTEX = 32,
|
|
|
|
/// <summary>
|
|
/// This record saves the current state of the playback device context (section 3.1) in an array of states saved by preceding
|
|
/// EMR_SAVEDC records if any.
|
|
/// </summary>
|
|
EMR_SAVEDC = 33,
|
|
|
|
/// <summary>
|
|
/// This record restores the playback device context to the specified state, which was saved by a preceding EMR_SAVEDC record
|
|
/// (section 2.3.11).
|
|
/// </summary>
|
|
EMR_RESTOREDC = 34,
|
|
|
|
/// <summary>This record defines a two-dimensional linear transform between world space and page space [MSDN-WRLDPGSPC].</summary>
|
|
EMR_SETWORLDTRANSFORM = 35,
|
|
|
|
/// <summary>This record redefines the world transform by using the specified mode.</summary>
|
|
EMR_MODIFYWORLDTRANSFORM = 36,
|
|
|
|
/// <summary>
|
|
/// This record selects an object in the playback device context, which is identified by its index in the EMF object table
|
|
/// (section 3.1.1.1).
|
|
/// </summary>
|
|
EMR_SELECTOBJECT = 37,
|
|
|
|
/// <summary>This record defines a logical pen (section 2.2.19) that has the specified style, width, and color.</summary>
|
|
EMR_CREATEPEN = 38,
|
|
|
|
/// <summary>This record defines a logical brush for filling figures in graphics operations.</summary>
|
|
EMR_CREATEBRUSHINDIRECT = 39,
|
|
|
|
/// <summary>This record deletes a graphics object, clearing its index in the EMF object table.</summary>
|
|
EMR_DELETEOBJECT = 40,
|
|
|
|
/// <summary>
|
|
/// This record defines a line segment of an arc. The line segment is drawn from the current drawing position to the beginning of
|
|
/// the arc. The arc is drawn along the perimeter of a circle with the given radius and center. The length of the arc is defined
|
|
/// by the given start and sweep angles.
|
|
/// </summary>
|
|
EMR_ANGLEARC = 41,
|
|
|
|
/// <summary>
|
|
/// This record defines an ellipse. The center of the ellipse is the center of the specified bounding rectangle. The ellipse is
|
|
/// outlined by using the current pen and is filled by using the current brush.
|
|
/// </summary>
|
|
EMR_ELLIPSE = 42,
|
|
|
|
/// <summary>
|
|
/// This record defines a rectangle. The rectangle is outlined by using the current pen and filled by using the current brush.
|
|
/// </summary>
|
|
EMR_RECTANGLE = 43,
|
|
|
|
/// <summary>
|
|
/// This record defines a rectangle with rounded corners. The rectangle is outlined by using the current pen and filled by using
|
|
/// the current brush.
|
|
/// </summary>
|
|
EMR_ROUNDRECT = 44,
|
|
|
|
/// <summary>This record defines an elliptical arc.</summary>
|
|
EMR_ARC = 45,
|
|
|
|
/// <summary>
|
|
/// This record defines a chord, which is a region bounded by the intersection of an ellipse and a line segment, called a secant.
|
|
/// The chord is outlined by using the current pen and filled by using the current brush.
|
|
/// </summary>
|
|
EMR_CHORD = 46,
|
|
|
|
/// <summary>
|
|
/// This record defines a pie-shaped wedge bounded by the intersection of an ellipse and two radials. The pie is outlined by
|
|
/// using the current pen and filled by using the current brush.
|
|
/// </summary>
|
|
EMR_PIE = 47,
|
|
|
|
/// <summary>
|
|
/// This record selects a LogPalette object (section 2.2.17) into the playback device context, identifying it by its index in the
|
|
/// EMF object table.
|
|
/// </summary>
|
|
EMR_SELECTPALETTE = 48,
|
|
|
|
/// <summary>This record defines a LogPalette object.</summary>
|
|
EMR_CREATEPALETTE = 49,
|
|
|
|
/// <summary>This record defines RGB color values in a range of entries in a LogPalette object.</summary>
|
|
EMR_SETPALETTEENTRIES = 50,
|
|
|
|
/// <summary>This record increases or decreases the size of a logical palette.</summary>
|
|
EMR_RESIZEPALETTE = 51,
|
|
|
|
/// <summary>This record maps entries from the current logical palette to the system palette.</summary>
|
|
EMR_REALIZEPALETTE = 52,
|
|
|
|
/// <summary>This record fills an area of the display surface with the current brush.</summary>
|
|
EMR_EXTFLOODFILL = 53,
|
|
|
|
/// <summary>
|
|
/// This record defines a line from the current drawing position up to, but not including, the specified point. It resets the
|
|
/// current drawing position to the specified point.
|
|
/// </summary>
|
|
EMR_LINETO = 54,
|
|
|
|
/// <summary>This record defines an elliptical arc. It resets the current position to the endpoint of the arc.</summary>
|
|
EMR_ARCTO = 55,
|
|
|
|
/// <summary>This record defines a set of line segments and Bezier curves.</summary>
|
|
EMR_POLYDRAW = 56,
|
|
|
|
/// <summary>This record defines the drawing direction to be used for arc and rectangle operations.</summary>
|
|
EMR_SETARCDIRECTION = 57,
|
|
|
|
/// <summary>This record defines the limit for the length of miter joins.</summary>
|
|
EMR_SETMITERLIMIT = 58,
|
|
|
|
/// <summary>This record opens a path bracket for specifying the current path.</summary>
|
|
EMR_BEGINPATH = 59,
|
|
|
|
/// <summary>This record closes an open path bracket and selects the path into the playback device context.</summary>
|
|
EMR_ENDPATH = 60,
|
|
|
|
/// <summary>This record closes an open figure in a path.</summary>
|
|
EMR_CLOSEFIGURE = 61,
|
|
|
|
/// <summary>
|
|
/// This record closes any open figures in the current path bracket and fills its interior by using the current brush and
|
|
/// polygon-filling mode.
|
|
/// </summary>
|
|
EMR_FILLPATH = 62,
|
|
|
|
/// <summary>
|
|
/// This record closes any open figures in a path, strokes the outline of the path by using the current pen, and fills its
|
|
/// interior by using the current brush.
|
|
/// </summary>
|
|
EMR_STROKEANDFILLPATH = 63,
|
|
|
|
/// <summary>This record renders the specified path by using the current pen.</summary>
|
|
EMR_STROKEPATH = 64,
|
|
|
|
/// <summary>This record turns each curve in the path into a sequence of lines.</summary>
|
|
EMR_FLATTENPATH = 65,
|
|
|
|
/// <summary>
|
|
/// This record redefines the current path bracket as the area that would be painted if the path were stroked using the current pen.
|
|
/// </summary>
|
|
EMR_WIDENPATH = 66,
|
|
|
|
/// <summary>
|
|
/// This record specifies a clipping region as the current clipping region combined with the current path bracket, using the
|
|
/// specified mode.
|
|
/// </summary>
|
|
EMR_SELECTCLIPPATH = 67,
|
|
|
|
/// <summary>This record aborts a path bracket or discards the path from a closed path bracket.</summary>
|
|
EMR_ABORTPATH = 68,
|
|
|
|
/// <summary>This record specifies arbitrary private data.</summary>
|
|
EMR_GDICOMMENT = 70,
|
|
|
|
/// <summary>This record fills the specified region by using the specified brush.</summary>
|
|
EMR_FILLRGN = 71,
|
|
|
|
/// <summary>This record draws a border around the specified region using the specified brush.</summary>
|
|
EMR_FRAMERGN = 72,
|
|
|
|
/// <summary>This record inverts the colors in the specified region.</summary>
|
|
EMR_INVERTRGN = 73,
|
|
|
|
/// <summary>This record paints the specified region by using the current brush.</summary>
|
|
EMR_PAINTRGN = 74,
|
|
|
|
/// <summary>This record combines the specified region with the current clipping region, using the specified mode.</summary>
|
|
EMR_EXTSELECTCLIPRGN = 75,
|
|
|
|
/// <summary>
|
|
/// This record specifies a block transfer of pixels from a source bitmap to a destination rectangle, optionally in combination
|
|
/// with a brush pattern, according to a specified raster operation.
|
|
/// </summary>
|
|
EMR_BITBLT = 76,
|
|
|
|
/// <summary>
|
|
/// This record specifies a block transfer of pixels from a source bitmap to a destination rectangle, optionally in combination
|
|
/// with a brush pattern, according to a specified raster operation, stretching or compressing the output to fit the dimensions
|
|
/// of the destination, if necessary.
|
|
/// </summary>
|
|
EMR_STRETCHBLT = 77,
|
|
|
|
/// <summary>
|
|
/// This record specifies a block transfer of pixels from a source bitmap to a destination rectangle, optionally in combination
|
|
/// with a brush pattern and with the application of a color mask bitmap, according to specified foreground and background raster operations.
|
|
/// </summary>
|
|
EMR_MASKBLT = 78,
|
|
|
|
/// <summary>
|
|
/// This record specifies a block transfer of pixels from a source bitmap to a destination parallelogram, with the application of
|
|
/// a color mask bitmap.
|
|
/// </summary>
|
|
EMR_PLGBLT = 79,
|
|
|
|
/// <summary>
|
|
/// This record specifies a block transfer of pixels from specified scanlines of a source bitmap to a destination rectangle.
|
|
/// </summary>
|
|
EMR_SETDIBITSTODEVICE = 80,
|
|
|
|
/// <summary>
|
|
/// This record specifies a block transfer of pixels from a source bitmap to a destination rectangle, optionally in combination
|
|
/// with a brush pattern, according to a specified raster operation, stretching or compressing the output to fit the dimensions
|
|
/// of the destination, if necessary.
|
|
/// </summary>
|
|
EMR_STRETCHDIBITS = 81,
|
|
|
|
/// <summary>
|
|
/// This record defines a logical font that has the specified characteristics. The font can subsequently be selected as the
|
|
/// current font.
|
|
/// </summary>
|
|
EMR_EXTCREATEFONTINDIRECTW = 82,
|
|
|
|
/// <summary>This record draws an ASCII text string using the current font and text colors.</summary>
|
|
EMR_EXTTEXTOUTA = 83,
|
|
|
|
/// <summary>This record draws a Unicode text string using the current font and text colors.</summary>
|
|
EMR_EXTTEXTOUTW = 84,
|
|
|
|
/// <summary>This record defines one or more Bezier curves. The curves are drawn using the current pen.</summary>
|
|
EMR_POLYBEZIER16 = 85,
|
|
|
|
/// <summary>
|
|
/// This record defines a polygon consisting of two or more vertexes connected by straight lines. The polygon is outlined by
|
|
/// using the current pen and filled by using the current brush and polygon fill mode. The polygon is closed automatically by
|
|
/// drawing a line from the last vertex to the first.
|
|
/// </summary>
|
|
EMR_POLYGON16 = 86,
|
|
|
|
/// <summary>This record defines a series of line segments by connecting the points in the specified array.</summary>
|
|
EMR_POLYLINE16 = 87,
|
|
|
|
/// <summary>This record defines one or more Bezier curves based on the current position.</summary>
|
|
EMR_POLYBEZIERTO16 = 88,
|
|
|
|
/// <summary>
|
|
/// This record defines one or more straight lines based upon the current position. A line is drawn from the current position to
|
|
/// the first point specified by the Points field by using the current pen. For each additional line, drawing is performed from
|
|
/// the ending point of the previous line to the next point specified by Points.
|
|
/// </summary>
|
|
EMR_POLYLINETO16 = 89,
|
|
|
|
/// <summary>This record defines multiple series of connected line segments.</summary>
|
|
EMR_POLYPOLYLINE16 = 90,
|
|
|
|
/// <summary>
|
|
/// This record defines a series of closed polygons. Each polygon is outlined by using the current pen and filled by using the
|
|
/// current brush and polygon fill mode. The polygons specified by this record can overlap.
|
|
/// </summary>
|
|
EMR_POLYPOLYGON16 = 91,
|
|
|
|
/// <summary>This record defines a set of line segments and Bezier curves.</summary>
|
|
EMR_POLYDRAW16 = 92,
|
|
|
|
/// <summary>
|
|
/// This record defines a logical brush with the specified bitmap pattern. The bitmap can be a device-independent bitmap (DIB)
|
|
/// section bitmap or it can be a device-dependent bitmap.
|
|
/// </summary>
|
|
EMR_CREATEMONOBRUSH = 93,
|
|
|
|
/// <summary>This record defines a logical brush that has the pattern specified by the DIB.</summary>
|
|
EMR_CREATEDIBPATTERNBRUSHPT = 94,
|
|
|
|
/// <summary>
|
|
/// This record defines an extended logical pen (section 2.2.20) that has the specified style, width, color, and brush attributes.
|
|
/// </summary>
|
|
EMR_EXTCREATEPEN = 95,
|
|
|
|
/// <summary>
|
|
/// This record draws one or more ASCII text strings using the current font and text colors. Note: EMR_POLYTEXTOUTA SHOULD be
|
|
/// emulated with a series of EMR_EXTTEXTOUTW records, one per string.
|
|
/// </summary>
|
|
EMR_POLYTEXTOUTA = 96,
|
|
|
|
/// <summary>
|
|
/// This record draws one or more Unicode text strings using the current font and text colors. Note: EMR_POLYTEXTOUTW SHOULD be
|
|
/// emulated with a series of EMR_EXTTEXTOUTW records, one per string.
|
|
/// </summary>
|
|
EMR_POLYTEXTOUTW = 97,
|
|
|
|
/// <summary>This record specifies the mode of Image Color Management (ICM) for graphics operations.</summary>
|
|
EMR_SETICMMODE = 98,
|
|
|
|
/// <summary>This record creates a logical color space object from a color profile with a name consisting of ASCII characters.</summary>
|
|
EMR_CREATECOLORSPACE = 99,
|
|
|
|
/// <summary>This record defines the current logical color space object for graphics operations.</summary>
|
|
EMR_SETCOLORSPACE = 100,
|
|
|
|
/// <summary>
|
|
/// This record deletes a logical color space object. Note: An EMR_DELETEOBJECT record SHOULD be used instead of
|
|
/// EMR_DELETECOLORSPACE to delete a logical color space object.
|
|
/// </summary>
|
|
EMR_DELETECOLORSPACE = 101,
|
|
|
|
/// <summary>This record specifies an OpenGL function.</summary>
|
|
EMR_GLSRECORD = 102,
|
|
|
|
/// <summary>This record specifies an OpenGL function with a bounding rectangle for output.</summary>
|
|
EMR_GLSBOUNDEDRECORD = 103,
|
|
|
|
/// <summary>This record specifies the pixel format to use for graphics operations.</summary>
|
|
EMR_PIXELFORMAT = 104,
|
|
|
|
/// <summary>
|
|
/// This record passes arbitrary information to the driver. The intent is that the information results in drawing being done.
|
|
/// </summary>
|
|
EMR_DRAWESCAPE = 105,
|
|
|
|
/// <summary>
|
|
/// This record passes arbitrary information to the driver. The intent is that the information does not result in drawing being done.
|
|
/// </summary>
|
|
EMR_EXTESCAPE = 106,
|
|
|
|
/// <summary>This record outputs a string.</summary>
|
|
EMR_SMALLTEXTOUT = 108,
|
|
|
|
/// <summary>
|
|
/// This record forces the font mapper to match fonts based on their UniversalFontId in preference to their LogFont information.
|
|
/// </summary>
|
|
EMR_FORCEUFIMAPPING = 109,
|
|
|
|
/// <summary>This record passes arbitrary information to the given named driver.</summary>
|
|
EMR_NAMEDESCAPE = 110,
|
|
|
|
/// <summary>
|
|
/// This record specifies how to correct the entries of a logical palette object using Windows Color System (WCS) 1.0 values.
|
|
/// </summary>
|
|
EMR_COLORCORRECTPALETTE = 111,
|
|
|
|
/// <summary>This record specifies a color profile in a file with a name consisting of ASCII characters, for graphics output.</summary>
|
|
EMR_SETICMPROFILEA = 112,
|
|
|
|
/// <summary>This record specifies a color profile in a file with a name consisting of Unicode characters, for graphics output.</summary>
|
|
EMR_SETICMPROFILEW = 113,
|
|
|
|
/// <summary>
|
|
/// This record specifies a block transfer of pixels from a source bitmap to a destination rectangle, including alpha
|
|
/// transparency data, according to a specified blending operation.
|
|
/// </summary>
|
|
EMR_ALPHABLEND = 114,
|
|
|
|
/// <summary>This record specifies the order in which text and graphics are drawn.</summary>
|
|
EMR_SETLAYOUT = 115,
|
|
|
|
/// <summary>
|
|
/// This record specifies a block transfer of pixels from a source bitmap to a destination rectangle, treating a specified color
|
|
/// as transparent, stretching or compressing the output to fit the dimensions of the destination, if necessary.
|
|
/// </summary>
|
|
EMR_TRANSPARENTBLT = 116,
|
|
|
|
/// <summary>This record specifies filling rectangles or triangles with gradients of color.</summary>
|
|
EMR_GRADIENTFILL = 118,
|
|
|
|
/// <summary>This record sets the UniversalFontIds (section 2.2.27) of linked fonts to use during character lookup.</summary>
|
|
EMR_SETLINKEDUFIS = 119,
|
|
|
|
/// <summary>This record specifies the amount of extra space to add to break characters for justification purposes.</summary>
|
|
EMR_SETTEXTJUSTIFICATION = 120,
|
|
|
|
/// <summary>
|
|
/// This record specifies whether to perform color matching with a color profile that is specified in a file with a name
|
|
/// consisting of Unicode characters.
|
|
/// </summary>
|
|
EMR_COLORMATCHTOTARGETW = 121,
|
|
|
|
/// <summary>This record creates a logical color space object from a color profile with a name consisting of Unicode characters.</summary>
|
|
EMR_CREATECOLORSPACEW = 122,
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>CloseEnhMetaFile</c> function closes an enhanced-metafile device context and returns a handle that identifies an
|
|
/// enhanced-format metafile.
|
|
/// </summary>
|
|
/// <param name="hdc">Handle to an enhanced-metafile device context.</param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to an enhanced metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// An application can use the enhanced-metafile handle returned by the <c>CloseEnhMetaFile</c> function to perform the following tasks:
|
|
/// </para>
|
|
/// <list type="bullet">
|
|
/// <item>
|
|
/// <term>Display a picture stored in an enhanced metafile</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Create copies of the enhanced metafile</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Enumerate, edit, or copy individual records in the enhanced metafile</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Retrieve an optional description of the metafile contents from the enhanced-metafile header</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Retrieve a copy of the enhanced-metafile header</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Retrieve a binary copy of the enhanced metafile</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Enumerate the colors in the optional palette</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>Convert an enhanced-format metafile into a Windows-format metafile</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>
|
|
/// When the application no longer needs the enhanced metafile handle, it should release the handle by calling the DeleteEnhMetaFile function.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-closeenhmetafile HENHMETAFILE CloseEnhMetaFile( HDC hdc );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "3c4a0d8b-75a5-4729-8c64-476c36d01a90")]
|
|
public static extern SafeHENHMETAFILE CloseEnhMetaFile(HDC hdc);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>CloseMetaFile</c> function closes a metafile device context and returns a handle that identifies a Windows-format metafile.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is CloseEnhMetaFile.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hdc">Handle to a metafile device context used to create a Windows-format metafile.</param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to a Windows-format metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>To convert a Windows-format metafile into a new enhanced-format metafile, use the SetWinMetaFileBits function.</para>
|
|
/// <para>
|
|
/// When an application no longer needs the Windows-format metafile handle, it should delete the handle by calling the DeleteMetaFile function.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-closemetafile HMETAFILE CloseMetaFile( HDC hdc );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "8e50457a-8ef8-4e71-8c56-38cfb277f57d")]
|
|
public static extern HMETAFILE CloseMetaFile(HDC hdc);
|
|
|
|
/// <summary>The <c>CopyEnhMetaFile</c> function copies the contents of an enhanced-format metafile to a specified file.</summary>
|
|
/// <param name="hEnh">A handle to the enhanced metafile to be copied.</param>
|
|
/// <param name="lpFileName">
|
|
/// A pointer to the name of the destination file. If this parameter is <c>NULL</c>, the source metafile is copied to memory.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to the copy of the enhanced metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Where text arguments must use Unicode characters, use the <c>CopyEnhMetaFile</c> function as a wide-character function. Where
|
|
/// text arguments must use characters from the Windows character set, use this function as an ANSI function.
|
|
/// </para>
|
|
/// <para>Applications can use metafiles stored in memory for temporary operations.</para>
|
|
/// <para>
|
|
/// When the application no longer needs the enhanced-metafile handle, it should delete the handle by calling the DeleteEnhMetaFile function.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-copyenhmetafilea HENHMETAFILE CopyEnhMetaFileA( HENHMETAFILE
|
|
// hEnh, LPCSTR lpFileName );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "7c428828-b239-41d4-926c-88caa0aa7214")]
|
|
public static extern SafeHENHMETAFILE CopyEnhMetaFile(HENHMETAFILE hEnh, [Optional] string lpFileName);
|
|
|
|
/// <summary>
|
|
/// <para>The <c>CopyMetaFile</c> function copies the content of a Windows-format metafile to the specified file.</para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is CopyEnhMetaFile.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="arg1">A handle to the source Windows-format metafile.</param>
|
|
/// <param name="arg2">
|
|
/// A pointer to the name of the destination file. If this parameter is <c>NULL</c>, the source metafile is copied to memory.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to the copy of the Windows-format metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Where text arguments must use Unicode characters, use this function as a wide-character function. Where text arguments must use
|
|
/// characters from the Windows character set, use this function as an ANSI function.
|
|
/// </para>
|
|
/// <para>
|
|
/// When the application no longer needs the Windows-format metafile handle, it should delete the handle by calling the
|
|
/// DeleteMetaFile function.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-copymetafilea HMETAFILE CopyMetaFileA( HMETAFILE , LPCSTR );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "e9f97591-697b-47d0-a748-60fda4d5258c")]
|
|
public static extern SafeHMETAFILE CopyMetaFile(HMETAFILE arg1, string arg2);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>CreateEnhMetaFile</c> function creates a device context for an enhanced-format metafile. This device context can be used
|
|
/// to store a device-independent picture.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hdc">
|
|
/// <para>
|
|
/// A handle to a reference device for the enhanced metafile. This parameter can be <c>NULL</c>; for more information, see Remarks.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="lpFilename">
|
|
/// <para>
|
|
/// A pointer to the file name for the enhanced metafile to be created. If this parameter is <c>NULL</c>, the enhanced metafile is
|
|
/// memory based and its contents are lost when it is deleted by using the DeleteEnhMetaFile function.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="lprc">
|
|
/// <para>
|
|
/// A pointer to a RECT structure that specifies the dimensions (in .01-millimeter units) of the picture to be stored in the enhanced metafile.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="lpDesc">
|
|
/// <para>
|
|
/// A pointer to a string that specifies the name of the application that created the picture, as well as the picture's title. This
|
|
/// parameter can be <c>NULL</c>; for more information, see Remarks.
|
|
/// </para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to the device context for the enhanced metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Where text arguments must use Unicode characters, use the <c>CreateEnhMetaFile</c> function as a wide-character function. Where
|
|
/// text arguments must use characters from the Windows character set, use this function as an ANSI function.
|
|
/// </para>
|
|
/// <para>
|
|
/// The system uses the reference device identified by the hdcRef parameter to record the resolution and units of the device on which
|
|
/// a picture originally appeared. If the hdcRef parameter is <c>NULL</c>, it uses the current display device for reference.
|
|
/// </para>
|
|
/// <para>
|
|
/// The <c>left</c> and <c>top</c> members of the RECT structure pointed to by the <paramref name="lprc"/> parameter must be less
|
|
/// than the <c>right</c> and <c>bottom</c> members, respectively. Points along the edges of the rectangle are included in the
|
|
/// picture. If <paramref name="lprc"/> is <c>NULL</c>, the graphics device interface (GDI) computes the dimensions of the smallest
|
|
/// rectangle that surrounds the picture drawn by the application. The <paramref name="lprc"/> parameter should be provided where possible.
|
|
/// </para>
|
|
/// <para>
|
|
/// The string pointed to by the lpDescription parameter must contain a null character between the application name and the picture
|
|
/// name and must terminate with two null characters for example, "XYZ Graphics Editor\0Bald Eagle\0\0", where \0 represents the null
|
|
/// character. If lpDescription is <c>NULL</c>, there is no corresponding entry in the enhanced-metafile header.
|
|
/// </para>
|
|
/// <para>
|
|
/// Applications use the device context created by this function to store a graphics picture in an enhanced metafile. The handle
|
|
/// identifying this device context can be passed to any GDI function.
|
|
/// </para>
|
|
/// <para>
|
|
/// After an application stores a picture in an enhanced metafile, it can display the picture on any output device by calling the
|
|
/// PlayEnhMetaFile function. When displaying the picture, the system uses the rectangle pointed to by the <paramref name="lprc"/>
|
|
/// parameter and the resolution data from the reference device to position and scale the picture.
|
|
/// </para>
|
|
/// <para>The device context returned by this function contains the same default attributes associated with any new device context.</para>
|
|
/// <para>Applications must use the GetWinMetaFileBits function to convert an enhanced metafile to the older Windows metafile format.</para>
|
|
/// <para>The file name for the enhanced metafile should use the .emf extension.</para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see Creating an Enhanced Metafile.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-createenhmetafilea HDC CreateEnhMetaFileA( HDC hdc, LPCSTR
|
|
// lpFilename, const RECT *lprc, LPCSTR lpDesc );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "647f83ca-dca3-44af-a594-5f9ba2bd7607")]
|
|
public static extern SafeHDC CreateEnhMetaFile([Optional] HDC hdc, [Optional] string lpFilename, [In, Optional] PRECT lprc, [Optional] string lpDesc);
|
|
|
|
/// <summary>
|
|
/// <para>The <c>CreateMetaFile</c> function creates a device context for a Windows-format metafile.</para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is CreateEnhMetaFile.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="pszFile">
|
|
/// A pointer to the file name for the Windows-format metafile to be created. If this parameter is <c>NULL</c>, the Windows-format
|
|
/// metafile is memory based and its contents are lost when it is deleted by using the DeleteMetaFile function.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to the device context for the Windows-format metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Where text arguments must use Unicode characters, use the <c>CreateMetaFile</c> function as a wide-character function. Where text
|
|
/// arguments must use characters from the Windows character set, use this function as an ANSI function.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>CreateMetaFile</c> is a Windows-format metafile function. This function supports only 16-bit Windows-based applications, which
|
|
/// are listed in Windows-Format Metafiles. It does not record or play back GDI functions such as PolyBezier, which were not part of
|
|
/// 16-bit Windows.
|
|
/// </para>
|
|
/// <para>
|
|
/// The device context created by this function can be used to record GDI output functions in a Windows-format metafile. It cannot be
|
|
/// used with GDI query functions such as GetTextColor. When the device context is used with a GDI output function, the return value
|
|
/// of that function becomes <c>TRUE</c> if the function is recorded and <c>FALSE</c> otherwise. When an object is selected by using
|
|
/// the SelectObject function, only a copy of the object is recorded. The object still belongs to the application.
|
|
/// </para>
|
|
/// <para>
|
|
/// To create a scalable Windows-format metafile, record the graphics output in the MM_ANISOTROPIC mapping mode. The file cannot
|
|
/// contain functions that modify the viewport origin and extents, nor can it contain device-dependent functions such as the
|
|
/// SelectClipRgn function. Once created, the Windows metafile can be scaled and rendered to any output device-format by defining the
|
|
/// viewport origin and extents of the picture before playing it.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createmetafilea HDC CreateMetaFileA( LPCSTR pszFile );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "81b3baae-f0e6-4b71-a6de-953ad3376dbd")]
|
|
public static extern HDC CreateMetaFile(string pszFile);
|
|
|
|
/// <summary>
|
|
/// <para>The <c>DeleteEnhMetaFile</c> function deletes an enhanced-format metafile or an enhanced-format metafile handle.</para>
|
|
/// </summary>
|
|
/// <param name="hmf">
|
|
/// <para>A handle to an enhanced metafile.</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>
|
|
/// If the hemf parameter identifies an enhanced metafile stored in memory, the <c>DeleteEnhMetaFile</c> function deletes the
|
|
/// metafile. If hemf identifies a metafile stored on a disk, the function deletes the metafile handle but does not destroy the
|
|
/// actual metafile. An application can retrieve the file by calling the GetEnhMetaFile function.
|
|
/// </para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see Opening an Enhanced Metafile and Displaying Its Contents.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-deleteenhmetafile BOOL DeleteEnhMetaFile( HENHMETAFILE hmf );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "d3b93b3b-fa0b-4480-8348-19919c9e904d")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DeleteEnhMetaFile(HENHMETAFILE hmf);
|
|
|
|
/// <summary>
|
|
/// <para>The <c>DeleteMetaFile</c> function deletes a Windows-format metafile or Windows-format metafile handle.</para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is DeleteEnhMetaFile.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hmf">A handle to a Windows-format metafile.</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>
|
|
/// If the metafile identified by the hmf parameter is stored in memory (rather than on a disk), its content is lost when it is
|
|
/// deleted by using the <c>DeleteMetaFile</c> function.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-deletemetafile BOOL DeleteMetaFile( HMETAFILE hmf );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "51766282-f185-4e29-a36e-1069d9d61f7c")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DeleteMetaFile(HMETAFILE hmf);
|
|
|
|
/// <summary>
|
|
/// The <c>EnumEnhMetaFile</c> function enumerates the records within an enhanced-format metafile by retrieving each record and
|
|
/// passing it to the specified callback function. The application-supplied callback function processes each record as required. The
|
|
/// enumeration continues until the last record is processed or when the callback function returns zero.
|
|
/// </summary>
|
|
/// <param name="hdc">A handle to a device context. This handle is passed to the callback function.</param>
|
|
/// <param name="hmf">A handle to an enhanced metafile.</param>
|
|
/// <param name="proc">A pointer to the application-supplied callback function. For more information, see the EnhMetaFileProc function.</param>
|
|
/// <param name="param">A pointer to optional callback-function data.</param>
|
|
/// <param name="lpRect">
|
|
/// A pointer to a RECT structure that specifies the coordinates, in logical units, of the picture's upper-left and lower-right corners.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the callback function successfully enumerates all the records in the enhanced metafile, the return value is nonzero.</para>
|
|
/// <para>
|
|
/// If the callback function does not successfully enumerate all the records in the enhanced metafile, the return value is zero.
|
|
/// </para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Points along the edge of the rectangle pointed to by the lpRect parameter are included in the picture. If the hdc parameter is
|
|
/// <c>NULL</c>, the system ignores lpRect.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the callback function calls the PlayEnhMetaFileRecord function, hdc must identify a valid device context. The system uses the
|
|
/// device context's transformation and mapping mode to transform the picture displayed by the <c>PlayEnhMetaFileRecord</c> function.
|
|
/// </para>
|
|
/// <para>You can use the <c>EnumEnhMetaFile</c> function to embed one enhanced-metafile within another.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-enumenhmetafile BOOL EnumEnhMetaFile( HDC hdc, HENHMETAFILE
|
|
// hmf, ENHMFENUMPROC proc, LPVOID param, const RECT *lpRect );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "bef5f43e-219a-4f8a-986d-290e29e17c4e")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool EnumEnhMetaFile([Optional] HDC hdc, HENHMETAFILE hmf, EnhMetaFileProc proc, [Optional] IntPtr param, [In, Optional] PRECT lpRect);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>EnumMetaFile</c> function enumerates the records within a Windows-format metafile by retrieving each record and passing it
|
|
/// to the specified callback function. The application-supplied callback function processes each record as required. The enumeration
|
|
/// continues until the last record is processed or when the callback function returns zero.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is EnumEnhMetaFile.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hdc">Handle to a device context. This handle is passed to the callback function.</param>
|
|
/// <param name="hmf">Handle to a Windows-format metafile.</param>
|
|
/// <param name="proc">Pointer to an application-supplied callback function. For more information, see EnumMetaFileProc.</param>
|
|
/// <param name="param">Pointer to optional data.</param>
|
|
/// <returns>
|
|
/// <para>If the callback function successfully enumerates all the records in the Windows-format metafile, the return value is nonzero.</para>
|
|
/// <para>
|
|
/// If the callback function does not successfully enumerate all the records in the Windows-format metafile, the return value is zero.
|
|
/// </para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>To convert a Windows-format metafile into an enhanced-format metafile, use the SetWinMetaFileBits function.</para>
|
|
/// <para>You can use the <c>EnumMetaFile</c> function to embed one Windows-format metafile within another.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-enummetafile BOOL EnumMetaFile( HDC hdc, HMETAFILE hmf,
|
|
// MFENUMPROC proc, LPARAM param );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "b11c7467-64a9-442b-8dee-26e15f64a26b")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool EnumMetaFile([Optional] HDC hdc, HMETAFILE hmf, EnumMetaFileProc proc, [Optional] IntPtr param);
|
|
|
|
/// <summary>The <c>GdiComment</c> function copies a comment from a buffer into a specified enhanced-format metafile.</summary>
|
|
/// <param name="hdc">A handle to an enhanced-metafile device context.</param>
|
|
/// <param name="nSize">The length of the comment buffer, in bytes.</param>
|
|
/// <param name="lpData">A pointer to the buffer that contains the comment.</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>
|
|
/// A comment can include any kind of private information, for example, the source of a picture and the date it was created. A
|
|
/// comment should begin with an application signature, followed by the data.
|
|
/// </para>
|
|
/// <para>
|
|
/// Comments should not contain application-specific or position-specific data. Position-specific data specifies the location of a
|
|
/// record, and it should not be included because one metafile may be embedded within another metafile.
|
|
/// </para>
|
|
/// <para>
|
|
/// A public comment is a comment that begins with the comment signature identifier GDICOMMENT_IDENTIFIER. The following public
|
|
/// comments are defined.
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>GDICOMMENT_WINDOWS_METAFILE</term>
|
|
/// <term>
|
|
/// The GDICOMMENT_WINDOWS_METAFILE public comment contains a Windows-format metafile that is equivalent to an enhanced-format
|
|
/// metafile. This comment is written only by the SetWinMetaFileBits function. The comment record, if given, follows the
|
|
/// ENHMETAHEADER metafile record. The comment has the following form:
|
|
/// </term>
|
|
/// </listheader>
|
|
/// </list>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>GDICOMMENT_BEGINGROUP</term>
|
|
/// <term>
|
|
/// The GDICOMMENT_BEGINGROUP public comment identifies the beginning of a group of drawing records. It identifies an object within
|
|
/// an enhanced metafile. The comment has the following form:
|
|
/// </term>
|
|
/// </listheader>
|
|
/// </list>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>GDICOMMENT_ENDGROUP</term>
|
|
/// <term>
|
|
/// The GDICOMMENT_ENDGROUP public comment identifies the end of a group of drawing records. The GDICOMMENT_BEGINGROUP comment and
|
|
/// the GDICOMMENT_ENDGROUP comment must be included in a pair and may be nested. The comment has the following form:
|
|
/// </term>
|
|
/// </listheader>
|
|
/// </list>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gdicomment BOOL GdiComment( HDC hdc, UINT nSize, const BYTE
|
|
// *lpData );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "80ed11fc-89f8-47ab-8b3b-c817733bd385")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool GdiComment(HDC hdc, uint nSize, [In] byte[] lpData);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>GetEnhMetaFile</c> function creates a handle that identifies the enhanced-format metafile stored in the specified file.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="lpName">
|
|
/// <para>A pointer to a null-terminated string that specifies the name of an enhanced metafile.</para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to the enhanced metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// When the application no longer needs an enhanced-metafile handle, it should delete the handle by calling the DeleteEnhMetaFile function.
|
|
/// </para>
|
|
/// <para>
|
|
/// A Windows-format metafile must be converted to the enhanced format before it can be processed by the <c>GetEnhMetaFile</c>
|
|
/// function. To convert the file, use the SetWinMetaFileBits function.
|
|
/// </para>
|
|
/// <para>
|
|
/// Where text arguments must use Unicode characters, use this function as a wide-character function. Where text arguments must use
|
|
/// characters from the Windows character set, use this function as an ANSI function.
|
|
/// </para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see Opening an Enhanced Metafile and Displaying Its Contents.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/wingdi/nf-wingdi-getenhmetafilea HENHMETAFILE GetEnhMetaFileA( LPCSTR lpName );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "bcb9611e-8e4e-4f87-8a1e-dedbe0042821")]
|
|
public static extern SafeHENHMETAFILE GetEnhMetaFile(string lpName);
|
|
|
|
/// <summary>
|
|
/// The <c>GetEnhMetaFileBits</c> function retrieves the contents of the specified enhanced-format metafile and copies them into a buffer.
|
|
/// </summary>
|
|
/// <param name="hEMF">A handle to the enhanced metafile.</param>
|
|
/// <param name="nSize">The size, in bytes, of the buffer to receive the data.</param>
|
|
/// <param name="lpData">
|
|
/// A pointer to a buffer that receives the metafile data. The buffer must be sufficiently large to contain the data. If lpbBuffer is
|
|
/// <c>NULL</c>, the function returns the size necessary to hold the data.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds and the buffer pointer is <c>NULL</c>, the return value is the size of the enhanced metafile, in bytes.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the function succeeds and the buffer pointer is a valid pointer, the return value is the number of bytes copied to the buffer.
|
|
/// </para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// After the enhanced-metafile bits are retrieved, they can be used to create a memory-based metafile by calling the
|
|
/// SetEnhMetaFileBits function.
|
|
/// </para>
|
|
/// <para>
|
|
/// The <c>GetEnhMetaFileBits</c> function does not invalidate the enhanced-metafile handle. The application must call the
|
|
/// DeleteEnhMetaFile function to delete the handle when it is no longer needed.
|
|
/// </para>
|
|
/// <para>
|
|
/// The metafile contents retrieved by this function are in the enhanced format. To retrieve the metafile contents in the Windows
|
|
/// format, use the GetWinMetaFileBits function.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getenhmetafilebits UINT GetEnhMetaFileBits( HENHMETAFILE hEMF,
|
|
// UINT nSize, LPBYTE lpData );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "2bbfa0da-5b1e-4843-9777-c2e4c5fd3b78")]
|
|
public static extern uint GetEnhMetaFileBits(HENHMETAFILE hEMF, uint nSize, byte[] lpData);
|
|
|
|
/// <summary>
|
|
/// The <c>GetEnhMetaFileDescription</c> function retrieves an optional text description from an enhanced-format metafile and copies
|
|
/// the string to the specified buffer.
|
|
/// </summary>
|
|
/// <param name="hemf">A handle to the enhanced metafile.</param>
|
|
/// <param name="cchBuffer">The size, in characters, of the buffer to receive the data. Only this many characters will be copied.</param>
|
|
/// <param name="lpDescription">A pointer to a buffer that receives the optional text description.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the optional text description exists and the buffer pointer is <c>NULL</c>, the return value is the length of the text string,
|
|
/// in characters.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the optional text description exists and the buffer pointer is a valid pointer, the return value is the number of characters
|
|
/// copied into the buffer.
|
|
/// </para>
|
|
/// <para>If the optional text description does not exist, the return value is zero.</para>
|
|
/// <para>If the function fails, the return value is GDI_ERROR.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The optional text description contains two strings, the first identifying the application that created the enhanced metafile and
|
|
/// the second identifying the picture contained in the metafile. The strings are separated by a null character and terminated with
|
|
/// two null charactersfor example, "XYZ Graphics Editor\0Bald Eagle\0\0" where \0 represents the null character.
|
|
/// </para>
|
|
/// <para>
|
|
/// Where text arguments must use Unicode characters, use this function as a wide-character function. Where text arguments must use
|
|
/// characters from the Windows character set, use this function as an ANSI function.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getenhmetafiledescriptiona UINT GetEnhMetaFileDescriptionA(
|
|
// HENHMETAFILE hemf, UINT cchBuffer, LPSTR lpDescription );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "51f4f617-fe53-4463-b222-cb6860d15dd6")]
|
|
public static extern uint GetEnhMetaFileDescription(HENHMETAFILE hemf, uint cchBuffer, StringBuilder lpDescription);
|
|
|
|
/// <summary>
|
|
/// The <c>GetEnhMetaFileHeader</c> function retrieves the record containing the header for the specified enhanced-format metafile.
|
|
/// </summary>
|
|
/// <param name="hemf">A handle to the enhanced metafile for which the header is to be retrieved.</param>
|
|
/// <param name="nSize">The size, in bytes, of the buffer to receive the data. Only this many bytes will be copied.</param>
|
|
/// <param name="lpEnhMetaHeader">
|
|
/// A pointer to an ENHMETAHEADER structure that receives the header record. If this parameter is <c>NULL</c>, the function returns
|
|
/// the size of the header record.
|
|
/// </param>
|
|
/// <returns>
|
|
/// If the function succeeds and the structure pointer is <c>NULL</c>, the return value is the size of the record that contains the
|
|
/// header; if the structure pointer is a valid pointer, the return value is the number of bytes copied. Otherwise, it is zero.
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// An enhanced-metafile header contains such information as the metafile's size, in bytes; the dimensions of the picture stored in
|
|
/// the metafile; the number of records stored in the metafile; the offset to the optional text description; the size of the optional
|
|
/// palette, and the resolution of the device on which the picture was created.
|
|
/// </para>
|
|
/// <para>The record that contains the enhanced-metafile header is always the first record in the metafile.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getenhmetafileheader UINT GetEnhMetaFileHeader( HENHMETAFILE
|
|
// hemf, UINT nSize, LPENHMETAHEADER lpEnhMetaHeader );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "c42bcbe2-2e8f-42bd-a8e3-2827c6563300")]
|
|
public static extern uint GetEnhMetaFileHeader(HENHMETAFILE hemf, uint nSize, IntPtr lpEnhMetaHeader);
|
|
|
|
/// <summary>
|
|
/// The <c>GetEnhMetaFileHeader</c> function retrieves the record containing the header for the specified enhanced-format metafile.
|
|
/// </summary>
|
|
/// <param name="hemf">A handle to the enhanced metafile for which the header is to be retrieved.</param>
|
|
/// <returns>An ENHMETAHEADER structure with the header record.</returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// An enhanced-metafile header contains such information as the metafile's size, in bytes; the dimensions of the picture stored in
|
|
/// the metafile; the number of records stored in the metafile; the offset to the optional text description; the size of the optional
|
|
/// palette, and the resolution of the device on which the picture was created.
|
|
/// </para>
|
|
/// <para>The record that contains the enhanced-metafile header is always the first record in the metafile.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getenhmetafileheader UINT GetEnhMetaFileHeader( HENHMETAFILE
|
|
// hemf, UINT nSize, LPENHMETAHEADER lpEnhMetaHeader );
|
|
[PInvokeData("wingdi.h", MSDNShortId = "c42bcbe2-2e8f-42bd-a8e3-2827c6563300")]
|
|
public static ENHMETAHEADER GetEnhMetaFileHeader(HENHMETAFILE hemf)
|
|
{
|
|
var hdr = ENHMETAHEADER.Default;
|
|
using (var mem = SafeHGlobalHandle.CreateFromStructure(hdr))
|
|
{
|
|
if (GetEnhMetaFileHeader(hemf, hdr.nSize, mem) != hdr.nSize)
|
|
Win32Error.ThrowLastError();
|
|
return mem.ToStructure<ENHMETAHEADER>();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>GetEnhMetaFilePaletteEntries</c> function retrieves optional palette entries from the specified enhanced metafile.
|
|
/// </summary>
|
|
/// <param name="hemf">A handle to the enhanced metafile.</param>
|
|
/// <param name="nNumEntries">The number of entries to be retrieved from the optional palette.</param>
|
|
/// <param name="lpPaletteEntries">
|
|
/// A pointer to an array of PALETTEENTRY structures that receives the palette colors. The array must contain at least as many
|
|
/// structures as there are entries specified by the cEntries parameter.
|
|
/// </param>
|
|
/// <returns>
|
|
/// If the array pointer is <c>NULL</c> and the enhanced metafile contains an optional palette, the return value is the number of
|
|
/// entries in the enhanced metafile's palette; if the array pointer is a valid pointer and the enhanced metafile contains an
|
|
/// optional palette, the return value is the number of entries copied; if the metafile does not contain an optional palette, the
|
|
/// return value is zero. Otherwise, the return value is GDI_ERROR.
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// An application can store an optional palette in an enhanced metafile by calling the CreatePalette and SetPaletteEntries functions
|
|
/// before creating the picture and storing it in the metafile. By doing this, the application can achieve consistent colors when the
|
|
/// picture is displayed on a variety of devices.
|
|
/// </para>
|
|
/// <para>
|
|
/// An application that displays a picture stored in an enhanced metafile can call the <c>GetEnhMetaFilePaletteEntries</c> function
|
|
/// to determine whether the optional palette exists. If it does, the application can call the <c>GetEnhMetaFilePaletteEntries</c>
|
|
/// function a second time to retrieve the palette entries and then create a logical palette (by using the CreatePalette function),
|
|
/// select it into its device context (by using the SelectPalette function), and then realize it (by using the RealizePalette
|
|
/// function). After the logical palette has been realized, calling the PlayEnhMetaFile function displays the picture using its
|
|
/// original colors.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getenhmetafilepaletteentries UINT
|
|
// GetEnhMetaFilePaletteEntries( HENHMETAFILE hemf, UINT nNumEntries, LPPALETTEENTRY lpPaletteEntries );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "2d61fd6a-cebd-457e-ad00-d3e8bd15584a")]
|
|
public static extern uint GetEnhMetaFilePaletteEntries(HENHMETAFILE hemf, uint nNumEntries, [Out] PALETTEENTRY[] lpPaletteEntries);
|
|
|
|
/// <summary>
|
|
/// <para>[GetMetaFile is no longer available for use as of Windows 2000. Instead, use GetEnhMetaFile.]</para>
|
|
/// <para>The <c>GetMetaFile</c> function creates a handle that identifies the metafile stored in the specified file.</para>
|
|
/// </summary>
|
|
/// <param name="lpName">A pointer to a null-terminated string that specifies the name of a metafile.</param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to the metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// This function is not implemented in the Win32 API. It is provided for compatibility with 16-bit versions of Windows. In Win32
|
|
/// applications, use the GetEnhMetaFile function.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getmetafilea HMETAFILE GetMetaFileA( LPCSTR lpName );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, CharSet = CharSet.Auto)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "56A602C4-AE4D-46DE-B5DA-66A68E3A16BF")]
|
|
public static extern SafeHMETAFILE GetMetaFile(string lpName);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>GetMetaFileBitsEx</c> function retrieves the contents of a Windows-format metafile and copies them into the specified buffer.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is GetEnhMetaFileBits.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hMF">A handle to a Windows-format metafile.</param>
|
|
/// <param name="cbBuffer">The size, in bytes, of the buffer to receive the data.</param>
|
|
/// <param name="lpData">
|
|
/// A pointer to a buffer that receives the metafile data. The buffer must be sufficiently large to contain the data. If lpvData is
|
|
/// <c>NULL</c>, the function returns the number of bytes required to hold the data.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds and the buffer pointer is <c>NULL</c>, the return value is the number of bytes required for the buffer;
|
|
/// if the function succeeds and the buffer pointer is a valid pointer, the return value is the number of bytes copied.
|
|
/// </para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// After the Windows-metafile bits are retrieved, they can be used to create a memory-based metafile by calling the
|
|
/// SetMetaFileBitsEx function.
|
|
/// </para>
|
|
/// <para>
|
|
/// The <c>GetMetaFileBitsEx</c> function does not invalidate the metafile handle. An application must delete this handle by calling
|
|
/// the DeleteMetaFile function.
|
|
/// </para>
|
|
/// <para>To convert a Windows-format metafile into an enhanced-format metafile, use the SetWinMetaFileBits function.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getmetafilebitsex UINT GetMetaFileBitsEx( HMETAFILE hMF, UINT
|
|
// cbBuffer, LPVOID lpData );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "6ca6de2e-79cb-4503-a0d7-f616b8e383eb")]
|
|
public static extern uint GetMetaFileBitsEx(HMETAFILE hMF, uint cbBuffer, [In, Optional] byte[] lpData);
|
|
|
|
/// <summary>
|
|
/// The <c>GetWinMetaFileBits</c> function converts the enhanced-format records from a metafile into Windows-format records and
|
|
/// stores the converted records in the specified buffer.
|
|
/// </summary>
|
|
/// <param name="hemf">A handle to the enhanced metafile.</param>
|
|
/// <param name="cbData16">The size, in bytes, of the buffer into which the converted records are to be copied.</param>
|
|
/// <param name="pData16">
|
|
/// A pointer to the buffer that receives the converted records. If lpbBuffer is <c>NULL</c>, <c>GetWinMetaFileBits</c> returns the
|
|
/// number of bytes required to store the converted metafile records.
|
|
/// </param>
|
|
/// <param name="iMapMode">The mapping mode to use in the converted metafile.</param>
|
|
/// <param name="hdcRef">A handle to the reference device context.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds and the buffer pointer is <c>NULL</c>, the return value is the number of bytes required to store the
|
|
/// converted records; if the function succeeds and the buffer pointer is a valid pointer, the return value is the size of the
|
|
/// metafile data in bytes.
|
|
/// </para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// This function converts an enhanced metafile into a Windows-format metafile so that its picture can be displayed in an application
|
|
/// that recognizes the older format.
|
|
/// </para>
|
|
/// <para>The system uses the reference device context to determine the resolution of the converted metafile.</para>
|
|
/// <para>
|
|
/// The <c>GetWinMetaFileBits</c> function does not invalidate the enhanced metafile handle. An application should call the
|
|
/// DeleteEnhMetaFile function to release the handle when it is no longer needed.
|
|
/// </para>
|
|
/// <para>To create a scalable Windows-format metafile, specify MM_ANISOTROPIC as the fnMapMode parameter.</para>
|
|
/// <para>The upper-left corner of the metafile picture is always mapped to the origin of the reference device.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getwinmetafilebits UINT GetWinMetaFileBits( HENHMETAFILE hemf,
|
|
// UINT cbData16, LPBYTE pData16, INT iMapMode, HDC hdcRef );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "db61ea3a-44d0-4769-acb4-05a982d3f06f")]
|
|
public static extern uint GetWinMetaFileBits(HENHMETAFILE hemf, uint cbData16, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pData16, MapMode iMapMode, HDC hdcRef);
|
|
|
|
/// <summary>The <c>PlayEnhMetaFile</c> function displays the picture stored in the specified enhanced-format metafile.</summary>
|
|
/// <param name="hdc">A handle to the device context for the output device on which the picture will appear.</param>
|
|
/// <param name="hmf">A handle to the enhanced metafile.</param>
|
|
/// <param name="lprect">
|
|
/// A pointer to a RECT structure that contains the coordinates of the bounding rectangle used to display the picture. The
|
|
/// coordinates are specified in logical units.
|
|
/// </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>
|
|
/// When an application calls the <c>PlayEnhMetaFile</c> function, the system uses the picture frame in the enhanced-metafile header
|
|
/// to map the picture onto the rectangle pointed to by the lpRect parameter. (This picture may be sheared or rotated by setting the
|
|
/// world transform in the output device before calling <c>PlayEnhMetaFile</c>.) Points along the edges of the rectangle are included
|
|
/// in the picture.
|
|
/// </para>
|
|
/// <para>
|
|
/// An enhanced-metafile picture can be clipped by defining the clipping region in the output device before playing the enhanced metafile.
|
|
/// </para>
|
|
/// <para>
|
|
/// If an enhanced metafile contains an optional palette, an application can achieve consistent colors by setting up a color palette
|
|
/// on the output device before calling <c>PlayEnhMetaFile</c>. To retrieve the optional palette, use the
|
|
/// GetEnhMetaFilePaletteEntries function.
|
|
/// </para>
|
|
/// <para>
|
|
/// An enhanced metafile can be embedded in a newly created enhanced metafile by calling <c>PlayEnhMetaFile</c> and playing the
|
|
/// source enhanced metafile into the device context for the new enhanced metafile.
|
|
/// </para>
|
|
/// <para>
|
|
/// The states of the output device context are preserved by this function. Any object created but not deleted in the enhanced
|
|
/// metafile is deleted by this function.
|
|
/// </para>
|
|
/// <para>
|
|
/// To stop this function, an application can call the CancelDC function from another thread to terminate the operation. In this
|
|
/// case, the function returns <c>FALSE</c>.
|
|
/// </para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see Opening an Enhanced Metafile and Displaying Its Contents.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-playenhmetafile BOOL PlayEnhMetaFile( HDC hdc, HENHMETAFILE
|
|
// hmf, const RECT *lprect );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "51e8937b-0c42-49fe-8930-7af303fce788")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool PlayEnhMetaFile(HDC hdc, HENHMETAFILE hmf, [In, Optional] PRECT lprect);
|
|
|
|
/// <summary>
|
|
/// The <c>PlayEnhMetaFileRecord</c> function plays an enhanced-metafile record by executing the graphics device interface (GDI)
|
|
/// functions identified by the record.
|
|
/// </summary>
|
|
/// <param name="hdc">A handle to the device context passed to the EnumEnhMetaFile function.</param>
|
|
/// <param name="pht">
|
|
/// A pointer to a table of handles to GDI objects used when playing the metafile. The first entry in this table contains the
|
|
/// enhanced-metafile handle.
|
|
/// </param>
|
|
/// <param name="pmr">A pointer to the enhanced-metafile record to be played.</param>
|
|
/// <param name="cht">The number of handles in the handle table.</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>This is an enhanced-metafile function.</para>
|
|
/// <para>
|
|
/// An application typically uses <c>PlayEnhMetaFileRecord</c> in conjunction with the EnumEnhMetaFile function to process and play
|
|
/// an enhanced-format metafile one record at a time.
|
|
/// </para>
|
|
/// <para>
|
|
/// The hdc, lpHandletable, and nHandles parameters must be exactly those passed to the EnhMetaFileProc callback procedure by the
|
|
/// EnumEnhMetaFile function.
|
|
/// </para>
|
|
/// <para>If <c>PlayEnhMetaFileRecord</c> does not recognize a record, it ignores the record and returns <c>TRUE</c>.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-playenhmetafilerecord BOOL PlayEnhMetaFileRecord( HDC hdc,
|
|
// LPHANDLETABLE pht, const ENHMETARECORD *pmr, UINT cht );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "3eec8c8d-b99f-4500-9d18-b819c097f341")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool PlayEnhMetaFileRecord(HDC hdc, [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] HGDIOBJ[] pht, [In] ENHMETARECORD pmr, uint cht);
|
|
|
|
/// <summary>
|
|
/// <para>The <c>PlayMetaFile</c> function displays the picture stored in the given Windows-format metafile on the specified device.</para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is PlayEnhMetaFile.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hdc">Handle to a device context.</param>
|
|
/// <param name="hmf">Handle to a Windows-format metafile.</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>To convert a Windows-format metafile into an enhanced format metafile, use the SetWinMetaFileBits function.</para>
|
|
/// <para>A Windows-format metafile can be played multiple times.</para>
|
|
/// <para>
|
|
/// A Windows-format metafile can be embedded in a second Windows-format metafile by calling the <c>PlayMetaFile</c> function and
|
|
/// playing the source metafile into the device context for the target metafile.
|
|
/// </para>
|
|
/// <para>Any object created but not deleted in the Windows-format metafile is deleted by this function.</para>
|
|
/// <para>
|
|
/// To stop this function, an application can call the CancelDC function from another thread to terminate the operation. In this
|
|
/// case, the function returns <c>FALSE</c>.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-playmetafile BOOL PlayMetaFile( HDC hdc, HMETAFILE hmf );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "044894df-dc8a-41b2-8810-e0a1b8bc19d8")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool PlayMetaFile(HDC hdc, HMETAFILE hmf);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>PlayMetaFileRecord</c> function plays a Windows-format metafile record by executing the graphics device interface (GDI)
|
|
/// function contained within that record.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is PlayEnhMetaFileRecord.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hdc">A handle to a device context.</param>
|
|
/// <param name="lpHandleTable">
|
|
/// A pointer to a HANDLETABLE structure representing the table of handles to GDI objects used when playing the metafile.
|
|
/// </param>
|
|
/// <param name="lpMR">A pointer to the Windows-format metafile record.</param>
|
|
/// <param name="noObjs">The number of handles in the handle table.</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>To convert a Windows-format metafile into an enhanced-format metafile, use the SetWinMetaFileBits function.</para>
|
|
/// <para>
|
|
/// An application typically uses <c>PlayMetaFileRecord</c> in conjunction with the EnumMetaFile function to process and play a
|
|
/// Windows-format metafile one record at a time.
|
|
/// </para>
|
|
/// <para>
|
|
/// The lpHandletable and nHandles parameters must be identical to those passed to the EnumMetaFileProc callback procedure by EnumMetaFile.
|
|
/// </para>
|
|
/// <para>If the <c>PlayMetaFileRecord</c> function does not recognize a record, it ignores the record and returns <c>TRUE</c>.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-playmetafilerecord BOOL PlayMetaFileRecord( HDC hdc,
|
|
// LPHANDLETABLE lpHandleTable, LPMETARECORD lpMR, UINT noObjs );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "bea22981-dc77-4de2-b6dc-d6a4f4b74bbd")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool PlayMetaFileRecord(HDC hdc, [In] HGDIOBJ[] lpHandleTable, METARECORD lpMR, uint noObjs);
|
|
|
|
/// <summary>The <c>SetEnhMetaFileBits</c> function creates a memory-based enhanced-format metafile from the specified data.</summary>
|
|
/// <param name="nSize">Specifies the size, in bytes, of the data provided.</param>
|
|
/// <param name="pb">
|
|
/// Pointer to a buffer that contains enhanced-metafile data. (It is assumed that the data in the buffer was obtained by calling the
|
|
/// GetEnhMetaFileBits function.)
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to a memory-based enhanced metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// When the application no longer needs the enhanced-metafile handle, it should delete the handle by calling the DeleteEnhMetaFile function.
|
|
/// </para>
|
|
/// <para>
|
|
/// The <c>SetEnhMetaFileBits</c> function does not accept metafile data in the Windows format. To import Windows-format metafiles,
|
|
/// use the SetWinMetaFileBits function.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-setenhmetafilebits HENHMETAFILE SetEnhMetaFileBits( UINT
|
|
// nSize, const BYTE *pb );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "0f21ed97-e37f-4b44-a2eb-b8e284b3dc4b")]
|
|
public static extern SafeHENHMETAFILE SetEnhMetaFileBits(uint nSize, [In] byte[] pb);
|
|
|
|
/// <summary>
|
|
/// <para>The <c>SetMetaFileBitsEx</c> function creates a memory-based Windows-format metafile from the supplied data.</para>
|
|
/// <para>
|
|
/// <c>Note</c> This function is provided only for compatibility with Windows-format metafiles. Enhanced-format metafiles provide
|
|
/// superior functionality and are recommended for new applications. The corresponding function for an enhanced-format metafile is SetEnhMetaFileBits.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="cbBuffer">Specifies the size, in bytes, of the Windows-format metafile.</param>
|
|
/// <param name="lpData">
|
|
/// Pointer to a buffer that contains the Windows-format metafile. (It is assumed that the data was obtained by using the
|
|
/// GetMetaFileBitsEx function.)
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to a memory-based Windows-format metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>To convert a Windows-format metafile into an enhanced-format metafile, use the SetWinMetaFileBits function.</para>
|
|
/// <para>
|
|
/// When the application no longer needs the metafile handle returned by <c>SetMetaFileBitsEx</c>, it should delete it by calling the
|
|
/// DeleteMetaFile function.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-setmetafilebitsex HMETAFILE SetMetaFileBitsEx( UINT cbBuffer,
|
|
// const BYTE *lpData );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "232eeba9-f579-4b5f-a31a-416aeb56a909")]
|
|
public static extern SafeHMETAFILE SetMetaFileBitsEx(uint cbBuffer, [In] byte[] lpData);
|
|
|
|
/// <summary>
|
|
/// The <c>SetWinMetaFileBits</c> function converts a metafile from the older Windows format to the new enhanced format and stores
|
|
/// the new metafile in memory.
|
|
/// </summary>
|
|
/// <param name="nSize">The size, in bytes, of the buffer that contains the Windows-format metafile.</param>
|
|
/// <param name="lpMeta16Data">
|
|
/// A pointer to a buffer that contains the Windows-format metafile data. (It is assumed that the data was obtained by using the
|
|
/// GetMetaFileBitsEx or GetWinMetaFileBits function.)
|
|
/// </param>
|
|
/// <param name="hdcRef">A handle to a reference device context.</param>
|
|
/// <param name="lpMFP">
|
|
/// A pointer to a METAFILEPICT structure that contains the suggested size of the metafile picture and the mapping mode that was used
|
|
/// when the picture was created.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to a memory-based enhanced metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Windows uses the reference device context's resolution data and the data in the METAFILEPICT structure to scale a picture. If the
|
|
/// hdcRef parameter is <c>NULL</c>, the system uses resolution data for the current output device. If the lpmfp parameter is
|
|
/// <c>NULL</c>, the system uses the MM_ANISOTROPIC mapping mode to scale the picture so that it fits the entire device surface. The
|
|
/// <c>hMF</c> member of the <c>METAFILEPICT</c> structure is not used.
|
|
/// </para>
|
|
/// <para>
|
|
/// When the application no longer needs the enhanced metafile handle, it should delete it by calling the DeleteEnhMetaFile function.
|
|
/// </para>
|
|
/// <para>The handle returned by this function can be used with other enhanced-metafile functions.</para>
|
|
/// <para>
|
|
/// If the reference device context is not identical to the device in which the metafile was originally created, some GDI functions
|
|
/// that use device units may not draw the picture correctly.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-setwinmetafilebits HENHMETAFILE SetWinMetaFileBits( UINT
|
|
// nSize, const BYTE *lpMeta16Data, HDC hdcRef, const METAFILEPICT *lpMFP );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "b7170c8a-da5f-4946-9c56-da3cffc84567")]
|
|
public static extern SafeHENHMETAFILE SetWinMetaFileBits(uint nSize, [In] byte[] lpMeta16Data, [Optional] HDC hdcRef, in METAFILEPICT lpMFP);
|
|
|
|
/// <summary>
|
|
/// The <c>SetWinMetaFileBits</c> function converts a metafile from the older Windows format to the new enhanced format and stores
|
|
/// the new metafile in memory.
|
|
/// </summary>
|
|
/// <param name="nSize">The size, in bytes, of the buffer that contains the Windows-format metafile.</param>
|
|
/// <param name="lpMeta16Data">
|
|
/// A pointer to a buffer that contains the Windows-format metafile data. (It is assumed that the data was obtained by using the
|
|
/// GetMetaFileBitsEx or GetWinMetaFileBits function.)
|
|
/// </param>
|
|
/// <param name="hdcRef">A handle to a reference device context.</param>
|
|
/// <param name="lpMFP">
|
|
/// A pointer to a METAFILEPICT structure that contains the suggested size of the metafile picture and the mapping mode that was used
|
|
/// when the picture was created.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to a memory-based enhanced metafile.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Windows uses the reference device context's resolution data and the data in the METAFILEPICT structure to scale a picture. If the
|
|
/// hdcRef parameter is <c>NULL</c>, the system uses resolution data for the current output device. If the lpmfp parameter is
|
|
/// <c>NULL</c>, the system uses the MM_ANISOTROPIC mapping mode to scale the picture so that it fits the entire device surface. The
|
|
/// <c>hMF</c> member of the <c>METAFILEPICT</c> structure is not used.
|
|
/// </para>
|
|
/// <para>
|
|
/// When the application no longer needs the enhanced metafile handle, it should delete it by calling the DeleteEnhMetaFile function.
|
|
/// </para>
|
|
/// <para>The handle returned by this function can be used with other enhanced-metafile functions.</para>
|
|
/// <para>
|
|
/// If the reference device context is not identical to the device in which the metafile was originally created, some GDI functions
|
|
/// that use device units may not draw the picture correctly.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-setwinmetafilebits HENHMETAFILE SetWinMetaFileBits( UINT
|
|
// nSize, const BYTE *lpMeta16Data, HDC hdcRef, const METAFILEPICT *lpMFP );
|
|
[DllImport(Lib.Gdi32, SetLastError = true, ExactSpelling = true)]
|
|
[PInvokeData("wingdi.h", MSDNShortId = "b7170c8a-da5f-4946-9c56-da3cffc84567")]
|
|
public static extern SafeHENHMETAFILE SetWinMetaFileBits(uint nSize, [In] byte[] lpMeta16Data, [Optional] HDC hdcRef, [Optional] IntPtr lpMFP);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>ENHMETAHEADER</c> structure contains enhanced-metafile data such as the dimensions of the picture stored in the enhanced
|
|
/// metafile, the count of records in the enhanced metafile, the resolution of the device on which the picture was created, and so on.
|
|
/// </para>
|
|
/// <para>This structure is always the first record in an enhanced metafile.</para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-enhmetaheader typedef struct tagENHMETAHEADER { DWORD iType;
|
|
// DWORD nSize; RECTL rclBounds; RECTL rclFrame; DWORD dSignature; DWORD nVersion; DWORD nBytes; DWORD nRecords; WORD nHandles; WORD
|
|
// sReserved; DWORD nDescription; DWORD offDescription; DWORD nPalEntries; SIZEL szlDevice; SIZEL szlMillimeters; DWORD
|
|
// cbPixelFormat; DWORD offPixelFormat; DWORD bOpenGL; SIZEL szlMicrometers; } ENHMETAHEADER, *PENHMETAHEADER, *LPENHMETAHEADER;
|
|
[PInvokeData("wingdi.h", MSDNShortId = "8e5f9a51-a995-48be-b936-1766fccb603a")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct ENHMETAHEADER
|
|
{
|
|
/// <summary>The record type. This member must specify the value assigned to the EMR_HEADER constant.</summary>
|
|
public RecordType iType;
|
|
|
|
/// <summary>The structure size, in bytes.</summary>
|
|
public uint nSize;
|
|
|
|
/// <summary>
|
|
/// The dimensions, in device units, of the smallest rectangle that can be drawn around the picture stored in the metafile. This
|
|
/// rectangle is supplied by graphics device interface (GDI). Its dimensions include the right and bottom edges.
|
|
/// </summary>
|
|
public RECT rclBounds;
|
|
|
|
/// <summary>
|
|
/// The dimensions, in .01 millimeter units, of a rectangle that surrounds the picture stored in the metafile. This rectangle
|
|
/// must be supplied by the application that creates the metafile. Its dimensions include the right and bottom edges.
|
|
/// </summary>
|
|
public RECT rclFrame;
|
|
|
|
/// <summary>A signature. This member must specify the value assigned to the ENHMETA_SIGNATURE constant.</summary>
|
|
public uint dSignature;
|
|
|
|
/// <summary>The metafile version. The current version value is 0x10000.</summary>
|
|
public uint nVersion;
|
|
|
|
/// <summary>The size of the enhanced metafile, in bytes.</summary>
|
|
public uint nBytes;
|
|
|
|
/// <summary>The number of records in the enhanced metafile.</summary>
|
|
public uint nRecords;
|
|
|
|
/// <summary>The number of handles in the enhanced-metafile handle table. (Index zero in this table is reserved.)</summary>
|
|
public ushort nHandles;
|
|
|
|
/// <summary>Reserved; must be zero.</summary>
|
|
public ushort sReserved;
|
|
|
|
/// <summary>
|
|
/// The number of characters in the array that contains the description of the enhanced metafile's contents. This member should
|
|
/// be set to zero if the enhanced metafile does not contain a description string.
|
|
/// </summary>
|
|
public uint nDescription;
|
|
|
|
/// <summary>
|
|
/// The offset from the beginning of the <c>ENHMETAHEADER</c> structure to the array that contains the description of the
|
|
/// enhanced metafile's contents. This member should be set to zero if the enhanced metafile does not contain a description string.
|
|
/// </summary>
|
|
public uint offDescription;
|
|
|
|
/// <summary>The number of entries in the enhanced metafile's palette.</summary>
|
|
public uint nPalEntries;
|
|
|
|
/// <summary>The resolution of the reference device, in pixels.</summary>
|
|
public SIZE szlDevice;
|
|
|
|
/// <summary>The resolution of the reference device, in millimeters.</summary>
|
|
public SIZE szlMillimeters;
|
|
|
|
/// <summary>
|
|
/// The size of the last recorded pixel format in a metafile. If a pixel format is set in a reference DC at the start of
|
|
/// recording, cbPixelFormat is set to the size of the PIXELFORMATDESCRIPTOR. When no pixel format is set when a metafile is
|
|
/// recorded, this member is set to zero. If more than a single pixel format is set, the header points to the last pixel format.
|
|
/// </summary>
|
|
public uint cbPixelFormat;
|
|
|
|
/// <summary>
|
|
/// The offset of pixel format used when recording a metafile. If a pixel format is set in a reference DC at the start of
|
|
/// recording or during recording, offPixelFormat is set to the offset of the PIXELFORMATDESCRIPTOR in the metafile. If no pixel
|
|
/// format is set when a metafile is recorded, this member is set to zero. If more than a single pixel format is set, the header
|
|
/// points to the last pixel format.
|
|
/// </summary>
|
|
public uint offPixelFormat;
|
|
|
|
/// <summary>
|
|
/// Indicates whether any OpenGL records are present in a metafile. bOpenGL is a simple Boolean flag that you can use to
|
|
/// determine whether an enhanced metafile requires OpenGL handling. When a metafile contains OpenGL records, bOpenGL is
|
|
/// <c>TRUE</c>; otherwise it is <c>FALSE</c>.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.Bool)]
|
|
public bool bOpenGL;
|
|
|
|
/// <summary>The size of the reference device, in micrometers.</summary>
|
|
public SIZE szlMicrometers;
|
|
|
|
/// <summary>A default instance of the structure with the size field preset.</summary>
|
|
public static readonly ENHMETAHEADER Default = new ENHMETAHEADER { nSize = (uint)Marshal.SizeOf(typeof(ENHMETAHEADER)) };
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>HANDLETABLE</c> structure is an array of handles, each of which identifies a graphics device interface (GDI) object.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-handletable typedef struct tagHANDLETABLE { HGDIOBJ
|
|
// objectHandle[1]; } HANDLETABLE, *PHANDLETABLE, *LPHANDLETABLE;
|
|
[PInvokeData("wingdi.h", MSDNShortId = "c0c03c7d-baac-4b59-ba2f-8f6330651b49")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct HANDLETABLE
|
|
{
|
|
/// <summary>An array of handles.</summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
|
|
public HGDIOBJ[] objectHandle;
|
|
}
|
|
|
|
/// <summary>Defines the metafile picture format used for exchanging metafile data through the clipboard.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-metafilepict typedef struct tagMETAFILEPICT { LONG mm; LONG
|
|
// xExt; LONG yExt; HMETAFILE hMF; } METAFILEPICT, *LPMETAFILEPICT;
|
|
[PInvokeData("wingdi.h")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct METAFILEPICT
|
|
{
|
|
/// <summary>
|
|
/// <para>Type: <c>LONG</c></para>
|
|
/// <para>The mapping mode in which the picture is drawn.</para>
|
|
/// </summary>
|
|
public MapMode mm;
|
|
|
|
/// <summary>
|
|
/// <para>Type: <c>LONG</c></para>
|
|
/// <para>
|
|
/// The size of the metafile picture for all modes except the <c>MM_ISOTROPIC</c> and <c>MM_ANISOTROPIC</c> modes. (For more
|
|
/// information about these modes, see the <c>yExt</c> member.) The x-extent specifies the width of the rectangle within which
|
|
/// the picture is drawn. The coordinates are in units that correspond to the mapping mode.
|
|
/// </para>
|
|
/// </summary>
|
|
public int xExt;
|
|
|
|
/// <summary>
|
|
/// <para>Type: <c>LONG</c></para>
|
|
/// <para>
|
|
/// The size of the metafile picture for all modes except the <c>MM_ISOTROPIC</c> and <c>MM_ANISOTROPIC</c> modes. The y-extent
|
|
/// specifies the height of the rectangle within which the picture is drawn. The coordinates are in units that correspond to the
|
|
/// mapping mode. For <c>MM_ISOTROPIC</c> and <c>MM_ANISOTROPIC</c> modes, which can be scaled, the <c>xExt</c> and <c>yExt</c>
|
|
/// members contain an optional suggested size in <c>MM_HIMETRIC</c> units. For <c>MM_ANISOTROPIC</c> pictures, <c>xExt</c> and
|
|
/// <c>yExt</c> can be zero when no suggested size is supplied. For <c>MM_ISOTROPIC</c> pictures, an aspect ratio must be
|
|
/// supplied even when no suggested size is given. (If a suggested size is given, the aspect ratio is implied by the size.) To
|
|
/// give an aspect ratio without implying a suggested size, set <c>xExt</c> and <c>yExt</c> to negative values whose ratio is the
|
|
/// appropriate aspect ratio. The magnitude of the negative <c>xExt</c> and <c>yExt</c> values is ignored; only the ratio is used.
|
|
/// </para>
|
|
/// </summary>
|
|
public int yExt;
|
|
|
|
/// <summary>
|
|
/// <para>Type: <c>HMETAFILE</c></para>
|
|
/// <para>A handle to a memory metafile.</para>
|
|
/// </summary>
|
|
public HMETAFILE hMF;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>ENHMETARECORD</c> structure contains data that describes a graphics device interface (GDI) function used to create part of
|
|
/// a picture in an enhanced-format metafile.
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-enhmetarecord typedef struct tagENHMETARECORD { DWORD iType;
|
|
// DWORD nSize; DWORD dParm[1]; } ENHMETARECORD, *PENHMETARECORD, *LPENHMETARECORD;
|
|
[PInvokeData("wingdi.h", MSDNShortId = "efe49094-fe61-40e1-873e-3302c595717e")]
|
|
public class ENHMETARECORD : SafeNativeArray<uint>
|
|
{
|
|
/// <summary>Initializes a new instance of the <see cref="ENHMETARECORD"/> class.</summary>
|
|
/// <param name="type">The record type.</param>
|
|
/// <param name="parameters">An array of parameters passed to the GDI function identified by the record.</param>
|
|
public ENHMETARECORD(RecordType type, uint[] parameters) : base(parameters, 8)
|
|
{
|
|
handle.Write(type);
|
|
handle.Write((uint)Size, 4);
|
|
}
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="ENHMETARECORD"/> class.</summary>
|
|
private ENHMETARECORD(IntPtr ptr) : base(ptr, 0, false, 8, 0, true)
|
|
{
|
|
sz = handle.ToStructure<uint>(0, 4);
|
|
base.Count = (int)(Size - base.HeaderSize) / 4;
|
|
}
|
|
|
|
/// <summary>An array of parameters passed to the GDI function identified by the record.</summary>
|
|
public uint[] dParm => base.Elements;
|
|
|
|
/// <summary>The record type.</summary>
|
|
public RecordType iType => handle.ToStructure<RecordType>();
|
|
|
|
/// <summary>The size of the record, in bytes.</summary>
|
|
public uint nSize => Size;
|
|
|
|
/// <summary>Performs an explicit conversion from <see cref="IntPtr"/> to <see cref="ENHMETARECORD"/>.</summary>
|
|
/// <param name="ptr">The pointer to an instance.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static explicit operator ENHMETARECORD(IntPtr ptr) => new ENHMETARECORD(ptr);
|
|
}
|
|
|
|
/// <summary>The <c>METARECORD</c> structure contains a Windows-format metafile record.</summary>
|
|
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-metarecord typedef struct tagMETARECORD { DWORD rdSize; WORD
|
|
// rdFunction; WORD rdParm[1]; } METARECORD, *PMETARECORD, *LPMETARECORD;
|
|
[PInvokeData("wingdi.h", MSDNShortId = "7c5d6e97-dff1-4c80-a7d3-082413dca469")]
|
|
public class METARECORD : SafeNativeArray<ushort>
|
|
{
|
|
/// <summary>Initializes a new instance of the <see cref="METARECORD"/> class.</summary>
|
|
/// <param name="functionNumber">The function number.</param>
|
|
/// <param name="parameters">An array of parameters passed to the GDI function identified by the record.</param>
|
|
public METARECORD(ushort functionNumber, ushort[] parameters) : base(parameters, 6)
|
|
{
|
|
handle.Write(Size / 2U);
|
|
handle.Write(functionNumber, 4);
|
|
}
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="ENHMETARECORD"/> class.</summary>
|
|
private METARECORD(IntPtr ptr) : base(ptr, 0, false, 6, 0, true)
|
|
{
|
|
sz = handle.ToStructure<uint>() * 2U;
|
|
base.Count = (int)(Size - base.HeaderSize) / 2;
|
|
}
|
|
|
|
/// <summary>The function number.</summary>
|
|
public ushort rdFunction => handle.ToStructure<ushort>(Size, 4);
|
|
|
|
/// <summary>An array of words containing the function parameters, in reverse of the order they are passed to the function.</summary>
|
|
public ushort[] rdParm => base.Elements;
|
|
|
|
/// <summary>The size, in words, of the record.</summary>
|
|
public uint rdSize => Size / 2U;
|
|
|
|
/// <summary>Performs an explicit conversion from <see cref="IntPtr"/> to <see cref="METARECORD"/>.</summary>
|
|
/// <param name="ptr">The pointer to an instance.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static explicit operator METARECORD(IntPtr ptr) => new METARECORD(ptr);
|
|
}
|
|
|
|
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="HENHMETAFILE"/> that is disposed using <see cref="DeleteEnhMetaFile"/>.</summary>
|
|
public class SafeHENHMETAFILE : SafeHANDLE
|
|
{
|
|
/// <summary>Initializes a new instance of the <see cref="SafeHENHMETAFILE"/> class and assigns an existing handle.</summary>
|
|
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
|
/// <param name="ownsHandle">
|
|
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
|
|
/// </param>
|
|
public SafeHENHMETAFILE(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="SafeHENHMETAFILE"/> class.</summary>
|
|
private SafeHENHMETAFILE() : base() { }
|
|
|
|
/// <summary>Performs an implicit conversion from <see cref="SafeHENHMETAFILE"/> to <see cref="HENHMETAFILE"/>.</summary>
|
|
/// <param name="h">The safe handle instance.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static implicit operator HENHMETAFILE(SafeHENHMETAFILE h) => h.handle;
|
|
|
|
/// <inheritdoc/>
|
|
protected override bool InternalReleaseHandle() => DeleteEnhMetaFile(this);
|
|
}
|
|
|
|
/// <summary>Provides a <see cref="SafeHandle"/> for <see cref="HMETAFILE"/> that is disposed using <see cref="DeleteMetaFile"/>.</summary>
|
|
public class SafeHMETAFILE : SafeHANDLE
|
|
{
|
|
/// <summary>Initializes a new instance of the <see cref="SafeHMETAFILE"/> class and assigns an existing handle.</summary>
|
|
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
|
/// <param name="ownsHandle">
|
|
/// <see langword="true"/> to reliably release the handle during the finalization phase; otherwise, <see langword="false"/> (not recommended).
|
|
/// </param>
|
|
public SafeHMETAFILE(IntPtr preexistingHandle, bool ownsHandle = true) : base(preexistingHandle, ownsHandle) { }
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="SafeHMETAFILE"/> class.</summary>
|
|
private SafeHMETAFILE() : base() { }
|
|
|
|
/// <summary>Performs an implicit conversion from <see cref="SafeHMETAFILE"/> to <see cref="HMETAFILE"/>.</summary>
|
|
/// <param name="h">The safe handle instance.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static implicit operator HMETAFILE(SafeHMETAFILE h) => h.handle;
|
|
|
|
/// <inheritdoc/>
|
|
protected override bool InternalReleaseHandle() => DeleteMetaFile(handle);
|
|
}
|
|
}
|
|
} |