sean-m
/
Vanara
mirror of https://github.com/dahall/Vanara.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Vanara/PInvoke/Gdi32/WinGdi.FontText.cs

6022 lines
288 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Text;
using Vanara.Extensions;
using Vanara.InteropServices;
namespace Vanara.PInvoke
{
public static partial class Gdi32
{
/// <summary>Mask for GetFontLanguageInfo results.</summary>
public const ushort FLI_MASK = 0x103B;
/// <summary>Font weight value.</summary>
public const int FW_BOLD = 700;
/// <summary>Font weight value.</summary>
public const int FW_DONTCARE = 0;
/// <summary>Font weight value.</summary>
public const int FW_EXTRABOLD = 800;
/// <summary>Font weight value.</summary>
public const int FW_EXTRALIGHT = 200;
/// <summary>Font weight value.</summary>
public const int FW_HEAVY = 900;
/// <summary>Font weight value.</summary>
public const int FW_LIGHT = 300;
/// <summary>Font weight value.</summary>
public const int FW_MEDIUM = 500;
/// <summary>Font weight value.</summary>
public const int FW_NORMAL = 400;
/// <summary>Font weight value.</summary>
public const int FW_SEMIBOLD = 600;
/// <summary>Font weight value.</summary>
public const int FW_THIN = 100;
/// <summary>Error value for some functions.</summary>
public const uint GCP_ERROR = 0x8000;
/// <summary>Value for <see cref="GCP_RESULTS"/><c>.lpGlyph</c> field.</summary>
public const ushort GCPGLYPH_LINKAFTER = 0x4000;
/// <summary>Value for <see cref="GCP_RESULTS"/><c>.lpGlyph</c> field.</summary>
public const ushort GCPGLYPH_LINKBEFORE = 0x8000;
/// <summary>Represents a generic GDI error.</summary>
public const uint GDI_ERROR = 0xFFFFFFFF;
/// <summary>This function enables or disables support for end-user-defined characters (EUDC).</summary>
/// <param name="fEnableEUDC">Boolean that is set to <c>TRUE</c> to enable EUDC, and to <c>FALSE</c> to disable EUDC.</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 EUDC is disabled, trying to display EUDC characters will result in missing or bad glyphs.</para>
/// <para>During multi-session, this function affects the current session only.</para>
/// <para>It is recommended that you use this function with Windows XP SP2 or later.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/gdi/enableeudc
// BOOL EnableEUDC( _In_ HDC BOOL fEnableEUDC );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("", MSDNShortId = "9e531d8c-6008-4189-ae25-cda707be5e2c")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool EnableEUDC([MarshalAs(UnmanagedType.Bool)] bool fEnableEUDC);
/// <summary>
/// The <c>EnumFontFamExProc</c> function is an application defined callback function used with the <c>EnumFontFamiliesEx</c>
/// function. It is used to process the fonts. It is called once for each enumerated font. The <c>FONTENUMPROC</c> type defines a
/// pointer to this callback function. <c>EnumFontFamExProc</c> is a placeholder for the application defined function name.
/// </summary>
/// <param name="lpelfe">
/// A pointer to an <c>LOGFONT</c> structure that contains information about the logical attributes of the font. To obtain additional
/// information about the font, you can cast the result as an <c>ENUMLOGFONTEX</c> or <c>ENUMLOGFONTEXDV</c> structure.
/// </param>
/// <param name="lpntme">
/// <para>
/// A pointer to a structure that contains information about the physical attributes of a font. The function uses the
/// <c>NEWTEXTMETRICEX</c> structure for TrueType fonts; and the <c>TEXTMETRIC</c> structure for other fonts.
/// </para>
/// <para>This can be an <c>ENUMTEXTMETRIC</c> structure.</para>
/// </param>
/// <param name="FontType">
/// <para>The type of the font. This parameter can be a combination of these values:</para>
/// <para><c>DEVICE_FONTTYPE</c></para>
/// <para><c>RASTER_FONTTYPE</c></para>
/// <para><c>TRUETYPE_FONTTYPE</c></para>
/// </param>
/// <param name="lParam">The application-defined data passed by the <c>EnumFontFamiliesEx</c> function.</param>
/// <returns>
/// The return value must be a nonzero value to continue enumeration; to stop enumeration, the return value must be zero.
/// </returns>
/// <remarks>
/// <para>An application must register this callback function by passing its address to the <c>EnumFontFamiliesEx</c> function.</para>
/// <para>
/// When the graphics mode on the device context is set to GM_ADVANCED using the <c>SetGraphicsMode</c> function and the
/// DEVICE_FONTTYPE flag is passed to the FontType parameter, this function returns a list of type 1 and OpenType fonts on the
/// system. When the graphics mode is not set to GM_ADVANCED, this function returns a list of type 1, OpenType, and TrueType fonts on
/// the system.
/// </para>
/// <para>
/// Unlike the <c>EnumFontFamProc</c> callback function, <c>EnumFontFamExProc</c> receives extended information about a font. The
/// <c>ENUMLOGFONTEX</c> structure includes the localized name of the script (character set) and the <c>NEWTEXTMETRICEX</c> structure
/// includes a font-coverage signature.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/previous-versions/dd162618(v=vs.85) int CALLBACK EnumFontFamExProc( const LOGFONT *lpelfe, const
// TEXTMETRIC *lpntme, DWORD FontType, LPARAM lParam );
[UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Auto)]
[PInvokeData("Wingdi.h")]
public delegate int EnumFontFamExProc(in ENUMLOGFONTEXDV lpelfe, in ENUMTEXTMETRIC lpntme, FontType FontType, IntPtr lParam);
/// <summary>
/// <para>
/// The <c>EnumFontFamProc</c> function is an application defined callback function used with the <c>EnumFontFamilies</c> function.
/// It receives data describing the available fonts. The <c>FONTENUMPROC</c> type defines a pointer to this callback function.
/// <c>EnumFontFamProc</c> is a placeholder for the application definedfunction name.
/// </para>
/// <para>
/// <c>Note</c> This function is provided only for compatibility with 16-bit versions of Windows. Applications should call the
/// <c>EnumFontFamiliesEx</c> function.
/// </para>
/// </summary>
/// <param name="lpelf">
/// <para>[in]</para>
/// <para>
/// A pointer to an <c>ENUMLOGFONT</c> structure that contains information about the logical attributes of the font. This structure
/// is locally defined.
/// </para>
/// <para>This can be an <c>ENUMLOGFONTEXDV</c> structure.</para>
/// </param>
/// <param name="lpntm">
/// <para>[in]</para>
/// <para>
/// A pointer to a <c>NEWTEXTMETRIC</c> structure that contains information about the physical attributes of the font, if the font is
/// a TrueType font. If the font is not a TrueType font, this parameter is a pointer to a <c>TEXTMETRIC</c> structure.
/// </para>
/// <para>This can be an <c>ENUMTEXTMETRIC</c> structure.</para>
/// </param>
/// <param name="FontType">
/// <para>[in]</para>
/// <para>The type of the font. This parameter can be a combination of the following values:</para>
/// <para><c>DEVICE_FONTTYPE</c></para>
/// <para><c>RASTER_FONTTYPE</c></para>
/// <para><c>TRUETYPE_FONTTYPE</c></para>
/// </param>
/// <param name="lParam">
/// <para>[in]</para>
/// <para>A pointer to the application-defined data passed by the <c>EnumFontFamilies</c> function.</para>
/// </param>
/// <returns>The return value must be a nonzero value to continue enumeration; to stop enumeration, it must return zero.</returns>
/// <remarks>
/// <para>An application must register this callback function by passing its address to the <c>EnumFontFamilies</c> function.</para>
/// <para>
/// When the graphics mode on the device context is set to GM_ADVANCED using the <c>SetGraphicsMode</c> function and the
/// DEVICE_FONTTYPE flag is passed to the FontType parameter, this function returns a list of type 1 and OpenType fonts on the
/// system. When the graphics mode is not set to GM_ADVANCED, this function returns a list of type 1, OpenType, and TrueType fonts on
/// the system.
/// </para>
/// <para>
/// The AND (&amp;) operator can be used with the RASTER_FONTTYPE, DEVICE_FONTTYPE, and TRUETYPE_FONTTYPE constants to determine the
/// font type. If the RASTER_FONTTYPE bit is set, the font is a raster font. If the TRUETYPE_FONTTYPE bit is set, the font is a
/// TrueType font. If neither bit is set, the font is a vector font. DEVICE_FONTTYPE is set when a device (for example, a laser
/// printer) supports downloading TrueType fonts or when the font is a device-resident font; it is zero if the device is a display
/// adapter, dot-matrix printer, or other raster device. An application can also use DEVICE_FONTTYPE to distinguish graphics device
/// interface (GDI)-supplied raster fonts from device-supplied fonts. GDI can simulate bold, italic, underline, and strikeout
/// attributes for GDI-supplied raster fonts, but not for device-supplied fonts.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/previous-versions/dd162621%28v%3dvs.85%29 int CALLBACK EnumFontFamProc( _In_ ENUMLOGFONT *lpelf,
// _In_ NEWTEXTMETRIC *lpntm, _In_ DWORD FontType, _In_ LPARAM lParam );
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("Wingdi.h")]
public delegate int EnumFontFamProc(in ENUMLOGFONT lpelf, in NEWTEXTMETRIC lpntm, uint FontType, IntPtr lParam);
/// <summary>
/// <para>
/// The <c>EnumFontsProc</c> function is an application definedcallback function that processes font data from the <c>EnumFonts</c>
/// function. The <c>FONTENUMPROC</c> type defines a pointer to this callback function. <c>EnumFontsProc</c> is a placeholder for the
/// application definedfunction name.
/// </para>
/// <para>
/// <c>Note</c> This function is provided only for compatibility with 16-bit versions of Windows. Applications should call the
/// <c>EnumFontFamiliesEx</c> function.
/// </para>
/// </summary>
/// <param name="lplf">
/// <para>[in]</para>
/// <para>A pointer to a <c>LOGFONT</c> structure that contains information about the logical attributes of the font.</para>
/// <para>This can be an <c>ENUMLOGFONTEXDV</c> structure.</para>
/// </param>
/// <param name="lptm">
/// <para>[in]</para>
/// <para>A pointer to a <c>TEXTMETRIC</c> structure that contains information about the physical attributes of the font.</para>
/// <para>This can be an <c>ENUMTEXTMETRIC</c> structure.</para>
/// </param>
/// <param name="dwType">
/// <para>[in]</para>
/// <para>The type of the font. This parameter can be a combination of the following values:</para>
/// <para><c>DEVICE_FONTTYPE</c></para>
/// <para><c>RASTER_FONTTYPE</c></para>
/// <para><c>TRUETYPE_FONTTYPE</c></para>
/// </param>
/// <param name="lpData">
/// <para>[in]</para>
/// <para>A pointer to the application-defined data passed by <c>EnumFonts</c>.</para>
/// </param>
/// <returns>The return value must be a nonzero value to continue enumeration; to stop enumeration, it must be zero.</returns>
/// <remarks>
/// <para>
/// The AND (&amp;) operator can be used with the RASTER_FONTTYPE and DEVICE_FONTTYPE constants to determine the font type. The
/// RASTER_FONTTYPE bit of the FontType parameter specifies whether the font is a raster or vector font. If the bit is one, the font
/// is a raster font; if zero, it is a vector font. The DEVICE_FONTTYPE bit of FontType specifies whether the font is a device-based
/// or graphics device interface (GDI)-based font. If the bit is one, the font is a device-based font; if zero, it is a GDI-based font.
/// </para>
/// <para>
/// If the device is capable of text transformations (scaling, italicizing, and so on) only the base font is enumerated. The user
/// must inquire into the device's text-transformation abilities to determine which additional fonts are available directly from the device.
/// </para>
/// <para>An application must register the <c>EnumFontsProc</c> function by passing its address to the <c>EnumFonts</c> function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/previous-versions/dd162623(v=vs.85) int CALLBACK EnumFontsProc( _In_ const LOGFONT *lplf, _In_
// const TEXTMETRIC *lptm, _In_ DWORD dwType, _In_ LPARAM lpData );
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("Wingdi.h")]
public delegate int EnumFontsProc(in LOGFONT lplf, in TEXTMETRIC lptm, uint dwType, IntPtr lpData);
/// <summary>The character set (4-bytes).</summary>
[PInvokeData("Wingdi.h", MSDNShortId = "dd145037")]
public enum CharacterSetUint : uint
{
/// <summary>Specifies the English character set.</summary>
ANSI_CHARSET = 0,
/// <summary>
/// Specifies a character set based on the current system locale; for example, when the system locale is United States English,
/// the default character set is ANSI_CHARSET.
/// </summary>
DEFAULT_CHARSET = 1,
/// <summary>Specifies a character set of symbols.</summary>
SYMBOL_CHARSET = 2,
/// <summary>Specifies the Japanese character set.</summary>
SHIFTJIS_CHARSET = 128,
/// <summary>Specifies the Hangul Korean character set.</summary>
HANGEUL_CHARSET = 129,
/// <summary>Also spelled "Hangeul". Specifies the Hangul Korean character set.</summary>
HANGUL_CHARSET = 129,
/// <summary>Specifies the "simplified" Chinese character set for People's Republic of China.</summary>
GB2312_CHARSET = 134,
/// <summary>
/// Specifies the "traditional" Chinese character set, used mostly in Taiwan and in the Hong Kong and Macao Special
/// Administrative Regions.
/// </summary>
CHINESEBIG5_CHARSET = 136,
/// <summary>Specifies a mapping to one of the OEM code pages, according to the current system locale setting.</summary>
OEM_CHARSET = 255,
/// <summary>Also spelled "Johap". Specifies the Johab Korean character set.</summary>
JOHAB_CHARSET = 130,
/// <summary>Specifies the Hebrew character set.</summary>
HEBREW_CHARSET = 177,
/// <summary>Specifies the Arabic character set.</summary>
ARABIC_CHARSET = 178,
/// <summary>Specifies the Greek character set.</summary>
GREEK_CHARSET = 161,
/// <summary>Specifies the Turkish character set.</summary>
TURKISH_CHARSET = 162,
/// <summary>Specifies the Vietnamese character set.</summary>
VIETNAMESE_CHARSET = 163,
/// <summary>Specifies the Thai character set.</summary>
THAI_CHARSET = 222,
/// <summary>Specifies a Eastern European character set.</summary>
EASTEUROPE_CHARSET = 238,
/// <summary>Specifies the Russian Cyrillic character set.</summary>
RUSSIAN_CHARSET = 204,
/// <summary>Specifies the Apple Macintosh character set.</summary>
MAC_CHARSET = 77,
/// <summary>Specifies the Baltic (Northeastern European) character set.</summary>
BALTIC_CHARSET = 186
}
/// <summary>The clipping precision defines how to clip characters that are partially outside the clipping region.</summary>
[PInvokeData("Wingdi.h", MSDNShortId = "dd145037")]
public enum ClippingPrecision : byte
{
/// <summary>Not used.</summary>
CLIP_CHARACTER_PRECIS = 1,
/// <summary>Specifies default clipping behavior.</summary>
CLIP_DEFAULT_PRECIS = 0,
/// <summary>
/// Windows XP SP1: Turns off font association for the font. Note that this flag is not guaranteed to have any effect on any
/// platform after Windows Server 2003.
/// </summary>
CLIP_DFA_DISABLE = 4 << 4,
/// <summary>
/// Turns off font association for the font. This is identical to CLIP_DFA_DISABLE, but it can have problems in some situations;
/// the recommended flag to use is CLIP_DFA_DISABLE.
/// </summary>
CLIP_DFA_OVERRIDE = 64,
/// <summary>You must specify this flag to use an embedded read-only font.</summary>
CLIP_EMBEDDED = 8 << 4,
/// <summary>
/// When this value is used, the rotation for all fonts depends on whether the orientation of the coordinate system is
/// left-handed or right-handed. If not used, device fonts always rotate counterclockwise, but the rotation of other fonts is
/// dependent on the orientation of the coordinate system.
/// </summary>
CLIP_LH_ANGLES = 1 << 4,
/// <summary>Not used.</summary>
CLIP_MASK = 0xf,
/// <summary>
/// Not used by the font mapper, but is returned when raster, vector, or TrueType fonts are enumerated. For compatibility, this
/// value is always returned when enumerating fonts.
/// </summary>
CLIP_STROKE_PRECIS = 2,
/// <summary>Not used.</summary>
CLIP_TT_ALWAYS = 2 << 4,
}
/// <summary>Options for <see cref="ExtTextOut"/>.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "74f8fcb8-8ad4-47f2-a330-fa56713bdb37")]
[Flags]
public enum ETO
{
/// <summary>The current background color should be used to fill the rectangle.</summary>
ETO_OPAQUE = 0x0002,
/// <summary>The text will be clipped to the rectangle.</summary>
ETO_CLIPPED = 0x0004,
/// <summary>
/// The lpString array refers to an array returned from GetCharacterPlacement and should be parsed directly by GDI as no further
/// language-specific processing is required. Glyph indexing only applies to TrueType fonts, but the flag can be used for bitmap
/// and vector fonts to indicate that no further language processing is necessary and GDI should process the string directly.
/// Note that all glyph indexes are 16-bit values even though the string is assumed to be an array of 8-bit values for raster
/// fonts. For ExtTextOutW, the glyph indexes are saved to a metafile. However, to display the correct characters the metafile
/// must be played back using the same font. For ExtTextOutA, the glyph indexes are not saved.
/// </summary>
ETO_GLYPH_INDEX = 0x0010,
/// <summary>
/// Middle East language edition of Windows: If this value is specified and a Hebrew or Arabic font is selected into the device
/// context, the string is output using right-to-left reading order. If this value is not specified, the string is output in
/// left-to-right order. The same effect can be achieved by setting the TA_RTLREADING value in SetTextAlign. This value is
/// preserved for backward compatibility.
/// </summary>
ETO_RTLREADING = 0x0080,
/// <summary>To display numbers, use digits appropriate to the locale.</summary>
ETO_NUMERICSLOCAL = 0x0400,
/// <summary>To display numbers, use European digits.</summary>
ETO_NUMERICSLATIN = 0x0800,
/// <summary>
/// Reserved for system use. If an application sets this flag, it loses international scripting support and in some cases it may
/// display no text at all.
/// </summary>
ETO_IGNORELANGUAGE = 0x1000,
/// <summary>
/// When this is set, the array pointed to by lpDx contains pairs of values. The first value of each pair is, as usual, the
/// distance between origins of adjacent character cells, but the second value is the displacement along the vertical direction
/// of the font.
/// </summary>
ETO_PDY = 0x2000,
/// <summary>Reserved and SHOULD NOT be used.</summary>
ETO_REVERSE_INDEX_MAP = 0x10000,
}
/// <summary>Font type.</summary>
[PInvokeData("Wingdi.h")]
public enum FontType
{
/// <summary/>
DEVICE_FONTTYPE,
/// <summary/>
RASTER_FONTTYPE,
/// <summary/>
TRUETYPE_FONTTYPE
}
/// <summary>Flags for <see cref="AddFontResourceEx"/>.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "eaf8ebf0-1b06-4a09-a842-83540245a117")]
[Flags]
public enum FR
{
/// <summary>
/// Specifies that only the process that called the AddFontResourceEx function can use this font. When the font name matches a
/// public font, the private font will be chosen. When the process terminates, the system will remove all fonts installed by the
/// process with the AddFontResourceEx function.
/// </summary>
FR_PRIVATE = 0x10,
/// <summary>
/// Specifies that no process, including the process that called the AddFontResourceEx function, can enumerate this font.
/// </summary>
FR_NOT_ENUM = 0x20,
}
/// <summary>Flags for <see cref="GetCharacterPlacement"/> and <see cref="GetFontLanguageInfo"/>.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "80d3f4b3-503b-4abb-826c-e5c09972ba2f")]
[Flags]
public enum GCP : uint
{
/// <summary>
/// The font contains extra glyphs not normally accessible using the code page. Use GetCharacterPlacement to access the glyphs.
/// This value is for information only and is not intended to be passed to GetCharacterPlacement.
/// </summary>
FLI_GLYPHS = 0x00040000,
/// <summary>
/// Specifies that the lpClass array contains preset classifications for characters. The classifications may be the same as on
/// output. If the particular classification for a character is not known, the corresponding location in the array must be set to
/// zero. for more information about the classifications, see GCP_RESULTS. This is useful only if GetFontLanguageInfo returned
/// the GCP_REORDER flag.
/// </summary>
GCP_CLASSIN = 0x00080000,
/// <summary>The character set is DBCS.</summary>
GCP_DBCS = 0x0001,
/// <summary>
/// Determines how diacritics in the string are handled. If this value is not set, diacritics are treated as zero-width
/// characters. For example, a Hebrew string may contain diacritics, but you may not want to display them. Use
/// GetFontLanguageInfo to determine whether a font supports diacritics. If it does, you can use or not use the GCP_DIACRITIC
/// flag in the call to GetCharacterPlacement, depending on the needs of your application.
/// </summary>
GCP_DIACRITIC = 0x0100,
/// <summary>
/// For languages that need reordering or different glyph shapes depending on the positions of the characters within a word,
/// nondisplayable characters often appear in the code page. For example, in the Hebrew code page, there are Left-To-Right and
/// Right-To-Left markers, to help determine the final positioning of characters within the output strings. Normally these are
/// not displayed and are removed from the lpGlyphs and lpDx arrays. You can use the GCP_DISPLAYZWG flag to display these characters.
/// </summary>
GCP_DISPLAYZWG = 0x00400000,
/// <summary>
/// Specifies that some or all characters in the string are to be displayed using shapes other than the standard shapes defined
/// in the currently selected font for the current code page. Some languages, such as Arabic, cannot support glyph creation
/// unless this value is specified. As a general rule, if GetFontLanguageInfo returns this value for a string, this value must be
/// used with GetCharacterPlacement.
/// </summary>
GCP_GLYPHSHAPE = 0x0010,
/// <summary>
/// Adjusts the extents in the lpDx array so that the string length is the same as nMaxExtent. GCP_JUSTIFY may only be used in
/// conjunction with GCP_MAXEXTENT.
/// </summary>
GCP_JUSTIFY = 0x00010000,
/// <summary/>
GCP_JUSTIFYIN = 0x00200000,
/// <summary>
/// Use Kashidas as well as, or instead of, adjusted extents to modify the length of the string so that it is equal to the value
/// specified by nMaxExtent. In the lpDx array, a Kashida is indicated by a negative justification index. GCP_KASHIDA may be used
/// only in conjunction with GCP_JUSTIFY and only if the font (and language) support Kashidas. Use GetFontLanguageInfo to
/// determine whether the current font supports Kashidas. Using Kashidas to justify the string can result in the number of glyphs
/// required being greater than the number of characters in the input string. Because of this, when Kashidas are used, the
/// application cannot assume that setting the arrays to be the size of the input string will be sufficient. (The maximum
/// possible will be approximately dxPageWidth/dxAveCharWidth, where dxPageWidth is the width of the document and dxAveCharWidth
/// is the average character width as returned from a GetTextMetrics call). Note that just because GetFontLanguageInfo returns
/// the GCP_KASHIDA flag does not mean that it has to be used in the call to GetCharacterPlacement, just that the option is available.
/// </summary>
GCP_KASHIDA = 0x0400,
/// <summary>
/// Use ligations wherever characters ligate. A ligation occurs where one glyph is used for two or more characters. For example,
/// the letters a and e can ligate to ?. For this to be used, however, both the language support and the font must support the
/// required glyphs (the example will not be processed by default in English). Use GetFontLanguageInfo to determine whether the
/// current font supports ligation. If it does and a specific maximum is required for the number of characters that will ligate,
/// set the number in the first element of the lpGlyphs array. If normal ligation is required, set this value to zero. If
/// GCP_LIGATE is not specified, no ligation will take place. See GCP_RESULTS for more information. If the GCP_REORDER value is
/// usually required for the character set but is not specified, the output will be meaningless unless the string being passed in
/// is already in visual ordering (that is, the result that gets put into lpGcpResults-&gt;lpOutString in one call to
/// GetCharacterPlacement is the input string of a second call). Note that just because GetFontLanguageInfo returns the
/// GCP_LIGATE flag does not mean that it has to be used in the call to GetCharacterPlacement, just that the option is available.
/// </summary>
GCP_LIGATE = 0x0020,
/// <summary>
/// Compute extents of the string only as long as the resulting extent, in logical units, does not exceed the values specified by
/// the nMaxExtent parameter.
/// </summary>
GCP_MAXEXTENT = 0x00100000,
/// <summary>
/// Certain languages only. Override the normal handling of neutrals and treat them as strong characters that match the strings
/// reading order. Useful only with the GCP_REORDER flag.
/// </summary>
GCP_NEUTRALOVERRIDE = 0x02000000,
/// <summary>
/// Certain languages only. Override the normal handling of numerics and treat them as strong characters that match the strings
/// reading order. Useful only with the GCP_REORDER flag.
/// </summary>
GCP_NUMERICOVERRIDE = 0x01000000,
/// <summary>
/// Arabic/Thai only. Use standard Latin glyphs for numbers and override the system default. To determine if this option is
/// available in the language of the font, use GetStringTypeEx to see if the language supports more than one number format.
/// </summary>
GCP_NUMERICSLATIN = 0x04000000,
/// <summary>
/// Arabic/Thai only. Use local glyphs for numeric characters and override the system default. To determine if this option is
/// available in the language of the font, use GetStringTypeEx to see if the language supports more than one number format.
/// </summary>
GCP_NUMERICSLOCAL = 0x08000000,
/// <summary>
/// Reorder the string. Use for languages that are not SBCS and left-to-right reading order. If this value is not specified, the
/// string is assumed to be in display order already. If this flag is set for Semitic languages and the lpClass array is used,
/// the first two elements of the array are used to specify the reading order beyond the bounds of the string.
/// GCP_CLASS_PREBOUNDRTL and GCP_CLASS_PREBOUNDLTR can be used to set the order. If no preset order is required, set the values
/// to zero. These values can be combined with other values if the GCPCLASSIN flag is set. If the GCP_REORDER value is not
/// specified, the lpString parameter is taken to be visual ordered for languages where this is used, and the lpOutString and
/// lpOrder fields are ignored. Use GetFontLanguageInfo to determine whether the current font supports reordering.
/// </summary>
GCP_REORDER = 0x0002,
/// <summary>
/// Semitic languages only. Specifies that swappable characters are not reset. For example, in a right-to-left string, the '('
/// and ')' are not reversed.
/// </summary>
GCP_SYMSWAPOFF = 0x00800000,
/// <summary>
/// Use kerning pairs in the font (if any) when creating the widths arrays. Use GetFontLanguageInfo to determine whether the
/// current font supports kerning pairs. Note that just because GetFontLanguageInfo returns the GCP_USEKERNING flag does not mean
/// that it has to be used in the call to GetCharacterPlacement, just that the option is available. Most TrueType fonts have a
/// kerning table, but you do not have to use it.
/// </summary>
GCP_USEKERNING = 0x0008,
}
/// <summary>Values for <see cref="GCP_RESULTS"/><c>.lpClass</c> field.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "7692637e-963a-4e0a-8a04-e05a6d01c417")]
[Flags]
public enum GCPCLASS : byte
{
/// <summary>Character from a Latin or other single-byte character set for a left-to-right language.</summary>
GCPCLASS_LATIN = 1,
/// <summary>Hebrew character.</summary>
GCPCLASS_HEBREW = 2,
/// <summary>Arabic character.</summary>
GCPCLASS_ARABIC = 2,
/// <summary>Input only. Character has no specific classification.</summary>
GCPCLASS_NEUTRAL = 3,
/// <summary>Digit from the character set associated with the current font.</summary>
GCPCLASS_LOCALNUMBER = 4,
/// <summary>Digit from a Latin or other single-byte character set for a left-to-right language.</summary>
GCPCLASS_LATINNUMBER = 5,
/// <summary>Input only. Character used to terminate Latin digits, such as a plus or minus sign.</summary>
GCPCLASS_LATINNUMERICTERMINATOR = 6,
/// <summary>Input only. Character used to separate Latin digits, such as a comma or decimal point.</summary>
GCPCLASS_LATINNUMERICSEPARATOR = 7,
/// <summary>Input only. Character used to separate digits, such as a comma or decimal point.</summary>
GCPCLASS_NUMERICSEPARATOR = 8,
/// <summary>Set lpClass[0] to GCPCLASS_PREBOUNDLTR to bind the string to left-to-right reading order before the string.</summary>
GCPCLASS_PREBOUNDLTR = 0x80,
/// <summary>Set lpClass[0] to GCPCLASS_PREBOUNDRTL to bind the string to right-to-left reading order before the string.</summary>
GCPCLASS_PREBOUNDRTL = 0x40,
/// <summary>Set lpClass[0] to GCPCLASS_POSTBOUNDLTR to bind the string to left-to-right reading order after the string.</summary>
GCPCLASS_POSTBOUNDLTR = 0x20,
/// <summary>Set lpClass[0] to GCPCLASS_POSTBOUNDRTL to bind the string to right-to-left reading order after the string.</summary>
GCPCLASS_POSTBOUNDRTL = 0x10,
}
/// <summary>Specifies how glyphs should be handled if they are not supported.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "7abfee7a-dd5d-4f33-96f1-b38364ba5afd")]
[Flags]
public enum GGI
{
/// <summary>Marks unsupported glyphs with the hexadecimal value 0xffff.</summary>
GGI_MARK_NONEXISTING_GLYPHS = 1
}
/// <summary>The format of the data that <see cref="GetGlyphOutline"/> retrieves.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "08f06007-5b21-44ab-b234-21a58c94ed4e")]
public enum GGO
{
/// <summary>
/// The function only retrieves the GLYPHMETRICS structure specified by lpgm. The lpvBuffer is ignored. This value affects the
/// meaning of the function's return value upon failure; see the Return Values section.
/// </summary>
GGO_METRICS = 0,
/// <summary>
/// The function retrieves the glyph bitmap. For information about memory allocation, see the following Remarks section.
/// </summary>
GGO_BITMAP = 1,
/// <summary>The function retrieves the curve data points in the rasterizer's native format and uses the font's design units.</summary>
GGO_NATIVE = 2,
/// <summary>The function retrieves the curve data as a cubic Bézier spline (not in quadratic spline format).</summary>
GGO_BEZIER = 3,
/// <summary>The function retrieves a glyph bitmap that contains five levels of gray.</summary>
GGO_GRAY2_BITMAP = 4,
/// <summary>The function retrieves a glyph bitmap that contains 17 levels of gray.</summary>
GGO_GRAY4_BITMAP = 5,
/// <summary>The function retrieves a glyph bitmap that contains 65 levels of gray.</summary>
GGO_GRAY8_BITMAP = 6,
/// <summary>
/// Indicates that the uChar parameter is a TrueType Glyph Index rather than a character code. See the ExtTextOut function for
/// additional remarks on Glyph Indexing.
/// </summary>
GGO_GLYPH_INDEX = 0x0080,
/// <summary>The function only returns unhinted outlines. This flag only works in conjunction with GGO_BEZIER and GGO_NATIVE.</summary>
GGO_UNHINTED = 0x0100,
}
/// <summary>Flags describing the maximum size of the glyph indices.</summary>
public enum GSISize : uint
{
/// <summary>Treat glyph indices as 16-bit wide values.</summary>
GS_16BIT_INDICES = 0,
/// <summary>Treat glyph indices as 8-bit wide values.</summary>
GS_8BIT_INDICES = 1
}
/// <summary>
/// The output precision. The output precision defines how closely the output must match the requested font's height, width,
/// character orientation, escapement, pitch, and font type.
/// </summary>
[PInvokeData("Wingdi.h", MSDNShortId = "dd145037")]
public enum OutputPrecision : byte
{
/// <summary>Not used.</summary>
OUT_CHARACTER_PRECIS = 2,
/// <summary>Specifies the default font mapper behavior.</summary>
OUT_DEFAULT_PRECIS = 0,
/// <summary>Instructs the font mapper to choose a Device font when the system contains multiple fonts with the same name.</summary>
OUT_DEVICE_PRECIS = 5,
/// <summary>This value instructs the font mapper to choose from TrueType and other outline-based fonts.</summary>
OUT_OUTLINE_PRECIS = 8,
/// <summary>
/// Instructs the font mapper to choose from only PostScript fonts. If there are no PostScript fonts installed in the system, the
/// font mapper returns to default behavior.
/// </summary>
OUT_PS_ONLY_PRECIS = 10,
/// <summary>Instructs the font mapper to choose a raster font when the system contains multiple fonts with the same name.</summary>
OUT_RASTER_PRECIS = 6,
/// <summary>A value that specifies a preference for TrueType and other outline fonts.</summary>
OUT_SCREEN_OUTLINE_PRECIS = 9,
/// <summary>This value is not used by the font mapper, but it is returned when raster fonts are enumerated.</summary>
OUT_STRING_PRECIS = 1,
/// <summary>
/// This value is not used by the font mapper, but it is returned when TrueType, other outline-based fonts, and vector fonts are enumerated.
/// </summary>
OUT_STROKE_PRECIS = 3,
/// <summary>
/// Instructs the font mapper to choose from only TrueType fonts. If there are no TrueType fonts installed in the system, the
/// font mapper returns to default behavior.
/// </summary>
OUT_TT_ONLY_PRECIS = 7,
/// <summary>Instructs the font mapper to choose a TrueType font when the system contains multiple fonts with the same name.</summary>
OUT_TT_PRECIS = 4,
}
/// <summary>
/// The output quality defines how carefully the graphics device interface (GDI) must attempt to match the logical-font attributes to
/// those of an actual physical font.
/// </summary>
[PInvokeData("Wingdi.h", MSDNShortId = "dd145037")]
public enum OutputQuality : byte
{
/// <summary>Appearance of the font does not matter.</summary>
DEFAULT_QUALITY = 0,
/// <summary>
/// Appearance of the font is less important than when PROOF_QUALITY is used. For GDI raster fonts, scaling is enabled, which
/// means that more font sizes are available, but the quality may be lower. Bold, italic, underline, and strikeout fonts are
/// synthesized if necessary.
/// </summary>
DRAFT_QUALITY = 1,
/// <summary>
/// Character quality of the font is more important than exact matching of the logical-font attributes. For GDI raster fonts,
/// scaling is disabled and the font closest in size is chosen. Although the chosen font size may not be mapped exactly when
/// PROOF_QUALITY is used, the quality of the font is high and there is no distortion of appearance. Bold, italic, underline, and
/// strikeout fonts are synthesized if necessary.
/// </summary>
PROOF_QUALITY = 2,
/// <summary>Font is never antialiased.</summary>
NONANTIALIASED_QUALITY = 3,
/// <summary>Font is always antialiased if the font supports it and the size of the font is not too small or too large.</summary>
ANTIALIASED_QUALITY = 4,
/// <summary>
/// If set, text is rendered (when possible) using ClearType antialiasing method. The font quality is given less importance than
/// maintaining the text size.
/// </summary>
CLEARTYPE_QUALITY = 5,
/// <summary>
/// If set, text is rendered (when possible) using ClearType antialiasing method. The font quality is given more importance than
/// maintaining the text size.
/// </summary>
CLEARTYPE_NATURAL_QUALITY = 6
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_ARMS : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Straight Arms/Horizontal</summary>
PAN_STRAIGHT_ARMS_HORZ = 2,
/// <summary>Straight Arms/Wedge</summary>
PAN_STRAIGHT_ARMS_WEDGE = 3,
/// <summary>Straight Arms/Vertical</summary>
PAN_STRAIGHT_ARMS_VERT = 4,
/// <summary>Straight Arms/Single-Serif</summary>
PAN_STRAIGHT_ARMS_SINGLE_SERIF = 5,
/// <summary>Straight Arms/Double-Serif</summary>
PAN_STRAIGHT_ARMS_DOUBLE_SERIF = 6,
/// <summary>Non-Straight Arms/Horizontal</summary>
PAN_BENT_ARMS_HORZ = 7,
/// <summary>Non-Straight Arms/Wedge</summary>
PAN_BENT_ARMS_WEDGE = 8,
/// <summary>Non-Straight Arms/Vertical</summary>
PAN_BENT_ARMS_VERT = 9,
/// <summary>Non-Straight Arms/Single-Serif</summary>
PAN_BENT_ARMS_SINGLE_SERIF = 10,
/// <summary>Non-Straight Arms/Double-Serif</summary>
PAN_BENT_ARMS_DOUBLE_SERIF = 11,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_CONTRAST : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>None</summary>
PAN_CONTRAST_NONE = 2,
/// <summary>Very Low</summary>
PAN_CONTRAST_VERY_LOW = 3,
/// <summary>Low</summary>
PAN_CONTRAST_LOW = 4,
/// <summary>Medium Low</summary>
PAN_CONTRAST_MEDIUM_LOW = 5,
/// <summary>Medium</summary>
PAN_CONTRAST_MEDIUM = 6,
/// <summary>Mediim High</summary>
PAN_CONTRAST_MEDIUM_HIGH = 7,
/// <summary>High</summary>
PAN_CONTRAST_HIGH = 8,
/// <summary>Very High</summary>
PAN_CONTRAST_VERY_HIGH = 9,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_FAMILY : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Text and Display</summary>
PAN_FAMILY_TEXT_DISPLAY = 2,
/// <summary>Script</summary>
PAN_FAMILY_SCRIPT = 3,
/// <summary>Decorative</summary>
PAN_FAMILY_DECORATIVE = 4,
/// <summary>Pictorial</summary>
PAN_FAMILY_PICTORIAL = 5,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_LETT : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Normal/Contact</summary>
PAN_LETT_NORMAL_CONTACT = 2,
/// <summary>Normal/Weighted</summary>
PAN_LETT_NORMAL_WEIGHTED = 3,
/// <summary>Normal/Boxed</summary>
PAN_LETT_NORMAL_BOXED = 4,
/// <summary>Normal/Flattened</summary>
PAN_LETT_NORMAL_FLATTENED = 5,
/// <summary>Normal/Rounded</summary>
PAN_LETT_NORMAL_ROUNDED = 6,
/// <summary>Normal/Off Center</summary>
PAN_LETT_NORMAL_OFF_CENTER = 7,
/// <summary>Normal/Square</summary>
PAN_LETT_NORMAL_SQUARE = 8,
/// <summary>Oblique/Contact</summary>
PAN_LETT_OBLIQUE_CONTACT = 9,
/// <summary>Oblique/Weighted</summary>
PAN_LETT_OBLIQUE_WEIGHTED = 10,
/// <summary>Oblique/Boxed</summary>
PAN_LETT_OBLIQUE_BOXED = 11,
/// <summary>Oblique/Flattened</summary>
PAN_LETT_OBLIQUE_FLATTENED = 12,
/// <summary>Oblique/Rounded</summary>
PAN_LETT_OBLIQUE_ROUNDED = 13,
/// <summary>Oblique/Off Center</summary>
PAN_LETT_OBLIQUE_OFF_CENTER = 14,
/// <summary>Oblique/Square</summary>
PAN_LETT_OBLIQUE_SQUARE = 15,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_MIDLINE : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Standard/Trimmed</summary>
PAN_MIDLINE_STANDARD_TRIMMED = 2,
/// <summary>Standard/Pointed</summary>
PAN_MIDLINE_STANDARD_POINTED = 3,
/// <summary>Standard/Serifed</summary>
PAN_MIDLINE_STANDARD_SERIFED = 4,
/// <summary>High/Trimmed</summary>
PAN_MIDLINE_HIGH_TRIMMED = 5,
/// <summary>High/Pointed</summary>
PAN_MIDLINE_HIGH_POINTED = 6,
/// <summary>High/Serifed</summary>
PAN_MIDLINE_HIGH_SERIFED = 7,
/// <summary>Constant/Trimmed</summary>
PAN_MIDLINE_CONSTANT_TRIMMED = 8,
/// <summary>Constant/Pointed</summary>
PAN_MIDLINE_CONSTANT_POINTED = 9,
/// <summary>Constant/Serifed</summary>
PAN_MIDLINE_CONSTANT_SERIFED = 10,
/// <summary>Low/Trimmed</summary>
PAN_MIDLINE_LOW_TRIMMED = 11,
/// <summary>Low/Pointed</summary>
PAN_MIDLINE_LOW_POINTED = 12,
/// <summary>Low/Serifed</summary>
PAN_MIDLINE_LOW_SERIFED = 13,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_PROP : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Old Style</summary>
PAN_PROP_OLD_STYLE = 2,
/// <summary>Modern</summary>
PAN_PROP_MODERN = 3,
/// <summary>Even Width</summary>
PAN_PROP_EVEN_WIDTH = 4,
/// <summary>Expanded</summary>
PAN_PROP_EXPANDED = 5,
/// <summary>Condensed</summary>
PAN_PROP_CONDENSED = 6,
/// <summary>Very Expanded</summary>
PAN_PROP_VERY_EXPANDED = 7,
/// <summary>Very Condensed</summary>
PAN_PROP_VERY_CONDENSED = 8,
/// <summary>Monospaced</summary>
PAN_PROP_MONOSPACED = 9,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_SERIF : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Cove</summary>
PAN_SERIF_COVE = 2,
/// <summary>Obtuse Cove</summary>
PAN_SERIF_OBTUSE_COVE = 3,
/// <summary>Square Cove</summary>
PAN_SERIF_SQUARE_COVE = 4,
/// <summary>Obtuse Square Cove</summary>
PAN_SERIF_OBTUSE_SQUARE_COVE = 5,
/// <summary>Square</summary>
PAN_SERIF_SQUARE = 6,
/// <summary>Thin</summary>
PAN_SERIF_THIN = 7,
/// <summary>Bone</summary>
PAN_SERIF_BONE = 8,
/// <summary>Exaggerated</summary>
PAN_SERIF_EXAGGERATED = 9,
/// <summary>Triangle</summary>
PAN_SERIF_TRIANGLE = 10,
/// <summary>Normal Sans</summary>
PAN_SERIF_NORMAL_SANS = 11,
/// <summary>Obtuse Sans</summary>
PAN_SERIF_OBTUSE_SANS = 12,
/// <summary>Prep Sans</summary>
PAN_SERIF_PERP_SANS = 13,
/// <summary>Flared</summary>
PAN_SERIF_FLARED = 14,
/// <summary>Rounded</summary>
PAN_SERIF_ROUNDED = 15,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_STROKE : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Gradual/Diagonal</summary>
PAN_STROKE_GRADUAL_DIAG = 2,
/// <summary>Gradual/Transitional</summary>
PAN_STROKE_GRADUAL_TRAN = 3,
/// <summary>Gradual/Vertical</summary>
PAN_STROKE_GRADUAL_VERT = 4,
/// <summary>Gradual/Horizontal</summary>
PAN_STROKE_GRADUAL_HORZ = 5,
/// <summary>Rapid/Vertical</summary>
PAN_STROKE_RAPID_VERT = 6,
/// <summary>Rapid/Horizontal</summary>
PAN_STROKE_RAPID_HORZ = 7,
/// <summary>Instant/Vertical</summary>
PAN_STROKE_INSTANT_VERT = 8,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_WEIGHT : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Very Light</summary>
PAN_WEIGHT_VERY_LIGHT = 2,
/// <summary>Light</summary>
PAN_WEIGHT_LIGHT = 3,
/// <summary>Thin</summary>
PAN_WEIGHT_THIN = 4,
/// <summary>Book</summary>
PAN_WEIGHT_BOOK = 5,
/// <summary>Medium</summary>
PAN_WEIGHT_MEDIUM = 6,
/// <summary>Demi</summary>
PAN_WEIGHT_DEMI = 7,
/// <summary>Bold</summary>
PAN_WEIGHT_BOLD = 8,
/// <summary>Heavy</summary>
PAN_WEIGHT_HEAVY = 9,
/// <summary>Black</summary>
PAN_WEIGHT_BLACK = 10,
/// <summary>Nord</summary>
PAN_WEIGHT_NORD = 11,
}
/// <summary>PANOSE font-classification values for a TrueType font.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
public enum PAN_XHEIGHT : byte
{
/// <summary>Any</summary>
PAN_ANY = 0,
/// <summary>No Fit</summary>
PAN_NO_FIT = 1,
/// <summary>Constant/Small</summary>
PAN_XHEIGHT_CONSTANT_SMALL = 2,
/// <summary>Constant/Standard</summary>
PAN_XHEIGHT_CONSTANT_STD = 3,
/// <summary>Constant/Large</summary>
PAN_XHEIGHT_CONSTANT_LARGE = 4,
/// <summary>Ducking/Small</summary>
PAN_XHEIGHT_DUCKING_SMALL = 5,
/// <summary>Ducking/Standard</summary>
PAN_XHEIGHT_DUCKING_STD = 6,
/// <summary>Ducking/Large</summary>
PAN_XHEIGHT_DUCKING_LARGE = 7,
}
/// <summary>Flags specifying pitch and family for fonts.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "373bac6e-5d4d-4909-8096-2f0e909d2f1d")]
[Flags]
public enum PitchAndFamily : uint
{
/// <summary>The default pitch, which is implementation-dependent.</summary>
DEFAULT_PITCH = 0,
/// <summary>A fixed pitch, which means that all the characters in the font occupy the same width when output in a string.</summary>
FIXED_PITCH = 1,
/// <summary>
/// A variable pitch, which means that the characters in the font occupy widths that are proportional to the actual widths of the
/// glyphs when output in a string. For example, the "i" and space characters usually have much smaller widths than a "W" or "O" character.
/// </summary>
VARIABLE_PITCH = 2,
/// <summary>The mono font/</summary>
MONO_FONT = 8,
/// <summary>
/// If this bit is set the font is a variable pitch font. If this bit is clear the font is a fixed pitch font. Note very
/// carefully that those meanings are the opposite of what the constant name implies.
/// </summary>
TMPF_FIXED_PITCH = 0x01,
/// <summary>If this bit is set the font is a vector font.</summary>
TMPF_VECTOR = 0x02,
/// <summary>If this bit is set the font is a TrueType font.</summary>
TMPF_TRUETYPE = 0x04,
/// <summary>If this bit is set the font is a device font.</summary>
TMPF_DEVICE = 0x08,
/// <summary>Use default font.</summary>
FF_DONTCARE = 0 << 4,
/// <summary>Fonts with variable stroke width (proportional) and with serifs. MS Serif is an example.</summary>
FF_ROMAN = 1 << 4,
/// <summary>Fonts with variable stroke width (proportional) and without serifs. MS Sans Serif is an example.</summary>
FF_SWISS = 2 << 4,
/// <summary>
/// Fonts with constant stroke width (monospace), with or without serifs. Monospace fonts are usually modern. Pica, Elite, and
/// CourierNew are examples.
/// </summary>
FF_MODERN = 3 << 4,
/// <summary>Fonts designed to look like handwriting. Script and Cursive are examples.</summary>
FF_SCRIPT = 4 << 4,
/// <summary>Novelty fonts. Old English is an example.</summary>
FF_DECORATIVE = 5 << 4,
}
/// <summary>Text-alignment settings for a device context.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "d3ec0350-2eb8-4843-88bb-d72cece710e7")]
[Flags]
public enum TextAlign : uint
{
/// <summary>The current position is not updated after each text output call.</summary>
TA_NOUPDATECP = 0,
/// <summary>The current position is updated after each text output call.</summary>
TA_UPDATECP = 1,
/// <summary>The reference point is on the left edge of the bounding rectangle.</summary>
TA_LEFT = 0,
/// <summary>The reference point is on the right edge of the bounding rectangle.</summary>
TA_RIGHT = 2,
/// <summary>The reference point is aligned horizontally with the center of the bounding rectangle.</summary>
TA_CENTER = 6,
/// <summary>The reference point is on the top edge of the bounding rectangle.</summary>
TA_TOP = 0,
/// <summary>The reference point is on the bottom edge of the bounding rectangle.</summary>
TA_BOTTOM = 8,
/// <summary>The reference point is on the base line of the text.</summary>
TA_BASELINE = 24,
/// <summary>
/// Middle East language edition of Windows: The text is laid out in right to left reading order, as opposed to the default left
/// to right order. This only applies when the font selected into the device context is either Hebrew or Arabic.
/// </summary>
TA_RTLREADING = 256,
}
/// <summary>Flags regarding TrueType status.</summary>
[PInvokeData("wingdi.h", MSDNShortId = "40bb4b59-90a4-4780-ae5f-fef8a6fa62cb")]
[Flags]
public enum TT : short
{
/// <summary>TrueType is available.</summary>
TT_AVAILABLE = 1,
/// <summary>TrueType is enabled.</summary>
TT_ENABLED = 2
}
/// <summary>The <c>AddFontMemResourceEx</c> function adds the font resource from a memory image to the system.</summary>
/// <param name="pFileView">A pointer to a font resource.</param>
/// <param name="cjSize">The number of bytes in the font resource that is pointed to by pbFont.</param>
/// <param name="pvResrved">Reserved. Must be 0.</param>
/// <param name="pNumFonts">A pointer to a variable that specifies the number of fonts installed.</param>
/// <returns>
/// If the function succeeds, the return value specifies the handle to the font added. This handle uniquely identifies the fonts that
/// were installed on the system. If the function fails, the return value is zero. No extended error information is available.
/// </returns>
/// <remarks>
/// <para>
/// This function allows an application to get a font that is embedded in a document or a webpage. A font that is added by
/// <c>AddFontMemResourceEx</c> is always private to the process that made the call and is not enumerable.
/// </para>
/// <para>
/// A memory image can contain more than one font. When this function succeeds, pcFonts is a pointer to a <c>DWORD</c> whose value is
/// the number of fonts added to the system as a result of this call. For example, this number could be 2 for the vertical and
/// horizontal faces of an Asian font.
/// </para>
/// <para>
/// When the function succeeds, the caller of this function can free the memory pointed to by pbFont because the system has made its
/// own copy of the memory. To remove the fonts that were installed, call RemoveFontMemResourceEx. However, when the process goes
/// away, the system will unload the fonts even if the process did not call RemoveFontMemResource.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-addfontmemresourceex HANDLE AddFontMemResourceEx( PVOID
// pFileView, DWORD cjSize, PVOID pvResrved, DWORD *pNumFonts );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "ad5153ba-fa9d-4a07-9be3-a07b524c1539")]
public static extern HANDLE AddFontMemResourceEx(IntPtr pFileView, uint cjSize, [Optional] IntPtr pvResrved, in uint pNumFonts);
/// <summary>
/// <para>
/// The <c>AddFontResource</c> function adds the font resource from the specified file to the system font table. The font can
/// subsequently be used for text output by any application.
/// </para>
/// <para>To mark a font as private or not enumerable, use the AddFontResourceEx function.</para>
/// </summary>
/// <param name="Arg1">
/// <para>
/// A pointer to a null-terminated character string that contains a valid font file name. This parameter can specify any of the
/// following files.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>File Extension</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>.fon</term>
/// <term>Font resource file.</term>
/// </item>
/// <item>
/// <term>.fnt</term>
/// <term>Raw bitmap font file.</term>
/// </item>
/// <item>
/// <term>.ttf</term>
/// <term>Raw TrueType file.</term>
/// </item>
/// <item>
/// <term>.ttc</term>
/// <term>East Asian Windows: TrueType font collection.</term>
/// </item>
/// <item>
/// <term>.fot</term>
/// <term>TrueType resource file.</term>
/// </item>
/// <item>
/// <term>.otf</term>
/// <term>PostScript OpenType font.</term>
/// </item>
/// <item>
/// <term>.mmm</term>
/// <term>Multiple master Type1 font resource file. It must be used with .pfm and .pfb files.</term>
/// </item>
/// <item>
/// <term>.pfb</term>
/// <term>Type 1 font bits file. It is used with a .pfm file.</term>
/// </item>
/// <item>
/// <term>.pfm</term>
/// <term>Type 1 font metrics file. It is used with a .pfb file.</term>
/// </item>
/// </list>
/// <para>
/// To add a font whose information comes from several resource files, have lpszFileName point to a string with the file names
/// separated by a "|" --for example, abcxxxxx.pfm | abcxxxxx.pfb.
/// </para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value specifies the number of fonts added.</para>
/// <para>If the function fails, the return value is zero. No extended error information is available.</para>
/// </returns>
/// <remarks>
/// <para>
/// Any application that adds or removes fonts from the system font table should notify other windows of the change by sending a
/// WM_FONTCHANGE message to all top-level windows in the operating system. The application should send this message by calling the
/// SendMessage function and setting the hwnd parameter to HWND_BROADCAST.
/// </para>
/// <para>
/// When an application no longer needs a font resource that it loaded by calling the <c>AddFontResource</c> function, it must remove
/// that resource by calling the RemoveFontResource function.
/// </para>
/// <para>
/// This function installs the font only for the current session. When the system restarts, the font will not be present. To have the
/// font installed even after restarting the system, the font must be listed in the registry.
/// </para>
/// <para>
/// A font listed in the registry and installed to a location other than the %windir%\fonts\ folder cannot be modified, deleted, or
/// replaced as long as it is loaded in any session. In order to change one of these fonts, it must first be removed by calling
/// RemoveFontResource, removed from the font registry ( <c>HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
/// NT\CurrentVersion\Fonts</c>), and the system restarted. After restarting the system, the font will no longer be loaded and can be changed.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-addfontresourcea int AddFontResourceA( LPCSTR Arg1 );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "e553a25a-f281-4ddc-8e95-1f61ed8238f9")]
public static extern int AddFontResource(string Arg1);
/// <summary>
/// The <c>AddFontResourceEx</c> function adds the font resource from the specified file to the system. Fonts added with the
/// <c>AddFontResourceEx</c> function can be marked as private and not enumerable.
/// </summary>
/// <param name="name">
/// <para>
/// A pointer to a null-terminated character string that contains a valid font file name. This parameter can specify any of the
/// following files.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>File Extension</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>.fon</term>
/// <term>Font resource file.</term>
/// </item>
/// <item>
/// <term>.fnt</term>
/// <term>Raw bitmap font file.</term>
/// </item>
/// <item>
/// <term>.ttf</term>
/// <term>Raw TrueType file.</term>
/// </item>
/// <item>
/// <term>.ttc</term>
/// <term>East Asian Windows: TrueType font collection.</term>
/// </item>
/// <item>
/// <term>.fot</term>
/// <term>TrueType resource file.</term>
/// </item>
/// <item>
/// <term>.otf</term>
/// <term>PostScript OpenType font.</term>
/// </item>
/// <item>
/// <term>.mmm</term>
/// <term>multiple master Type1 font resource file. It must be used with .pfm and .pfb files.</term>
/// </item>
/// <item>
/// <term>.pfb</term>
/// <term>Type 1 font bits file. It is used with a .pfm file.</term>
/// </item>
/// <item>
/// <term>.pfm</term>
/// <term>Type 1 font metrics file. It is used with a .pfb file.</term>
/// </item>
/// </list>
/// <para>
/// To add a font whose information comes from several resource files, point lpszFileName to a string with the file names separated
/// by a | --for example, abcxxxxx.pfm | abcxxxxx.pfb.
/// </para>
/// </param>
/// <param name="fl">
/// <para>The characteristics of the font to be added to the system. This parameter can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>FR_PRIVATE</term>
/// <term>
/// Specifies that only the process that called the AddFontResourceEx function can use this font. When the font name matches a public
/// font, the private font will be chosen. When the process terminates, the system will remove all fonts installed by the process
/// with the AddFontResourceEx function.
/// </term>
/// </item>
/// <item>
/// <term>FR_NOT_ENUM</term>
/// <term>Specifies that no process, including the process that called the AddFontResourceEx function, can enumerate this font.</term>
/// </item>
/// </list>
/// </param>
/// <param name="res">Reserved. Must be zero.</param>
/// <returns>
/// <para>If the function succeeds, the return value specifies the number of fonts added.</para>
/// <para>If the function fails, the return value is zero. No extended error information is available.</para>
/// </returns>
/// <remarks>
/// <para>This function allows a process to use fonts without allowing other processes access to the fonts.</para>
/// <para>
/// When an application no longer needs a font resource it loaded by calling the <c>AddFontResourceEx</c> function, it must remove
/// the resource by calling the RemoveFontResourceEx function.
/// </para>
/// <para>
/// This function installs the font only for the current session. When the system restarts, the font will not be present. To have the
/// font installed even after restarting the system, the font must be listed in the registry.
/// </para>
/// <para>
/// A font listed in the registry and installed to a location other than the %windir%\fonts\ folder cannot be modified, deleted, or
/// replaced as long as it is loaded in any session. In order to change one of these fonts, it must first be removed by calling
/// RemoveFontResource, removed from the font registry ( <c>HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
/// NT\CurrentVersion\Fonts</c>), and the system restarted. After restarting the system, the font will no longer be loaded and can be changed.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-addfontresourceexa int AddFontResourceExA( LPCSTR name, DWORD
// fl, PVOID res );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "eaf8ebf0-1b06-4a09-a842-83540245a117")]
public static extern int AddFontResourceEx(string name, FR fl, IntPtr res = default);
/// <summary>
/// The <c>CreateFont</c> function creates a logical font with the specified characteristics. The logical font can subsequently be
/// selected as the font for any device.
/// </summary>
/// <param name="cHeight">
/// <para>
/// The height, in logical units, of the font's character cell or character. The character height value (also known as the em height)
/// is the character cell height value minus the internal-leading value. The font mapper interprets the value specified in nHeight in
/// the following manner.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>&gt; 0</term>
/// <term>The font mapper transforms this value into device units and matches it against the cell height of the available fonts.</term>
/// </item>
/// <item>
/// <term>0</term>
/// <term>The font mapper uses a default height value when it searches for a match.</term>
/// </item>
/// <item>
/// <term>&lt; 0</term>
/// <term>
/// The font mapper transforms this value into device units and matches its absolute value against the character height of the
/// available fonts.
/// </term>
/// </item>
/// </list>
/// <para>For all height comparisons, the font mapper looks for the largest font that does not exceed the requested size.</para>
/// <para>This mapping occurs when the font is used for the first time.</para>
/// <para>
/// For the MM_TEXT mapping mode, you can use the following formula to specify a height for a font with a specified point size:
/// </para>
/// <para>nHeight = -MulDiv(PointSize, GetDeviceCaps(hDC, LOGPIXELSY), 72);</para>
/// </param>
/// <param name="cWidth">
/// The average width, in logical units, of characters in the requested font. If this value is zero, the font mapper chooses a
/// closest match value. The closest match value is determined by comparing the absolute values of the difference between the current
/// device's aspect ratio and the digitized aspect ratio of available fonts.
/// </param>
/// <param name="cEscapement">
/// <para>
/// The angle, in tenths of degrees, between the escapement vector and the x-axis of the device. The escapement vector is parallel to
/// the base line of a row of text.
/// </para>
/// <para>
/// When the graphics mode is set to GM_ADVANCED, you can specify the escapement angle of the string independently of the orientation
/// angle of the string's characters.
/// </para>
/// <para>
/// When the graphics mode is set to GM_COMPATIBLE, nEscapement specifies both the escapement and orientation. You should set
/// nEscapement and nOrientation to the same value.
/// </para>
/// </param>
/// <param name="cOrientation">The angle, in tenths of degrees, between each character's base line and the x-axis of the device.</param>
/// <param name="cWeight">
/// <para>
/// The weight of the font in the range 0 through 1000. For example, 400 is normal and 700 is bold. If this value is zero, a default
/// weight is used.
/// </para>
/// <para>The following values are defined for convenience.</para>
/// <list type="table">
/// <listheader>
/// <term>Weight</term>
/// <term>Value</term>
/// </listheader>
/// <item>
/// <term>FW_DONTCARE</term>
/// <term>0</term>
/// </item>
/// <item>
/// <term>FW_THIN</term>
/// <term>100</term>
/// </item>
/// <item>
/// <term>FW_EXTRALIGHT</term>
/// <term>200</term>
/// </item>
/// <item>
/// <term>FW_ULTRALIGHT</term>
/// <term>200</term>
/// </item>
/// <item>
/// <term>FW_LIGHT</term>
/// <term>300</term>
/// </item>
/// <item>
/// <term>FW_NORMAL</term>
/// <term>400</term>
/// </item>
/// <item>
/// <term>FW_REGULAR</term>
/// <term>400</term>
/// </item>
/// <item>
/// <term>FW_MEDIUM</term>
/// <term>500</term>
/// </item>
/// <item>
/// <term>FW_SEMIBOLD</term>
/// <term>600</term>
/// </item>
/// <item>
/// <term>FW_DEMIBOLD</term>
/// <term>600</term>
/// </item>
/// <item>
/// <term>FW_BOLD</term>
/// <term>700</term>
/// </item>
/// <item>
/// <term>FW_EXTRABOLD</term>
/// <term>800</term>
/// </item>
/// <item>
/// <term>FW_ULTRABOLD</term>
/// <term>800</term>
/// </item>
/// <item>
/// <term>FW_HEAVY</term>
/// <term>900</term>
/// </item>
/// <item>
/// <term>FW_BLACK</term>
/// <term>900</term>
/// </item>
/// </list>
/// </param>
/// <param name="bItalic">Specifies an italic font if set to <c>TRUE</c>.</param>
/// <param name="bUnderline">Specifies an underlined font if set to <c>TRUE</c>.</param>
/// <param name="bStrikeOut">A strikeout font if set to <c>TRUE</c>.</param>
/// <param name="iCharSet">
/// <para>The character set. The following values are predefined:</para>
/// <list type="bullet">
/// <item>
/// <term>ANSI_CHARSET</term>
/// </item>
/// <item>
/// <term>BALTIC_CHARSET</term>
/// </item>
/// <item>
/// <term>CHINESEBIG5_CHARSET</term>
/// </item>
/// <item>
/// <term>DEFAULT_CHARSET</term>
/// </item>
/// <item>
/// <term>EASTEUROPE_CHARSET</term>
/// </item>
/// <item>
/// <term>GB2312_CHARSET</term>
/// </item>
/// <item>
/// <term>GREEK_CHARSET</term>
/// </item>
/// <item>
/// <term>HANGUL_CHARSET</term>
/// </item>
/// <item>
/// <term>MAC_CHARSET</term>
/// </item>
/// <item>
/// <term>OEM_CHARSET</term>
/// </item>
/// <item>
/// <term>RUSSIAN_CHARSET</term>
/// </item>
/// <item>
/// <term>SHIFTJIS_CHARSET</term>
/// </item>
/// <item>
/// <term>SYMBOL_CHARSET</term>
/// </item>
/// <item>
/// <term>TURKISH_CHARSET</term>
/// </item>
/// <item>
/// <term>VIETNAMESE_CHARSET</term>
/// </item>
/// </list>
/// <para>Korean language edition of Windows:</para>
/// <list type="bullet">
/// <item>
/// <term>JOHAB_CHARSET</term>
/// </item>
/// </list>
/// <para>Middle East language edition of Windows:</para>
/// <list type="bullet">
/// <item>
/// <term>ARABIC_CHARSET</term>
/// </item>
/// <item>
/// <term>HEBREW_CHARSET</term>
/// </item>
/// </list>
/// <para>Thai language edition of Windows:</para>
/// <list type="bullet">
/// <item>
/// <term>THAI_CHARSET</term>
/// </item>
/// </list>
/// <para>The OEM_CHARSET value specifies a character set that is operating-system dependent.</para>
/// <para>
/// DEFAULT_CHARSET is set to a value based on the current system locale. For example, when the system locale is English (United
/// States), it is set as ANSI_CHARSET.
/// </para>
/// <para>
/// Fonts with other character sets may exist in the operating system. If an application uses a font with an unknown character set,
/// it should not attempt to translate or interpret strings that are rendered with that font.
/// </para>
/// <para>
/// To ensure consistent results when creating a font, do not specify OEM_CHARSET or DEFAULT_CHARSET. If you specify a typeface name
/// in the lpszFace parameter, make sure that the fdwCharSet value matches the character set of the typeface specified in lpszFace.
/// </para>
/// </param>
/// <param name="iOutPrecision">
/// <para>
/// The output precision. The output precision defines how closely the output must match the requested font's height, width,
/// character orientation, escapement, pitch, and font type. It can be one of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>OUT_CHARACTER_PRECIS</term>
/// <term>Not used.</term>
/// </item>
/// <item>
/// <term>OUT_DEFAULT_PRECIS</term>
/// <term>The default font mapper behavior.</term>
/// </item>
/// <item>
/// <term>OUT_DEVICE_PRECIS</term>
/// <term>Instructs the font mapper to choose a Device font when the system contains multiple fonts with the same name.</term>
/// </item>
/// <item>
/// <term>OUT_OUTLINE_PRECIS</term>
/// <term>This value instructs the font mapper to choose from TrueType and other outline-based fonts.</term>
/// </item>
/// <item>
/// <term>OUT_PS_ONLY_PRECIS</term>
/// <term>
/// Instructs the font mapper to choose from only PostScript fonts. If there are no PostScript fonts installed in the system, the
/// font mapper returns to default behavior.
/// </term>
/// </item>
/// <item>
/// <term>OUT_RASTER_PRECIS</term>
/// <term>Instructs the font mapper to choose a raster font when the system contains multiple fonts with the same name.</term>
/// </item>
/// <item>
/// <term>OUT_STRING_PRECIS</term>
/// <term>This value is not used by the font mapper, but it is returned when raster fonts are enumerated.</term>
/// </item>
/// <item>
/// <term>OUT_STROKE_PRECIS</term>
/// <term>
/// This value is not used by the font mapper, but it is returned when TrueType, other outline-based fonts, and vector fonts are enumerated.
/// </term>
/// </item>
/// <item>
/// <term>OUT_TT_ONLY_PRECIS</term>
/// <term>
/// Instructs the font mapper to choose from only TrueType fonts. If there are no TrueType fonts installed in the system, the font
/// mapper returns to default behavior.
/// </term>
/// </item>
/// <item>
/// <term>OUT_TT_PRECIS</term>
/// <term>Instructs the font mapper to choose a TrueType font when the system contains multiple fonts with the same name.</term>
/// </item>
/// </list>
/// <para>
/// Applications can use the OUT_DEVICE_PRECIS, OUT_RASTER_PRECIS, OUT_TT_PRECIS, and OUT_PS_ONLY_PRECIS values to control how the
/// font mapper chooses a font when the operating system contains more than one font with a specified name. For example, if an
/// operating system contains a font named Symbol in raster and TrueType form, specifying OUT_TT_PRECIS forces the font mapper to
/// choose the TrueType version. Specifying OUT_TT_ONLY_PRECIS forces the font mapper to choose a TrueType font, even if it must
/// substitute a TrueType font of another name.
/// </para>
/// </param>
/// <param name="iClipPrecision">
/// <para>
/// The clipping precision. The clipping precision defines how to clip characters that are partially outside the clipping region. It
/// can be one or more of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>CLIP_CHARACTER_PRECIS</term>
/// <term>Not used.</term>
/// </item>
/// <item>
/// <term>CLIP_DEFAULT_PRECIS</term>
/// <term>Specifies default clipping behavior.</term>
/// </item>
/// <item>
/// <term>CLIP_DFA_DISABLE</term>
/// <term>
/// Windows XP SP1: Turns off font association for the font. Note that this flag is not guaranteed to have any effect on any platform
/// after Windows Server 2003.
/// </term>
/// </item>
/// <item>
/// <term>CLIP_EMBEDDED</term>
/// <term>You must specify this flag to use an embedded read-only font.</term>
/// </item>
/// <item>
/// <term>CLIP_LH_ANGLES</term>
/// <term>
/// When this value is used, the rotation for all fonts depends on whether the orientation of the coordinate system is left-handed or
/// right-handed. If not used, device fonts always rotate counterclockwise, but the rotation of other fonts is dependent on the
/// orientation of the coordinate system. For more information about the orientation of coordinate systems, see the description of
/// the nOrientation parameter
/// </term>
/// </item>
/// <item>
/// <term>CLIP_MASK</term>
/// <term>Not used.</term>
/// </item>
/// <item>
/// <term>CLIP_DFA_OVERRIDE</term>
/// <term>
/// Turns off font association for the font. This is identical to CLIP_DFA_DISABLE, but it can have problems in some situations; the
/// recommended flag to use is CLIP_DFA_DISABLE.
/// </term>
/// </item>
/// <item>
/// <term>CLIP_STROKE_PRECIS</term>
/// <term>
/// Not used by the font mapper, but is returned when raster, vector, or TrueType fonts are enumerated. For compatibility, this value
/// is always returned when enumerating fonts.
/// </term>
/// </item>
/// <item>
/// <term>CLIP_TT_ALWAYS</term>
/// <term>Not used.</term>
/// </item>
/// </list>
/// </param>
/// <param name="iQuality">
/// <para>
/// The output quality. The output quality defines how carefully GDI must attempt to match the logical-font attributes to those of an
/// actual physical font. It can be one of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>ANTIALIASED_QUALITY</term>
/// <term>Font is antialiased, or smoothed, if the font supports it and the size of the font is not too small or too large.</term>
/// </item>
/// <item>
/// <term>CLEARTYPE_QUALITY</term>
/// <term>If set, text is rendered (when possible) using ClearType antialiasing method. See Remarks for more information.</term>
/// </item>
/// <item>
/// <term>DEFAULT_QUALITY</term>
/// <term>Appearance of the font does not matter.</term>
/// </item>
/// <item>
/// <term>DRAFT_QUALITY</term>
/// <term>
/// Appearance of the font is less important than when the PROOF_QUALITY value is used. For GDI raster fonts, scaling is enabled,
/// which means that more font sizes are available, but the quality may be lower. Bold, italic, underline, and strikeout fonts are
/// synthesized, if necessary.
/// </term>
/// </item>
/// <item>
/// <term>NONANTIALIASED_QUALITY</term>
/// <term>Font is never antialiased, that is, font smoothing is not done.</term>
/// </item>
/// <item>
/// <term>PROOF_QUALITY</term>
/// <term>
/// Character quality of the font is more important than exact matching of the logical-font attributes. For GDI raster fonts, scaling
/// is disabled and the font closest in size is chosen. Although the chosen font size may not be mapped exactly when PROOF_QUALITY is
/// used, the quality of the font is high and there is no distortion of appearance. Bold, italic, underline, and strikeout fonts are
/// synthesized, if necessary.
/// </term>
/// </item>
/// </list>
/// <para>
/// If the output quality is DEFAULT_QUALITY, DRAFT_QUALITY, or PROOF_QUALITY, then the font is antialiased if the
/// SPI_GETFONTSMOOTHING system parameter is <c>TRUE</c>. Users can control this system parameter from the Control Panel. (The
/// precise wording of the setting in the Control panel depends on the version of Windows, but it will be words to the effect of
/// "Smooth edges of screen fonts".)
/// </para>
/// </param>
/// <param name="iPitchAndFamily">
/// <para>
/// The pitch and family of the font. The two low-order bits specify the pitch of the font and can be one of the following values:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>DEFAULT_PITCH</term>
/// </item>
/// <item>
/// <term>FIXED_PITCH</term>
/// </item>
/// <item>
/// <term>VARIABLE_PITCH</term>
/// </item>
/// </list>
/// <para>The four high-order bits specify the font family and can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>FF_DECORATIVE</term>
/// <term>Novelty fonts. Old English is an example.</term>
/// </item>
/// <item>
/// <term>FF_DONTCARE</term>
/// <term>Use default font.</term>
/// </item>
/// <item>
/// <term>FF_MODERN</term>
/// <term>Fonts with constant stroke width, with or without serifs. Pica, Elite, and Courier New are examples.</term>
/// </item>
/// <item>
/// <term>FF_ROMAN</term>
/// <term>Fonts with variable stroke width and with serifs. MS Serif is an example.</term>
/// </item>
/// <item>
/// <term>FF_SCRIPT</term>
/// <term>Fonts designed to look like handwriting. Script and Cursive are examples.</term>
/// </item>
/// <item>
/// <term>FF_SWISS</term>
/// <term>Fonts with variable stroke width and without serifs. MS?Sans Serif is an example.</term>
/// </item>
/// </list>
/// <para>
/// An application can specify a value for the fdwPitchAndFamily parameter by using the Boolean OR operator to join a pitch constant
/// with a family constant.
/// </para>
/// <para>
/// Font families describe the look of a font in a general way. They are intended for specifying fonts when the exact typeface
/// requested is not available.
/// </para>
/// </param>
/// <param name="pszFaceName">
/// <para>
/// A pointer to a null-terminated string that specifies the typeface name of the font. The length of this string must not exceed 32
/// characters, including the terminating null character. The EnumFontFamilies function can be used to enumerate the typeface names
/// of all currently available fonts. For more information, see the Remarks.
/// </para>
/// <para>If lpszFace is <c>NULL</c> or empty string, GDI uses the first font that matches the other specified attributes.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to a logical font.</para>
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
/// </returns>
/// <remarks>
/// <para>When you no longer need the font, call the DeleteObject function to delete it.</para>
/// <para>
/// To help protect the copyrights of vendors who provide fonts for Windows, applications should always report the exact name of a
/// selected font. Because available fonts can vary from system to system, do not assume that the selected font is always the same as
/// the requested font. For example, if you request a font named Palatino, but no such font is available on the system, the font
/// mapper will substitute a font that has similar attributes but a different name. Always report the name of the selected font to
/// the user.
/// </para>
/// <para>
/// To get the appropriate font on different language versions of the OS, call EnumFontFamiliesEx with the desired font
/// characteristics in the LOGFONT structure, then retrieve the appropriate typeface name and create the font using <c>CreateFont</c>
/// or CreateFontIndirect.
/// </para>
/// <para>
/// The font mapper for <c>CreateFont</c>,CreateFontIndirect, and CreateFontIndirectEx recognizes both the English and the localized
/// typeface name, regardless of locale.
/// </para>
/// <para>The following situations do not support ClearType antialiasing:</para>
/// <list type="bullet">
/// <item>
/// <term>Text rendered on a printer.</term>
/// </item>
/// <item>
/// <term>A display set for 256 colors or less.</term>
/// </item>
/// <item>
/// <term>Text rendered to a terminal server client.</term>
/// </item>
/// <item>
/// <term>
/// The font is not a TrueType font or an OpenType font with TrueType outlines. For example, the following do not support ClearType
/// antialiasing: Type 1 fonts, Postscript OpenType fonts without TrueType outlines, bitmap fonts, vector fonts, and device fonts.
/// </term>
/// </item>
/// <item>
/// <term>
/// The font has tuned embedded bitmaps, only for the font sizes that contain the embedded bitmaps. For example, this occurs commonly
/// in East Asian fonts.
/// </term>
/// </item>
/// </list>
/// <para>Examples</para>
/// <para>For another example, see "Setting Fonts for Menu-Item Text Strings" in Using Menus.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createfonta HFONT CreateFontA( int cHeight, int cWidth, int
// cEscapement, int cOrientation, int cWeight, DWORD bItalic, DWORD bUnderline, DWORD bStrikeOut, DWORD iCharSet, DWORD
// iOutPrecision, DWORD iClipPrecision, DWORD iQuality, DWORD iPitchAndFamily, LPCSTR pszFaceName );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "373bac6e-5d4d-4909-8096-2f0e909d2f1d")]
public static extern SafeHFONT CreateFont([Optional] int cHeight, [Optional] int cWidth, [Optional] int cEscapement, [Optional] int cOrientation,
[Optional] int cWeight, [Optional, MarshalAs(UnmanagedType.Bool)] bool bItalic, [Optional, MarshalAs(UnmanagedType.Bool)] bool bUnderline,
[Optional, MarshalAs(UnmanagedType.Bool)] bool bStrikeOut, CharacterSet iCharSet = CharacterSet.DEFAULT_CHARSET,
OutputPrecision iOutPrecision = OutputPrecision.OUT_DEFAULT_PRECIS, ClippingPrecision iClipPrecision = ClippingPrecision.CLIP_DEFAULT_PRECIS,
OutputQuality iQuality = OutputQuality.DEFAULT_QUALITY, PitchAndFamily iPitchAndFamily = PitchAndFamily.FF_DONTCARE, string pszFaceName = null);
/// <summary>
/// The <c>CreateFontIndirect</c> function creates a logical font that has the specified characteristics. The font can subsequently
/// be selected as the current font for any device context.
/// </summary>
/// <param name="lplf">A pointer to a LOGFONT structure that defines the characteristics of the logical font.</param>
/// <returns>
/// <para>If the function succeeds, the return value is a handle to a logical font.</para>
/// <para>If the function fails, the return value is <c>NULL</c>.</para>
/// </returns>
/// <remarks>
/// <para>
/// The <c>CreateFontIndirect</c> function creates a logical font with the characteristics specified in the LOGFONT structure. When
/// this font is selected by using the SelectObject function, GDI's font mapper attempts to match the logical font with an existing
/// physical font. If it fails to find an exact match, it provides an alternative whose characteristics match as many of the
/// requested characteristics as possible.
/// </para>
/// <para>
/// To get the appropriate font on different language versions of the OS, call EnumFontFamiliesEx with the desired font
/// characteristics in the LOGFONT structure, retrieve the appropriate typeface name, and create the font using CreateFont or <c>CreateFontIndirect</c>.
/// </para>
/// <para>When you no longer need the font, call the DeleteObject function to delete it.</para>
/// <para>
/// The fonts for many East Asian languages have two typeface names: an English name and a localized name. CreateFont and
/// <c>CreateFontIndirect</c> take the localized typeface name only on a system locale that matches the language, while they take the
/// English typeface name on all other system locales. The best method is to try one name and, on failure, try the other. Note that
/// EnumFonts, EnumFontFamilies, and EnumFontFamiliesEx return the English typeface name if the system locale does not match the
/// language of the font.
/// </para>
/// <para>
/// The font mapper for CreateFont, <c>CreateFontIndirect</c>, and CreateFontIndirectEx recognizes both the English and the localized
/// typeface name, regardless of locale.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Creating a Logical Font.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createfontindirecta HFONT CreateFontIndirectA( const LOGFONTA
// *lplf );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "b7919fb6-8515-4f1b-af9c-dc7eac381b90")]
public static extern SafeHFONT CreateFontIndirect(in LOGFONT lplf);
/// <summary>
/// The <c>CreateFontIndirectEx</c> function specifies a logical font that has the characteristics in the specified structure. The
/// font can subsequently be selected as the current font for any device context.
/// </summary>
/// <param name="Arg1">
/// <para>Pointer to an ENUMLOGFONTEXDV structure that defines the characteristics of a multiple master font.</para>
/// <para>Note, this function ignores the <c>elfDesignVector</c> member in ENUMLOGFONTEXDV.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the handle to the new ENUMLOGFONTEXDV structure.</para>
/// <para>If the function fails, the return value is zero. No extended error information is available.</para>
/// </returns>
/// <remarks>
/// <para>
/// The <c>CreateFontIndirectEx</c> function creates a logical font with the characteristics specified in the ENUMLOGFONTEXDV
/// structure. When this font is selected by using the SelectObject function, GDI's font mapper attempts to match the logical font
/// with an existing physical font. If it fails to find an exact match, it provides an alternative whose characteristics match as
/// many of the requested characteristics as possible.
/// </para>
/// <para>When you no longer need the font, call the DeleteObject function to delete it.</para>
/// <para>
/// The font mapper for CreateFont, CreateFontIndirect, and <c>CreateFontIndirectEx</c> recognizes both the English and the localized
/// typeface name, regardless of locale.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createfontindirectexa HFONT CreateFontIndirectExA( const
// ENUMLOGFONTEXDVA *Arg1 );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "1161b79e-f9c8-4073-97c4-1ccc1a78279b")]
public static extern SafeHFONT CreateFontIndirectEx(in ENUMLOGFONTEXDV Arg1);
/// <summary>
/// <para>
/// [The <c>CreateScalableFontResource</c> function is available for use in the operating systems specified in the Requirements
/// section. It may be
/// </para>
/// <para>altered or unavailable in subsequent versions.]</para>
/// <para>The <c>CreateScalableFontResource</c> function creates a font resource file for a scalable font.</para>
/// </summary>
/// <param name="fdwHidden">
/// <para>Specifies whether the font is a read-only font. This parameter can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>0</term>
/// <term>The font has read/write permission.</term>
/// </item>
/// <item>
/// <term>1</term>
/// <term>
/// The font has read-only permission and should be hidden from other applications in the system. When this flag is set, the font is
/// not enumerated by the EnumFonts or EnumFontFamilies function.
/// </term>
/// </item>
/// </list>
/// </param>
/// <param name="lpszFont">
/// A pointer to a null-terminated string specifying the name of the font resource file to create. If this parameter specifies an
/// existing font resource file, the function fails.
/// </param>
/// <param name="lpszFile">
/// A pointer to a null-terminated string specifying the name of the scalable font file that this function uses to create the font
/// resource file.
/// </param>
/// <param name="lpszPath">A pointer to a null-terminated string specifying the path to the scalable font file.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero.</para>
/// <para>If lpszFontRes specifies an existing font file, GetLastError returns ERROR_FILE_EXISTS</para>
/// </returns>
/// <remarks>
/// <para>
/// The <c>CreateScalableFontResource</c> function is used by applications that install TrueType fonts. An application uses the
/// <c>CreateScalableFontResource</c> function to create a font resource file (typically with a .fot file name extension) and then
/// uses the AddFontResource function to install the font. The TrueType font file (typically with a .ttf file name extension) must be
/// in the System subdirectory of the Windows directory to be used by the AddFontResource function.
/// </para>
/// <para>The <c>CreateScalableFontResource</c> function currently supports only TrueType-technology scalable fonts.</para>
/// <para>
/// When the lpszFontFile parameter specifies only a file name and extension, the lpszCurrentPath parameter must specify a path. When
/// the lpszFontFile parameter specifies a full path, the lpszCurrentPath parameter must be <c>NULL</c> or a pointer to <c>NULL</c>.
/// </para>
/// <para>
/// When only a file name and extension are specified in the lpszFontFile parameter and a path is specified in the lpszCurrentPath
/// parameter, the string in lpszFontFile is copied into the .fot file as the .ttf file that belongs to this resource. When the
/// AddFontResource function is called, the operating system assumes that the .ttf file has been copied into the System directory (or
/// into the main Windows directory in the case of a network installation). The .ttf file need not be in this directory when the
/// <c>CreateScalableFontResource</c> function is called, because the lpszCurrentPath parameter contains the directory information. A
/// resource created in this manner does not contain absolute path information and can be used in any installation.
/// </para>
/// <para>
/// When a path is specified in the lpszFontFile parameter and <c>NULL</c> is specified in the lpszCurrentPath parameter, the string
/// in lpszFontFile is copied into the .fot file. In this case, when the AddFontResource function is called, the .ttf file must be at
/// the location specified in the lpszFontFile parameter when the <c>CreateScalableFontResource</c> function was called; the
/// lpszCurrentPath parameter is not needed. A resource created in this manner contains absolute references to paths and drives and
/// does not work if the .ttf file is moved to a different location.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createscalablefontresourcea BOOL CreateScalableFontResourceA(
// DWORD fdwHidden, LPCSTR lpszFont, LPCSTR lpszFile, LPCSTR lpszPath );
[DllImport(Lib.Gdi32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "9a43a254-4cf4-46de-80b2-a83838871fd7")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool CreateScalableFontResource(uint fdwHidden, string lpszFont, string lpszFile, string lpszPath);
/// <summary>
/// <para>
/// The <c>EnumFontFamilies</c> function enumerates the fonts in a specified font family that are available on a specified device.
/// </para>
/// <para>
/// <c>Note</c> This function is provided only for compatibility with 16-bit versions of Windows. Applications should use the
/// EnumFontFamiliesEx function.
/// </para>
/// </summary>
/// <param name="hdc">A handle to the device context from which to enumerate the fonts.</param>
/// <param name="lpLogfont">
/// A pointer to a null-terminated string that specifies the family name of the desired fonts. If lpszFamily is <c>NULL</c>,
/// <c>EnumFontFamilies</c> selects and enumerates one font of each available type family.
/// </param>
/// <param name="lpProc">A pointer to the application defined callback function. For information, see EnumFontFamProc.</param>
/// <param name="lParam">
/// A pointer to application-supplied data. The data is passed to the callback function along with the font information.
/// </param>
/// <returns>The return value is the last value returned by the callback function. Its meaning is implementation specific.</returns>
/// <remarks>
/// <para>
/// For each font having the typeface name specified by the lpszFamily parameter, the <c>EnumFontFamilies</c> function retrieves
/// information about that font and passes it to the function pointed to by the lpEnumFontFamProc parameter. The application defined
/// callback function can process the font information as desired. Enumeration continues until there are no more fonts or the
/// callback function returns zero.
/// </para>
/// <para>
/// When the graphics mode on the device context is set to GM_ADVANCED using the SetGraphicsMode function and the DEVICE_FONTTYPE
/// flag is passed to the FontType parameter, this function returns a list of type 1 and OpenType fonts on the system. When the
/// graphics mode is not set to GM_ADVANCED, this function returns a list of type 1, OpenType, and TrueType fonts on the system.
/// </para>
/// <para>
/// The fonts for many East Asian languages have two typeface names: an English name and a localized name. EnumFonts,
/// <c>EnumFontFamilies</c>, and EnumFontFamiliesEx return the English typeface name if the system locale does not match the language
/// of the font.
/// </para>
/// <para>Examples</para>
/// <para>For examples, see Enumerating the Installed Fonts.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-enumfontfamiliesa int EnumFontFamiliesA( HDC hdc, LPCSTR
// lpLogfont, FONTENUMPROCA lpProc, LPARAM lParam );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "4960afbb-eeba-4030-ac89-d1ff077bb2f3")]
public static extern int EnumFontFamilies(HDC hdc, string lpLogfont, EnumFontFamProc lpProc, [Optional] IntPtr lParam);
/// <summary>
/// The <c>EnumFontFamiliesEx</c> function enumerates all uniquely-named fonts in the system that match the font characteristics
/// specified by the LOGFONT structure. <c>EnumFontFamiliesEx</c> enumerates fonts based on typeface name, character set, or both.
/// </summary>
/// <param name="hdc">A handle to the device context from which to enumerate the fonts.</param>
/// <param name="lpLogfont">
/// <para>
/// A pointer to a LOGFONT structure that contains information about the fonts to enumerate. The function examines the following members.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Member</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>lfCharSet</term>
/// <term>
/// If set to DEFAULT_CHARSET, the function enumerates all uniquely-named fonts in all character sets. (If there are two fonts with
/// the same name, only one is enumerated.) If set to a valid character set value, the function enumerates only fonts in the
/// specified character set.
/// </term>
/// </item>
/// <item>
/// <term>lfFaceName</term>
/// <term>
/// If set to an empty string, the function enumerates one font in each available typeface name. If set to a valid typeface name, the
/// function enumerates all fonts with the specified name.
/// </term>
/// </item>
/// <item>
/// <term>lfPitchAndFamily</term>
/// <term>Must be set to zero for all language versions of the operating system.</term>
/// </item>
/// </list>
/// </param>
/// <param name="lpProc">
/// A pointer to the application defined callback function. For more information, see the EnumFontFamExProc function.
/// </param>
/// <param name="lParam">
/// An application defined value. The function passes this value to the callback function along with font information.
/// </param>
/// <param name="dwFlags">This parameter is not used and must be zero.</param>
/// <returns>
/// The return value is the last value returned by the callback function. This value depends on which font families are available for
/// the specified device.
/// </returns>
/// <remarks>
/// <para>
/// The <c>EnumFontFamiliesEx</c> function does not use tagged typeface names to identify character sets. Instead, it always passes
/// the correct typeface name and a separate character set value to the callback function. The function enumerates fonts based on the
/// values of the <c>lfCharSet</c> and <c>lfFaceName</c> members in the LOGFONT structure.
/// </para>
/// <para>
/// As with EnumFontFamilies, <c>EnumFontFamiliesEx</c> enumerates all font styles. Not all styles of a font cover the same character
/// sets. For example, Fontorama Bold might contain ANSI, Greek, and Cyrillic characters, but Fontorama Italic might contain only
/// ANSI characters. For this reason, it's best not to assume that a specified font covers a specific character set, even if it is
/// the ANSI character set. The following table shows the results of various combinations of values for <c>lfCharSet</c> and <c>lfFaceName</c>.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Values</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>lfCharSet = DEFAULT_CHARSET lfFaceName = '\0'</term>
/// <term>
/// Enumerates all uniquely-named fonts within all character sets. If there are two fonts with the same name, only one is enumerated.
/// </term>
/// </item>
/// <item>
/// <term>lfCharSet = DEFAULT_CHARSET lfFaceName = a specific font</term>
/// <term>Enumerates all character sets and styles in a specific font.</term>
/// </item>
/// <item>
/// <term>lfCharSet =a specific character set lfFaceName = '\0'</term>
/// <term>Enumerates all styles of all fonts in the specific character set.</term>
/// </item>
/// <item>
/// <term>lfCharSet =a specific character set lfFaceName = a specific font</term>
/// <term>Enumerates all styles of a font in a specific character set.</term>
/// </item>
/// </list>
/// <para>The following code sample shows how these values are used.</para>
/// <para>
/// The callback functions for EnumFontFamilies and <c>EnumFontFamiliesEx</c> are very similar. The main difference is that the
/// ENUMLOGFONTEX structure includes a script field.
/// </para>
/// <para>
/// Note, based on the values of <c>lfCharSet</c> and <c>lfFaceName</c>, <c>EnumFontFamiliesEx</c> will enumerate the same font as
/// many times as there are distinct character sets in the font. This can create an extensive list of fonts which can be burdensome
/// to a user. For example, the Century Schoolbook font can appear for the Baltic, Western, Greek, Turkish, and Cyrillic character
/// sets. To avoid this, an application should filter the list of fonts.
/// </para>
/// <para>
/// The fonts for many East Asian languages have two typeface names: an English name and a localized name. EnumFonts,
/// EnumFontFamilies, and <c>EnumFontFamiliesEx</c> return the English typeface name if the system locale does not match the language
/// of the font.
/// </para>
/// <para>
/// When the graphics mode on the device context is set to GM_ADVANCED using the SetGraphicsMode function and the DEVICE_FONTTYPE
/// flag is passed to the FontType parameter, this function returns a list of type 1 and OpenType fonts on the system. When the
/// graphics mode is not set to GM_ADVANCED, this function returns a list of type 1, OpenType, and TrueType fonts on the system.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-enumfontfamiliesexa int EnumFontFamiliesExA( HDC hdc,
// LPLOGFONTA lpLogfont, FONTENUMPROCA lpProc, LPARAM lParam, DWORD dwFlags );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "4d70906d-8005-4c4a-869e-16dd3e6fa3f2")]
public static extern int EnumFontFamiliesEx(HDC hdc, in LOGFONT lpLogfont, EnumFontFamExProc lpProc, [Optional] IntPtr lParam, uint dwFlags = 0);
/// <summary>
/// The <c>EnumFontFamiliesEx</c> function enumerates all uniquely-named fonts in the system that match the font characteristics
/// specified by the LOGFONT structure. <c>EnumFontFamiliesEx</c> enumerates fonts based on typeface name, character set, or both.
/// </summary>
/// <param name="hdc">A handle to the device context from which to enumerate the fonts.</param>
/// <param name="lfCharSet">The character set.</param>
/// <param name="lfFaceName">
/// A null-terminated string that specifies the typeface name of the font. The length of this string must not exceed 32 TCHAR
/// values, including the terminating NULL. The EnumFontFamiliesEx function can be used to enumerate the typeface names of all
/// currently available fonts. If lfFaceName is an empty string, GDI uses the first font that matches the other specified attributes.
/// </param>
/// <returns>A sequence of tuples that contain the ENUMLOGFONTEXDV, ENUMTEXTMETRIC and FontType for each font family.</returns>
[PInvokeData("wingdi.h", MSDNShortId = "4d70906d-8005-4c4a-869e-16dd3e6fa3f2")]
public static IEnumerable<(ENUMLOGFONTEXDV lpelfe, ENUMTEXTMETRIC lpntme, FontType FontType)> EnumFontFamiliesEx(HDC hdc, PInvoke.CharacterSet lfCharSet = PInvoke.CharacterSet.ANSI_CHARSET, string lfFaceName = "")
{
var lf = default(LOGFONT);
lf.lfCharSet = lfCharSet;
lf.lfFaceName = lfFaceName;
var l = new List<(ENUMLOGFONTEXDV lpelfe, ENUMTEXTMETRIC lpntme, FontType FontType)>();
EnumFontFamiliesEx(hdc, lf, EnumProc);
return l;
int EnumProc(in ENUMLOGFONTEXDV lpelfe, in ENUMTEXTMETRIC lpntme, FontType FontType, IntPtr lParam)
{
l.Add((lpelfe, lpntme, FontType));
return 1;
}
}
/// <summary>
/// <para>
/// The <c>EnumFonts</c> function enumerates the fonts available on a specified device. For each font with the specified typeface
/// name, the <c>EnumFonts</c> function retrieves information about that font and passes it to the application defined callback
/// function. This callback function can process the font information as desired. Enumeration continues until there are no more fonts
/// or the callback function returns zero.
/// </para>
/// <para>
/// <c>Note</c> This function is provided only for compatibility with 16-bit versions of Windows. Applications should use the
/// EnumFontFamiliesEx function.
/// </para>
/// </summary>
/// <param name="hdc">A handle to the device context from which to enumerate the fonts.</param>
/// <param name="lpLogfont">
/// A pointer to a null-terminated string that specifies the typeface name of the desired fonts. If lpFaceName is <c>NULL</c>,
/// <c>EnumFonts</c> randomly selects and enumerates one font of each available typeface.
/// </param>
/// <param name="lpProc">A pointer to the application definedcallback function. For more information, see EnumFontsProc.</param>
/// <param name="lParam">
/// A pointer to any application-defined data. The data is passed to the callback function along with the font information.
/// </param>
/// <returns>The return value is the last value returned by the callback function. Its meaning is defined by the application.</returns>
/// <remarks>
/// <para>
/// Use EnumFontFamiliesEx instead of <c>EnumFonts</c>. The <c>EnumFontFamiliesEx</c> function differs from the <c>EnumFonts</c>
/// function in that it retrieves the style names associated with a TrueType font. With <c>EnumFontFamiliesEx</c>, you can retrieve
/// information about font styles that cannot be enumerated using the <c>EnumFonts</c> function.
/// </para>
/// <para>
/// The fonts for many East Asian languages have two typeface names: an English name and a localized name. <c>EnumFonts</c>,
/// EnumFontFamilies, and EnumFontFamiliesEx return the English typeface name if the system locale does not match the language of the font.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-enumfontsa int EnumFontsA( HDC hdc, LPCSTR lpLogfont,
// FONTENUMPROCA lpProc, LPARAM lParam );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "b5dfc38d-c400-4900-a15b-f251815ee346")]
public static extern int EnumFonts(HDC hdc, string lpLogfont, EnumFontsProc lpProc, [Optional] IntPtr lParam);
/// <summary>
/// The <c>ExtTextOut</c> function draws text using the currently selected font, background color, and text color. You can optionally
/// provide dimensions to be used for clipping, opaquing, or both.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="x">The x-coordinate, in logical coordinates, of the reference point used to position the string.</param>
/// <param name="y">The y-coordinate, in logical coordinates, of the reference point used to position the string.</param>
/// <param name="options">
/// <para>Specifies how to use the application-defined rectangle. This parameter can be one or more of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>ETO_CLIPPED</term>
/// <term>The text will be clipped to the rectangle.</term>
/// </item>
/// <item>
/// <term>ETO_GLYPH_INDEX</term>
/// <term>
/// The lpString array refers to an array returned from GetCharacterPlacement and should be parsed directly by GDI as no further
/// language-specific processing is required. Glyph indexing only applies to TrueType fonts, but the flag can be used for bitmap and
/// vector fonts to indicate that no further language processing is necessary and GDI should process the string directly. Note that
/// all glyph indexes are 16-bit values even though the string is assumed to be an array of 8-bit values for raster fonts. For
/// ExtTextOutW, the glyph indexes are saved to a metafile. However, to display the correct characters the metafile must be played
/// back using the same font. For ExtTextOutA, the glyph indexes are not saved.
/// </term>
/// </item>
/// <item>
/// <term>ETO_IGNORELANGUAGE</term>
/// <term>
/// Reserved for system use. If an application sets this flag, it loses international scripting support and in some cases it may
/// display no text at all.
/// </term>
/// </item>
/// <item>
/// <term>ETO_NUMERICSLATIN</term>
/// <term>To display numbers, use European digits.</term>
/// </item>
/// <item>
/// <term>ETO_NUMERICSLOCAL</term>
/// <term>To display numbers, use digits appropriate to the locale.</term>
/// </item>
/// <item>
/// <term>ETO_OPAQUE</term>
/// <term>The current background color should be used to fill the rectangle.</term>
/// </item>
/// <item>
/// <term>ETO_PDY</term>
/// <term>
/// When this is set, the array pointed to by lpDx contains pairs of values. The first value of each pair is, as usual, the distance
/// between origins of adjacent character cells, but the second value is the displacement along the vertical direction of the font.
/// </term>
/// </item>
/// <item>
/// <term>ETO_RTLREADING</term>
/// <term>
/// Middle East language edition of Windows: If this value is specified and a Hebrew or Arabic font is selected into the device
/// context, the string is output using right-to-left reading order. If this value is not specified, the string is output in
/// left-to-right order. The same effect can be achieved by setting the TA_RTLREADING value in SetTextAlign. This value is preserved
/// for backward compatibility.
/// </term>
/// </item>
/// </list>
/// <para>
/// The ETO_GLYPH_INDEX and ETO_RTLREADING values cannot be used together. Because ETO_GLYPH_INDEX implies that all language
/// processing has been completed, the function ignores the ETO_RTLREADING flag if also specified.
/// </para>
/// </param>
/// <param name="lprect">
/// A pointer to an optional RECT structure that specifies the dimensions, in logical coordinates, of a rectangle that is used for
/// clipping, opaquing, or both.
/// </param>
/// <param name="lpString">
/// A pointer to a string that specifies the text to be drawn. The string does not need to be zero-terminated, since cbCount
/// specifies the length of the string.
/// </param>
/// <param name="c">
/// <para>The length of the string pointed to by lpString.</para>
/// <para>This value may not exceed 8192.</para>
/// </param>
/// <param name="lpDx">
/// A pointer to an optional array of values that indicate the distance between origins of adjacent character cells. For example,
/// lpDx[i] logical units separate the origins of character cell i and character cell i + 1.
/// </param>
/// <returns>
/// <para>
/// If the string is drawn, the return value is nonzero. However, if the ANSI version of <c>ExtTextOut</c> is called with
/// ETO_GLYPH_INDEX, the function returns <c>TRUE</c> even though the function does nothing.
/// </para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>
/// The current text-alignment settings for the specified device context determine how the reference point is used to position the
/// text. The text-alignment settings are retrieved by calling the GetTextAlign function. The text-alignment settings are altered by
/// calling the SetTextAlign function. You can use the following values for text alignment. Only one flag can be chosen from those
/// that affect horizontal and vertical alignment. In addition, only one of the two flags that alter the current position can be chosen.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Term</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>TA_BASELINE</term>
/// <term>The reference point will be on the base line of the text.</term>
/// </item>
/// <item>
/// <term>TA_BOTTOM</term>
/// <term>The reference point will be on the bottom edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_TOP</term>
/// <term>The reference point will be on the top edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_CENTER</term>
/// <term>The reference point will be aligned horizontally with the center of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_LEFT</term>
/// <term>The reference point will be on the left edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_RIGHT</term>
/// <term>The reference point will be on the right edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_NOUPDATECP</term>
/// <term>The current position is not updated after each text output call. The reference point is passed to the text output function.</term>
/// </item>
/// <item>
/// <term>TA_RTLREADING</term>
/// <term>
/// Middle East language edition of Windows: The text is laid out in right to left reading order, as opposed to the default left to
/// right order. This applies only when the font selected into the device context is either Hebrew or Arabic.
/// </term>
/// </item>
/// <item>
/// <term>TA_UPDATECP</term>
/// <term>The current position is updated after each text output call. The current position is used as the reference point.</term>
/// </item>
/// </list>
/// <para>
/// If the lpDx parameter is <c>NULL</c>, the <c>ExtTextOut</c> function uses the default spacing between characters. The
/// character-cell origins and the contents of the array pointed to by the lpDx parameter are specified in logical units. A
/// character-cell origin is defined as the upper-left corner of the character cell.
/// </para>
/// <para>
/// By default, the current position is not used or updated by this function. However, an application can call the SetTextAlign
/// function with the fMode parameter set to TA_UPDATECP to permit the system to use and update the current position each time the
/// application calls <c>ExtTextOut</c> for a specified device context. When this flag is set, the system ignores the X and Y
/// parameters on subsequent <c>ExtTextOut</c> calls.
/// </para>
/// <para>
/// For the ANSI version of <c>ExtTextOut</c>, the lpDx array has the same number of INT values as there are bytes in lpString. For
/// DBCS characters, you can apportion the dx in the lpDx entries between the lead byte and the trail byte, as long as the sum of the
/// two bytes adds up to the desired dx. For DBCS characters with the Unicode version of <c>ExtTextOut</c>, each Unicode glyph gets a
/// single pdx entry.
/// </para>
/// <para>
/// Note, the alpDx values from GetTextExtentExPoint are not the same as the lpDx values for <c>ExtTextOut</c>. To use the alpDx
/// values in lpDx, you must first process them.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see "Setting Fonts for Menu-Item Text Strings" in Using Menus.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-exttextouta BOOL ExtTextOutA( HDC hdc, int x, int y, UINT
// options, const RECT *lprect, LPCSTR lpString, UINT c, const INT *lpDx );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "74f8fcb8-8ad4-47f2-a330-fa56713bdb37")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool ExtTextOut(HDC hdc, int x, int y, ETO options, [In, Optional] PRECT lprect, string lpString, uint c, [In, Optional] int[] lpDx);
/// <summary>The <c>GetAspectRatioFilterEx</c> function retrieves the setting for the current aspect-ratio filter.</summary>
/// <param name="hdc">Handle to a device context.</param>
/// <param name="lpsize">Pointer to a SIZE structure that receives the current aspect-ratio filter.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>The aspect ratio is the ratio formed by the width and height of a pixel on a specified device.</para>
/// <para>
/// The system provides a special filter, the aspect-ratio filter, to select fonts that were designed for a particular device. An
/// application can specify that the system should only retrieve fonts matching the specified aspect ratio by calling the
/// SetMapperFlags function.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getaspectratiofilterex BOOL GetAspectRatioFilterEx( HDC hdc,
// LPSIZE lpsize );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "3f2dd47d-08bf-4848-897f-5ae506fba342")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetAspectRatioFilterEx(HDC hdc, out SIZE lpsize);
/// <summary>
/// The <c>GetCharABCWidths</c> function retrieves the widths, in logical units, of consecutive characters in a specified range from
/// the current TrueType font. This function succeeds only with TrueType fonts.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="wFirst">The first character in the group of consecutive characters from the current font.</param>
/// <param name="wLast">The last character in the group of consecutive characters from the current font.</param>
/// <param name="lpABC">
/// A pointer to an array of ABC structures that receives the character widths, in logical units. This array must contain at least as
/// many <c>ABC</c> structures as there are characters in the range specified by the uFirstChar and uLastChar parameters.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>
/// The TrueType rasterizer provides ABC character spacing after a specific point size has been selected. A spacing is the distance
/// added to the current position before placing the glyph. B spacing is the width of the black part of the glyph. C spacing is the
/// distance added to the current position to provide white space to the right of the glyph. The total advanced width is specified by A+B+C.
/// </para>
/// <para>
/// When the <c>GetCharABCWidths</c> function retrieves negative A or C widths for a character, that character includes underhangs or overhangs.
/// </para>
/// <para>
/// To convert the ABC widths to font design units, an application should use the value stored in the <c>otmEMSquare</c> member of a
/// OUTLINETEXTMETRIC structure. This value can be retrieved by calling the GetOutlineTextMetrics function.
/// </para>
/// <para>The ABC widths of the default character are used for characters outside the range of the currently selected font.</para>
/// <para>To retrieve the widths of characters in non-TrueType fonts, applications should use the GetCharWidth function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getcharabcwidthsa BOOL GetCharABCWidthsA( HDC hdc, UINT
// wFirst, UINT wLast, LPABC lpABC );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "b48ab66d-ff0a-48d9-b7dd-28610bf69d51")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetCharABCWidths(HDC hdc, uint wFirst, uint wLast, [In, Out] ABC[] lpABC);
/// <summary>
/// The <c>GetCharABCWidthsFloat</c> function retrieves the widths, in logical units, of consecutive characters in a specified range
/// from the current font.
/// </summary>
/// <param name="hdc">Handle to the device context.</param>
/// <param name="iFirst">
/// Specifies the code point of the first character in the group of consecutive characters where the ABC widths are seeked.
/// </param>
/// <param name="iLast">
/// Specifies the code point of the last character in the group of consecutive characters where the ABC widths are seeked. This range
/// is inclusive. An error is returned if the specified last character precedes the specified first character.
/// </param>
/// <param name="lpABC">Pointer to an array of ABCFLOAT structures that receives the character widths, 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>
/// Unlike the GetCharABCWidths function that returns widths only for TrueType fonts, the <c>GetCharABCWidthsFloat</c> function
/// retrieves widths for any font. The widths returned by this function are in the IEEE floating-point format.
/// </para>
/// <para>
/// If the current world-to-device transformation is not identified, the returned widths may be noninteger values, even if the
/// corresponding values in the device space are integers.
/// </para>
/// <para>
/// A spacing is the distance added to the current position before placing the glyph. B spacing is the width of the black part of the
/// glyph. C spacing is the distance added to the current position to provide white space to the right of the glyph. The total
/// advanced width is specified by A+B+C.
/// </para>
/// <para>The ABC spaces are measured along the character base line of the selected font.</para>
/// <para>The ABC widths of the default character are used for characters outside the range of the currently selected font.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getcharabcwidthsfloata BOOL GetCharABCWidthsFloatA( HDC hdc,
// UINT iFirst, UINT iLast, LPABCFLOAT lpABC );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "552942c9-e2a6-43f9-901f-3aba1e2523e5")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetCharABCWidthsFloat(HDC hdc, uint iFirst, uint iLast, [In, Out] ABCFLOAT[] lpABC);
/// <summary>
/// The <c>GetCharABCWidthsI</c> function retrieves the widths, in logical units, of consecutive glyph indices in a specified range
/// from the current TrueType font. This function succeeds only with TrueType fonts.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="giFirst">
/// The first glyph index in the group of consecutive glyph indices from the current font. This parameter is only used if the pgi
/// parameter is <c>NULL</c>.
/// </param>
/// <param name="cgi">The number of glyph indices.</param>
/// <param name="pgi">
/// A pointer to an array that contains glyph indices. If this parameter is <c>NULL</c>, the giFirst parameter is used instead. The
/// cgi parameter specifies the number of glyph indices in this array.
/// </param>
/// <param name="pabc">
/// A pointer to an array of ABC structures that receives the character widths, in logical units. This array must contain at least as
/// many <c>ABC</c> structures as there are glyph indices specified by the cgi parameter.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>
/// The TrueType rasterizer provides ABC character spacing after a specific point size has been selected. A spacing is the distance
/// added to the current position before placing the glyph. B spacing is the width of the black part of the glyph. C spacing is the
/// distance added to the current position to provide white space to the right of the glyph. The total advanced width is specified by A+B+C.
/// </para>
/// <para>
/// When the <c>GetCharABCWidthsI</c> function retrieves negative A or C widths for a character, that character includes underhangs
/// or overhangs.
/// </para>
/// <para>
/// To convert the ABC widths to font design units, an application should use the value stored in the <c>otmEMSquare</c> member of a
/// OUTLINETEXTMETRIC structure. This value can be retrieved by calling the GetOutlineTextMetrics function.
/// </para>
/// <para>The ABC widths of the default character are used for characters outside the range of the currently selected font.</para>
/// <para>To retrieve the widths of glyph indices in non-TrueType fonts, applications should use the GetCharWidthI function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getcharabcwidthsi BOOL GetCharABCWidthsI( HDC hdc, UINT
// giFirst, UINT cgi, LPWORD pgi, LPABC pabc );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "7d1210ee-42b7-4f2e-9e89-fb1543d76290")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetCharABCWidthsI(HDC hdc, uint giFirst, uint cgi, [In, Optional] ushort[] pgi, [In, Out] ABC[] pabc);
/// <summary>
/// <para>
/// The <c>GetCharacterPlacement</c> function retrieves information about a character string, such as character widths, caret
/// positioning, ordering within the string, and glyph rendering. The type of information returned depends on the dwFlags parameter
/// and is based on the currently selected font in the specified display context. The function copies the information to the
/// specified GCP_RESULTS structure or to one or more arrays specified by the structure.
/// </para>
/// <para>
/// Although this function was once adequate for working with character strings, a need to work with an increasing number of
/// languages and scripts has rendered it obsolete. It has been superseded by the functionality of the Uniscribe module. For more
/// information, see Uniscribe.
/// </para>
/// <para>
/// It is recommended that an application use the GetFontLanguageInfo function to determine whether the GCP_DIACRITIC, GCP_DBCS,
/// GCP_USEKERNING, GCP_LIGATE, GCP_REORDER, GCP_GLYPHSHAPE, and GCP_KASHIDA values are valid for the currently selected font. If not
/// valid, <c>GetCharacterPlacement</c> ignores the value.
/// </para>
/// <para>The GCP_NODIACRITICS value is no longer defined and should not be used.</para>
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="lpString">
/// A pointer to the character string to process. The string does not need to be zero-terminated, since nCount specifies the length
/// of the string.
/// </param>
/// <param name="nCount">The length of the string pointed to by lpString.</param>
/// <param name="nMexExtent">
/// The maximum extent (in logical units) to which the string is processed. Characters that, if processed, would exceed this extent
/// are ignored. Computations for any required ordering or glyph arrays apply only to the included characters. This parameter is used
/// only if the GCP_MAXEXTENT value is specified in the dwFlags parameter. As the function processes the input string, each character
/// and its extent is added to the output, extent, and other arrays only if the total extent has not yet exceeded the maximum. Once
/// the limit is reached, processing will stop.
/// </param>
/// <param name="lpResults">A pointer to a GCP_RESULTS structure that receives the results of the function.</param>
/// <param name="dwFlags">
/// <para>Specifies how to process the string into the required arrays. This parameter can be one or more of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GCP_CLASSIN</term>
/// <term>
/// Specifies that the lpClass array contains preset classifications for characters. The classifications may be the same as on
/// output. If the particular classification for a character is not known, the corresponding location in the array must be set to
/// zero. for more information about the classifications, see GCP_RESULTS. This is useful only if GetFontLanguageInfo returned the
/// GCP_REORDER flag.
/// </term>
/// </item>
/// <item>
/// <term>GCP_DIACRITIC</term>
/// <term>
/// Determines how diacritics in the string are handled. If this value is not set, diacritics are treated as zero-width characters.
/// For example, a Hebrew string may contain diacritics, but you may not want to display them. Use GetFontLanguageInfo to determine
/// whether a font supports diacritics. If it does, you can use or not use the GCP_DIACRITIC flag in the call to
/// GetCharacterPlacement, depending on the needs of your application.
/// </term>
/// </item>
/// <item>
/// <term>GCP_DISPLAYZWG</term>
/// <term>
/// For languages that need reordering or different glyph shapes depending on the positions of the characters within a word,
/// nondisplayable characters often appear in the code page. For example, in the Hebrew code page, there are Left-To-Right and
/// Right-To-Left markers, to help determine the final positioning of characters within the output strings. Normally these are not
/// displayed and are removed from the lpGlyphs and lpDx arrays. You can use the GCP_DISPLAYZWG flag to display these characters.
/// </term>
/// </item>
/// <item>
/// <term>GCP_GLYPHSHAPE</term>
/// <term>
/// Specifies that some or all characters in the string are to be displayed using shapes other than the standard shapes defined in
/// the currently selected font for the current code page. Some languages, such as Arabic, cannot support glyph creation unless this
/// value is specified. As a general rule, if GetFontLanguageInfo returns this value for a string, this value must be used with GetCharacterPlacement.
/// </term>
/// </item>
/// <item>
/// <term>GCP_JUSTIFY</term>
/// <term>
/// Adjusts the extents in the lpDx array so that the string length is the same as nMaxExtent. GCP_JUSTIFY may only be used in
/// conjunction with GCP_MAXEXTENT.
/// </term>
/// </item>
/// <item>
/// <term>GCP_KASHIDA</term>
/// <term>
/// Use Kashidas as well as, or instead of, adjusted extents to modify the length of the string so that it is equal to the value
/// specified by nMaxExtent. In the lpDx array, a Kashida is indicated by a negative justification index. GCP_KASHIDA may be used
/// only in conjunction with GCP_JUSTIFY and only if the font (and language) support Kashidas. Use GetFontLanguageInfo to determine
/// whether the current font supports Kashidas. Using Kashidas to justify the string can result in the number of glyphs required
/// being greater than the number of characters in the input string. Because of this, when Kashidas are used, the application cannot
/// assume that setting the arrays to be the size of the input string will be sufficient. (The maximum possible will be approximately
/// dxPageWidth/dxAveCharWidth, where dxPageWidth is the width of the document and dxAveCharWidth is the average character width as
/// returned from a GetTextMetrics call). Note that just because GetFontLanguageInfo returns the GCP_KASHIDA flag does not mean that
/// it has to be used in the call to GetCharacterPlacement, just that the option is available.
/// </term>
/// </item>
/// <item>
/// <term>GCP_LIGATE</term>
/// <term>
/// Use ligations wherever characters ligate. A ligation occurs where one glyph is used for two or more characters. For example, the
/// letters a and e can ligate to ?. For this to be used, however, both the language support and the font must support the required
/// glyphs (the example will not be processed by default in English). Use GetFontLanguageInfo to determine whether the current font
/// supports ligation. If it does and a specific maximum is required for the number of characters that will ligate, set the number in
/// the first element of the lpGlyphs array. If normal ligation is required, set this value to zero. If GCP_LIGATE is not specified,
/// no ligation will take place. See GCP_RESULTS for more information. If the GCP_REORDER value is usually required for the character
/// set but is not specified, the output will be meaningless unless the string being passed in is already in visual ordering (that
/// is, the result that gets put into lpGcpResults-&gt;lpOutString in one call to GetCharacterPlacement is the input string of a
/// second call). Note that just because GetFontLanguageInfo returns the GCP_LIGATE flag does not mean that it has to be used in the
/// call to GetCharacterPlacement, just that the option is available.
/// </term>
/// </item>
/// <item>
/// <term>GCP_MAXEXTENT</term>
/// <term>
/// Compute extents of the string only as long as the resulting extent, in logical units, does not exceed the values specified by the
/// nMaxExtent parameter.
/// </term>
/// </item>
/// <item>
/// <term>GCP_NEUTRALOVERRIDE</term>
/// <term>
/// Certain languages only. Override the normal handling of neutrals and treat them as strong characters that match the strings
/// reading order. Useful only with the GCP_REORDER flag.
/// </term>
/// </item>
/// <item>
/// <term>GCP_NUMERICOVERRIDE</term>
/// <term>
/// Certain languages only. Override the normal handling of numerics and treat them as strong characters that match the strings
/// reading order. Useful only with the GCP_REORDER flag.
/// </term>
/// </item>
/// <item>
/// <term>GCP_NUMERICSLATIN</term>
/// <term>
/// Arabic/Thai only. Use standard Latin glyphs for numbers and override the system default. To determine if this option is available
/// in the language of the font, use GetStringTypeEx to see if the language supports more than one number format.
/// </term>
/// </item>
/// <item>
/// <term>GCP_NUMERICSLOCAL</term>
/// <term>
/// Arabic/Thai only. Use local glyphs for numeric characters and override the system default. To determine if this option is
/// available in the language of the font, use GetStringTypeEx to see if the language supports more than one number format.
/// </term>
/// </item>
/// <item>
/// <term>GCP_REORDER</term>
/// <term>
/// Reorder the string. Use for languages that are not SBCS and left-to-right reading order. If this value is not specified, the
/// string is assumed to be in display order already. If this flag is set for Semitic languages and the lpClass array is used, the
/// first two elements of the array are used to specify the reading order beyond the bounds of the string. GCP_CLASS_PREBOUNDRTL and
/// GCP_CLASS_PREBOUNDLTR can be used to set the order. If no preset order is required, set the values to zero. These values can be
/// combined with other values if the GCPCLASSIN flag is set. If the GCP_REORDER value is not specified, the lpString parameter is
/// taken to be visual ordered for languages where this is used, and the lpOutString and lpOrder fields are ignored. Use
/// GetFontLanguageInfo to determine whether the current font supports reordering.
/// </term>
/// </item>
/// <item>
/// <term>GCP_SYMSWAPOFF</term>
/// <term>
/// Semitic languages only. Specifies that swappable characters are not reset. For example, in a right-to-left string, the '(' and
/// ')' are not reversed.
/// </term>
/// </item>
/// <item>
/// <term>GCP_USEKERNING</term>
/// <term>
/// Use kerning pairs in the font (if any) when creating the widths arrays. Use GetFontLanguageInfo to determine whether the current
/// font supports kerning pairs. Note that just because GetFontLanguageInfo returns the GCP_USEKERNING flag does not mean that it has
/// to be used in the call to GetCharacterPlacement, just that the option is available. Most TrueType fonts have a kerning table, but
/// you do not have to use it.
/// </term>
/// </item>
/// </list>
/// <para>
/// It is recommended that an application use the GetFontLanguageInfo function to determine whether the GCP_DIACRITIC, GCP_DBCS,
/// GCP_USEKERNING, GCP_LIGATE, GCP_REORDER, GCP_GLYPHSHAPE, and GCP_KASHIDA values are valid for the currently selected font. If not
/// valid, <c>GetCharacterPlacement</c> ignores the value.
/// </para>
/// <para>The GCP_NODIACRITICS value is no longer defined and should not be used.</para>
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is the width and height of the string in logical units. The width is the low-order
/// word and the height is the high-order word.
/// </para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>
/// <c>GetCharacterPlacement</c> ensures that an application can correctly process text regardless of the international setting and
/// type of fonts available. Applications use this function before using the ExtTextOut function and in place of the
/// GetTextExtentPoint32 function (and occasionally in place of the GetCharWidth32 and GetCharABCWidths functions).
/// </para>
/// <para>
/// Using <c>GetCharacterPlacement</c> to retrieve intercharacter spacing and index arrays is not always necessary unless
/// justification or kerning is required. For non-Latin fonts, applications can improve the speed at which the ExtTextOut function
/// renders text by using <c>GetCharacterPlacement</c> to retrieve the intercharacter spacing and index arrays before calling
/// <c>ExtTextOut</c>. This is especially useful when rendering the same text repeatedly or when using intercharacter spacing to
/// position the caret. If the <c>lpGlyphs</c> output array is used in the call to <c>ExtTextOut</c>, the ETO_GLYPH_INDEX flag must
/// be set.
/// </para>
/// <para>
/// <c>GetCharacterPlacement</c> checks the <c>lpOrder</c>, <c>lpDX</c>, <c>lpCaretPos</c>, <c>lpOutString</c>, and <c>lpGlyphs</c>
/// members of the GCP_RESULTS structure and fills the corresponding arrays if these members are not set to <c>NULL</c>. If
/// <c>GetCharacterPlacement</c> cannot fill an array, it sets the corresponding member to <c>NULL</c>. To ensure retrieval of valid
/// information, the application is responsible for setting the member to a valid address before calling the function and for
/// checking the value of the member after the call. If the GCP_JUSTIFY or GCP_USEKERNING values are specified, the <c>lpDX</c>
/// and/or <c>lpCaretPos</c> members must have valid addresses.
/// </para>
/// <para>
/// Note that the glyph indexes returned in GCP_RESULTS.lpGlyphs are specific to the current font in the device context and should
/// only be used to draw text in the device context while that font remains selected.
/// </para>
/// <para>
/// When computing justification, if the trailing characters in the string are spaces, the function reduces the length of the string
/// and removes the spaces prior to computing the justification. If the array consists of only spaces, the function returns an error.
/// </para>
/// <para>
/// ExtTextOut expects an <c>lpDX</c> entry for each byte of a DBCS string, whereas <c>GetCharacterPlacement</c> assigns an
/// <c>lpDX</c> entry for each glyph. To correct this mismatch when using this combination of functions, either use GetGlyphIndices
/// or expand the <c>lpDX</c> array with zero-width entries for the corresponding second byte of a DBCS byte pair.
/// </para>
/// <para>
/// If the logical width is less than the width of the leading character in the input string, GCP_RESULTS.nMaxFit returns a bad
/// value. For this case, call <c>GetCharacterPlacement</c> for glyph indexes and the <c>lpDX</c> array. Then use the <c>lpDX</c>
/// array to do the extent calculation using the advance width of each character, where <c>nMaxFit</c> is the number of characters
/// whose glyph indexes advance width is less than the width of the leading character.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getcharacterplacementa DWORD GetCharacterPlacementA( HDC hdc,
// LPCSTR lpString, int nCount, int nMexExtent, LPGCP_RESULTSA lpResults, DWORD dwFlags );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "80d3f4b3-503b-4abb-826c-e5c09972ba2f")]
public static extern uint GetCharacterPlacement(HDC hdc, string lpString, int nCount, int nMexExtent, out GCP_RESULTS lpResults, GCP dwFlags);
/// <summary>
/// The <c>GetCharWidth32</c> function retrieves the widths, in logical coordinates, of consecutive characters in a specified range
/// from the current font.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="iFirst">The first character in the group of consecutive characters.</param>
/// <param name="iLast">The last character in the group of consecutive characters, which must not precede the specified first character.</param>
/// <param name="lpBuffer">A pointer to a buffer that receives the character widths, in logical coordinates.</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><c>GetCharWidth32</c> cannot be used on TrueType fonts. To retrieve character widths for TrueType fonts, use GetCharABCWidths.</para>
/// <para>
/// The range is inclusive; that is, the returned widths include the widths of the characters specified by the iFirstChar and
/// iLastChar parameters.
/// </para>
/// <para>If a character does not exist in the current font, it is assigned the width of the default character.</para>
/// <para>Examples</para>
/// <para>For an example, see "Displaying Keyboard Input" in Using Keyboard Input.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getcharwidth32a BOOL GetCharWidth32A( HDC hdc, UINT iFirst,
// UINT iLast, LPINT lpBuffer );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "f7d6e9b3-72aa-42d8-8346-b230b9e98237")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetCharWidth32(HDC hdc, uint iFirst, uint iLast, [Out] int[] lpBuffer);
/// <summary>
/// The <c>GetCharWidthFloat</c> function retrieves the fractional widths of consecutive characters in a specified range from the
/// current font.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="iFirst">The code point of the first character in the group of consecutive characters.</param>
/// <param name="iLast">The code point of the last character in the group of consecutive characters.</param>
/// <param name="lpBuffer">A pointer to a buffer that receives the character widths, 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>
/// The returned widths are in the 32-bit IEEE floating-point format. (The widths are measured along the base line of the characters.)
/// </para>
/// <para>
/// If the iFirstChar parameter specifies the letter a and the iLastChar parameter specifies the letter z, <c>GetCharWidthFloat</c>
/// retrieves the widths of all lowercase characters.
/// </para>
/// <para>If a character does not exist in the current font, it is assigned the width of the default character.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getcharwidthfloata BOOL GetCharWidthFloatA( HDC hdc, UINT
// iFirst, UINT iLast, PFLOAT lpBuffer );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "7a90b701-63f9-41e5-9069-10d344edfe02")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetCharWidthFloat(HDC hdc, uint iFirst, uint iLast, [Out] float[] lpBuffer);
/// <summary>
/// The <c>GetCharWidthI</c> function retrieves the widths, in logical coordinates, of consecutive glyph indices in a specified range
/// from the current font.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="giFirst">The first glyph index in the group of consecutive glyph indices.</param>
/// <param name="cgi">The number of glyph indices.</param>
/// <param name="pgi">
/// A pointer to an array of glyph indices. If this parameter is not <c>NULL</c>, it is used instead of the giFirst parameter.
/// </param>
/// <param name="piWidths">A pointer to a buffer that receives the widths, in logical coordinates.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>
/// The <c>GetCharWidthI</c> function processes a consecutive glyph indices if the pgi parameter is <c>NULL</c> with the giFirst
/// parameter indicating the first glyph index to process and the cgi parameter indicating how many glyph indices to process.
/// Otherwise the <c>GetCharWidthI</c> function processes the array of glyph indices pointed to by the pgi parameter with the cgi
/// parameter indicating how many glyph indices to process.
/// </para>
/// <para>If a character does not exist in the current font, it is assigned the width of the default character.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getcharwidthi BOOL GetCharWidthI( HDC hdc, UINT giFirst, UINT
// cgi, LPWORD pgi, LPINT piWidths );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "5f532149-7c2f-4972-9900-68c2f185d255")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetCharWidthI(HDC hdc, uint giFirst, uint cgi, [In, Optional] ushort[] pgi, [Out] int[] piWidths);
/// <summary>The <c>GetFontData</c> function retrieves font metric data for a TrueType font.</summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="dwTable">
/// The name of a font metric table from which the font data is to be retrieved. This parameter can identify one of the metric tables
/// documented in the TrueType Font Files specification published by Microsoft Corporation. If this parameter is zero, the
/// information is retrieved starting at the beginning of the file for TrueType font files or from the beginning of the data for the
/// currently selected font for TrueType Collection files. To retrieve the data from the beginning of the file for TrueType
/// Collection files specify 'ttcf' (0x66637474).
/// </param>
/// <param name="dwOffset">
/// The offset from the beginning of the font metric table to the location where the function should begin retrieving information. If
/// this parameter is zero, the information is retrieved starting at the beginning of the table specified by the dwTable parameter.
/// If this value is greater than or equal to the size of the table, an error occurs.
/// </param>
/// <param name="pvBuffer">
/// A pointer to a buffer that receives the font information. If this parameter is <c>NULL</c>, the function returns the size of the
/// buffer required for the font data.
/// </param>
/// <param name="cjBuffer">
/// The length, in bytes, of the information to be retrieved. If this parameter is zero, <c>GetFontData</c> returns the size of the
/// data specified in the dwTable parameter.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the number of bytes returned.</para>
/// <para>If the function fails, the return value is GDI_ERROR.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function is intended to be used to retrieve TrueType font information directly from the font file by font-manipulation
/// applications. For information about embedding fonts see the Font Embedding Reference.
/// </para>
/// <para>
/// An application can sometimes use the <c>GetFontData</c> function to save a TrueType font with a document. To do this, the
/// application determines whether the font can be embedded by checking the <c>otmfsType</c> member of the OUTLINETEXTMETRIC
/// structure. If bit 1 of <c>otmfsType</c> is set, embedding is not permitted for the font. If bit 1 is clear, the font can be
/// embedded. If bit 2 is set, the embedding is read-only. If embedding is permitted, the application can retrieve the entire font
/// file, specifying zero for the dwTable, dwOffset, and cbData parameters.
/// </para>
/// <para>If an application attempts to use this function to retrieve information for a non-TrueType font, an error occurs.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getfontdata DWORD GetFontData( HDC hdc, DWORD dwTable, DWORD
// dwOffset, PVOID pvBuffer, DWORD cjBuffer );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "ec716ad8-bdc2-4f61-968e-f86288123cec")]
public static extern uint GetFontData(HDC hdc, [Optional] uint dwTable, [Optional] uint dwOffset, [Optional] IntPtr pvBuffer, [Optional] uint cjBuffer);
/// <summary>
/// The <c>GetFontLanguageInfo</c> function returns information about the currently selected font for the specified display context.
/// Applications typically use this information and the GetCharacterPlacement function to prepare a character string for display.
/// </summary>
/// <param name="hdc">Handle to a display device context.</param>
/// <returns>
/// <para>
/// The return value identifies characteristics of the currently selected font. The function returns 0 if the font is "normalized"
/// and can be treated as a simple Latin font; it returns GCP_ERROR if an error occurs. Otherwise, the function returns a combination
/// of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GCP_DBCS</term>
/// <term>The character set is DBCS.</term>
/// </item>
/// <item>
/// <term>GCP_DIACRITIC</term>
/// <term>The font/language contains diacritic glyphs.</term>
/// </item>
/// <item>
/// <term>FLI_GLYPHS</term>
/// <term>
/// The font contains extra glyphs not normally accessible using the code page. Use GetCharacterPlacement to access the glyphs. This
/// value is for information only and is not intended to be passed to GetCharacterPlacement.
/// </term>
/// </item>
/// <item>
/// <term>GCP_GLYPHSHAPE</term>
/// <term>
/// The font/language contains multiple glyphs per code point or per code point combination (supports shaping and/or ligation), and
/// the font contains advanced glyph tables to provide extra glyphs for the extra shapes. If this value is specified, the lpGlyphs
/// array must be used with the GetCharacterPlacement function and the ETO_GLYPHINDEX value must be passed to the ExtTextOut function
/// when the string is drawn.
/// </term>
/// </item>
/// <item>
/// <term>GCP_KASHIDA</term>
/// <term>The font/ language permits Kashidas.</term>
/// </item>
/// <item>
/// <term>GCP_LIGATE</term>
/// <term>The font/language contains ligation glyphs which can be substituted for specific character combinations.</term>
/// </item>
/// <item>
/// <term>GCP_USEKERNING</term>
/// <term>The font contains a kerning table which can be used to provide better spacing between the characters and glyphs.</term>
/// </item>
/// <item>
/// <term>GCP_REORDER</term>
/// <term>The language requires reordering for displayfor example, Hebrew or Arabic.</term>
/// </item>
/// </list>
/// <para>The return value, when masked with FLI_MASK, can be passed directly to the GetCharacterPlacement function.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getfontlanguageinfo DWORD GetFontLanguageInfo( HDC hdc );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "c2f19423-4410-44dd-83f1-5b858852051d")]
public static extern GCP GetFontLanguageInfo(HDC hdc);
/// <summary>
/// The <c>GetFontUnicodeRanges</c> function returns information about which Unicode characters are supported by a font. The
/// information is returned as a GLYPHSET structure.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="lpgs">
/// A pointer to a GLYPHSET structure that receives the glyph set information. If this parameter is <c>NULL</c>, the function returns
/// the size of the <c>GLYPHSET</c> structure required to store the information.
/// </param>
/// <returns>
/// <para>
/// If the function succeeds, it returns number of bytes written to the GLYPHSET structure or, if the lpgs parameter is <c>NULL</c>,
/// it returns the size of the GLYPHSET structure required to store the information.
/// </para>
/// <para>If the function fails, it returns zero. No extended error information is available.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getfontunicoderanges DWORD GetFontUnicodeRanges( HDC hdc,
// LPGLYPHSET lpgs );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "51b0ab12-c467-4a89-8173-fdc513868aae")]
public static extern uint GetFontUnicodeRanges(HDC hdc, IntPtr lpgs);
/// <summary>
/// The <c>GetFontUnicodeRanges</c> function returns information about which Unicode characters are supported by a font. The
/// information is returned as a GLYPHSET structure.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <returns>A <see cref="GLYPHSET"/> structure with the glyph set information.</returns>
/// <exception cref="Exception">An unspecified error has occurred.</exception>
public static GLYPHSET GetFontUnicodeRanges(HDC hdc)
{
var l = GetFontUnicodeRanges(hdc, IntPtr.Zero);
if (l == 0) throw new Exception();
using var mem = new SafeAnysizeStruct<GLYPHSET>(l, nameof(GLYPHSET.cRanges));
mem.DangerousGetHandle().Write(l); // Set cbThis
if (0 == GetFontUnicodeRanges(hdc, mem))
throw new Exception();
return mem.Value;
}
/// <summary>
/// The <c>GetGlyphIndices</c> function translates a string into an array of glyph indices. The function can be used to determine
/// whether a glyph exists in a font.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="lpstr">A pointer to the string to be converted.</param>
/// <param name="c">
/// The length of both the length of the string pointed to by lpstr and the size (in WORDs) of the buffer pointed to by pgi.
/// </param>
/// <param name="pgi">
/// This buffer must be of dimension c. On successful return, contains an array of glyph indices corresponding to the characters in
/// the string.
/// </param>
/// <param name="fl">
/// <para>Specifies how glyphs should be handled if they are not supported. This parameter can be the following value.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GGI_MARK_NONEXISTING_GLYPHS</term>
/// <term>Marks unsupported glyphs with the hexadecimal value 0xffff.</term>
/// </item>
/// </list>
/// </param>
/// <returns>
/// <para>If the function succeeds, it returns the number of bytes (for the ANSI function) or WORDs (for the Unicode function) converted.</para>
/// <para>If the function fails, the return value is GDI_ERROR.</para>
/// </returns>
/// <remarks>
/// This function attempts to identify a single-glyph representation for each character in the string pointed to by lpstr. While this
/// is useful for certain low-level purposes (such as manipulating font files), higher-level applications that wish to map a string
/// to glyphs will typically wish to use the Uniscribe functions.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getglyphindicesa DWORD GetGlyphIndicesA( HDC hdc, LPCSTR
// lpstr, int c, LPWORD pgi, DWORD fl );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "7abfee7a-dd5d-4f33-96f1-b38364ba5afd")]
public static extern uint GetGlyphIndices(HDC hdc, string lpstr, int c, [Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] ushort[] pgi, GGI fl = GGI.GGI_MARK_NONEXISTING_GLYPHS);
/// <summary>
/// The <c>GetGlyphOutline</c> function retrieves the outline or bitmap for a character in the TrueType font that is selected into
/// the specified device context.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="uChar">The character for which data is to be returned.</param>
/// <param name="fuFormat">
/// <para>The format of the data that the function retrieves. This parameter can be one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GGO_BEZIER</term>
/// <term>The function retrieves the curve data as a cubic Bézier spline (not in quadratic spline format).</term>
/// </item>
/// <item>
/// <term>GGO_BITMAP</term>
/// <term>The function retrieves the glyph bitmap. For information about memory allocation, see the following Remarks section.</term>
/// </item>
/// <item>
/// <term>GGO_GLYPH_INDEX</term>
/// <term>
/// Indicates that the uChar parameter is a TrueType Glyph Index rather than a character code. See the ExtTextOut function for
/// additional remarks on Glyph Indexing.
/// </term>
/// </item>
/// <item>
/// <term>GGO_GRAY2_BITMAP</term>
/// <term>The function retrieves a glyph bitmap that contains five levels of gray.</term>
/// </item>
/// <item>
/// <term>GGO_GRAY4_BITMAP</term>
/// <term>The function retrieves a glyph bitmap that contains 17 levels of gray.</term>
/// </item>
/// <item>
/// <term>GGO_GRAY8_BITMAP</term>
/// <term>The function retrieves a glyph bitmap that contains 65 levels of gray.</term>
/// </item>
/// <item>
/// <term>GGO_METRICS</term>
/// <term>
/// The function only retrieves the GLYPHMETRICS structure specified by lpgm. The lpvBuffer is ignored. This value affects the
/// meaning of the function's return value upon failure; see the Return Values section.
/// </term>
/// </item>
/// <item>
/// <term>GGO_NATIVE</term>
/// <term>The function retrieves the curve data points in the rasterizer's native format and uses the font's design units.</term>
/// </item>
/// <item>
/// <term>GGO_UNHINTED</term>
/// <term>The function only returns unhinted outlines. This flag only works in conjunction with GGO_BEZIER and GGO_NATIVE.</term>
/// </item>
/// </list>
/// <para>
/// Note that, for the GGO_GRAYn_BITMAP values, the function retrieves a glyph bitmap that contains n^2+1 (n squared plus one) levels
/// of gray.
/// </para>
/// </param>
/// <param name="lpgm">A pointer to the GLYPHMETRICS structure describing the placement of the glyph in the character cell.</param>
/// <param name="cjBuffer">
/// The size, in bytes, of the buffer (*lpvBuffer) where the function is to copy information about the outline character. If this
/// value is zero, the function returns the required size of the buffer.
/// </param>
/// <param name="pvBuffer">
/// A pointer to the buffer that receives information about the outline character. If this value is <c>NULL</c>, the function returns
/// the required size of the buffer.
/// </param>
/// <param name="lpmat2">A pointer to a MAT2 structure specifying a transformation matrix for the character.</param>
/// <returns>
/// <para>
/// If GGO_BITMAP, GGO_GRAY2_BITMAP, GGO_GRAY4_BITMAP, GGO_GRAY8_BITMAP, or GGO_NATIVE is specified and the function succeeds, the
/// return value is greater than zero; otherwise, the return value is GDI_ERROR. If one of these flags is specified and the buffer
/// size or address is zero, the return value specifies the required buffer size, in bytes.
/// </para>
/// <para>If GGO_METRICS is specified and the function fails, the return value is GDI_ERROR.</para>
/// </returns>
/// <remarks>
/// <para>
/// The glyph outline returned by the <c>GetGlyphOutline</c> function is for a grid-fitted glyph. (A grid-fitted glyph is a glyph
/// that has been modified so that its bitmapped image conforms as closely as possible to the original design of the glyph.) If an
/// application needs an unmodified glyph outline, it can request the glyph outline for a character in a font whose size is equal to
/// the font's em unit. The value for a font's em unit is stored in the <c>otmEMSquare</c> member of the OUTLINETEXTMETRIC structure.
/// </para>
/// <para>
/// The glyph bitmap returned by <c>GetGlyphOutline</c> when GGO_BITMAP is specified is a DWORD-aligned, row-oriented, monochrome
/// bitmap. When GGO_GRAY2_BITMAP is specified, the bitmap returned is a DWORD-aligned, row-oriented array of bytes whose values
/// range from 0 to 4. When GGO_GRAY4_BITMAP is specified, the bitmap returned is a DWORD-aligned, row-oriented array of bytes whose
/// values range from 0 to 16. When GGO_GRAY8_BITMAP is specified, the bitmap returned is a DWORD-aligned, row-oriented array of
/// bytes whose values range from 0 to 64.
/// </para>
/// <para>
/// The native buffer returned by <c>GetGlyphOutline</c> when GGO_NATIVE is specified is a glyph outline. A glyph outline is returned
/// as a series of one or more contours defined by a TTPOLYGONHEADER structure followed by one or more curves. Each curve in the
/// contour is defined by a TTPOLYCURVE structure followed by a number of POINTFX data points. <c>POINTFX</c> points are absolute
/// positions, not relative moves. The starting point of a contour is given by the <c>pfxStart</c> member of the
/// <c>TTPOLYGONHEADER</c> structure. The starting point of each curve is the last point of the previous curve or the starting point
/// of the contour. The count of data points in a curve is stored in the <c>cpfx</c> member of <c>TTPOLYCURVE</c> structure. The size
/// of each contour in the buffer, in bytes, is stored in the <c>cb</c> member of <c>TTPOLYGONHEADER</c> structure. Additional curve
/// definitions are packed into the buffer following preceding curves and additional contours are packed into the buffer following
/// preceding contours. The buffer contains as many contours as fit within the buffer returned by <c>GetGlyphOutline</c>.
/// </para>
/// <para>
/// The GLYPHMETRICS structure specifies the width of the character cell and the location of a glyph within the character cell. The
/// origin of the character cell is located at the left side of the cell at the baseline of the font. The location of the glyph
/// origin is relative to the character cell origin. The height of a character cell, the baseline, and other metrics global to the
/// font are given by the OUTLINETEXTMETRIC structure.
/// </para>
/// <para>
/// An application can alter the characters retrieved in bitmap or native format by specifying a 2-by-2 transformation matrix in the
/// lpMatrix parameter. For example the glyph can be modified by shear, rotation, scaling, or any combination of the three using
/// matrix multiplication.
/// </para>
/// <para>Additional information on a glyph outlines is located in the TrueType and the OpenType technical specifications.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getglyphoutlinea DWORD GetGlyphOutlineA( HDC hdc, UINT uChar,
// UINT fuFormat, LPGLYPHMETRICS lpgm, DWORD cjBuffer, LPVOID pvBuffer, const MAT2 *lpmat2 );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "08f06007-5b21-44ab-b234-21a58c94ed4e")]
public static extern uint GetGlyphOutline(HDC hdc, uint uChar, GGO fuFormat, out GLYPHMETRICS lpgm, uint cjBuffer, IntPtr pvBuffer, in MAT2 lpmat2);
/// <summary>
/// The <c>GetKerningPairs</c> function retrieves the character-kerning pairs for the currently selected font for the specified
/// device context.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="nPairs">
/// The number of pairs in the lpkrnpair array. If the font has more than nNumPairs kerning pairs, the function returns an error.
/// </param>
/// <param name="lpKernPair">
/// A pointer to an array of KERNINGPAIR structures that receives the kerning pairs. The array must contain at least as many
/// structures as specified by the nNumPairs parameter. If this parameter is <c>NULL</c>, the function returns the total number of
/// kerning pairs for the font.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the number of kerning pairs returned.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getkerningpairsa DWORD GetKerningPairsA( HDC hdc, DWORD
// nPairs, LPKERNINGPAIR lpKernPair );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "9aba629f-afab-4ef3-8e1d-d0b90e122e94")]
public static extern uint GetKerningPairs(HDC hdc, uint nPairs, [Out] KERNINGPAIR[] lpKernPair);
/// <summary>The <c>GetOutlineTextMetrics</c> function retrieves text metrics for TrueType fonts.</summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="cjCopy">The size, in bytes, of the array that receives the text metrics.</param>
/// <param name="potm">
/// A pointer to an OUTLINETEXTMETRIC structure. If this parameter is <c>NULL</c>, the function returns the size of the buffer
/// required for the retrieved metric data.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero or the size of the required buffer.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// The OUTLINETEXTMETRIC structure contains most of the text metric information provided for TrueType fonts (including a TEXTMETRIC
/// structure). The sizes returned in <c>OUTLINETEXTMETRIC</c> are in logical units; they depend on the current mapping mode.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getoutlinetextmetricsa UINT GetOutlineTextMetricsA( HDC hdc,
// UINT cjCopy, LPOUTLINETEXTMETRICA potm );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "b8c7a557-ca35-41a4-9043-8496e5b01564")]
public static extern uint GetOutlineTextMetrics(HDC hdc, uint cjCopy, IntPtr potm);
/// <summary>The <c>GetRasterizerCaps</c> function returns flags indicating whether TrueType fonts are installed in the system.</summary>
/// <param name="lpraststat">A pointer to a RASTERIZER_STATUS structure that receives information about the rasterizer.</param>
/// <param name="cjBytes">The number of bytes to be copied into the structure pointed to by the lprs parameter.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>
/// The <c>GetRasterizerCaps</c> function enables applications and printer drivers to determine whether TrueType fonts are installed.
/// </para>
/// <para>
/// If the TT_AVAILABLE flag is set in the <c>wFlags</c> member of the RASTERIZER_STATUS structure, at least one TrueType font is
/// installed. If the TT_ENABLED flag is set, TrueType is enabled for the system.
/// </para>
/// <para>
/// The actual number of bytes copied is either the member specified in the cb parameter or the length of the RASTERIZER_STATUS
/// structure, whichever is less.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-getrasterizercaps BOOL GetRasterizerCaps( LPRASTERIZER_STATUS
// lpraststat, UINT cjBytes );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "0898d1c0-5480-4bd2-aa45-918340172a05")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetRasterizerCaps(out RASTERIZER_STATUS lpraststat, uint cjBytes);
/// <summary>The <c>GetTextAlign</c> function retrieves the text-alignment setting for the specified device context.</summary>
/// <param name="hdc">A handle to the device context.</param>
/// <returns>
/// <para>
/// If the function succeeds, the return value is the status of the text-alignment flags. For more information about the return
/// value, see the Remarks section. The return value is a combination of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>TA_BASELINE</term>
/// <term>The reference point is on the base line of the text.</term>
/// </item>
/// <item>
/// <term>TA_BOTTOM</term>
/// <term>The reference point is on the bottom edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_TOP</term>
/// <term>The reference point is on the top edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_CENTER</term>
/// <term>The reference point is aligned horizontally with the center of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_LEFT</term>
/// <term>The reference point is on the left edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_RIGHT</term>
/// <term>The reference point is on the right edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_RTLREADING</term>
/// <term>
/// Middle East language edition of Windows: The text is laid out in right to left reading order, as opposed to the default left to
/// right order. This only applies when the font selected into the device context is either Hebrew or Arabic.
/// </term>
/// </item>
/// <item>
/// <term>TA_NOUPDATECP</term>
/// <term>The current position is not updated after each text output call.</term>
/// </item>
/// <item>
/// <term>TA_UPDATECP</term>
/// <term>The current position is updated after each text output call.</term>
/// </item>
/// </list>
/// <para>
/// When the current font has a vertical default base line (as with Kanji), the following values are used instead of TA_BASELINE and TA_CENTER.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>VTA_BASELINE</term>
/// <term>The reference point is on the base line of the text.</term>
/// </item>
/// <item>
/// <term>VTA_CENTER</term>
/// <term>The reference point is aligned vertically with the center of the bounding rectangle.</term>
/// </item>
/// </list>
/// <para>If the function fails, the return value is GDI_ERROR.</para>
/// </returns>
/// <remarks>
/// <para>
/// The bounding rectangle is a rectangle bounding all of the character cells in a string of text. Its dimensions can be obtained by
/// calling the GetTextExtentPoint32 function.
/// </para>
/// <para>
/// The text-alignment flags determine how the TextOut and ExtTextOut functions align a string of text in relation to the string's
/// reference point provided to <c>TextOut</c> or <c>ExtTextOut</c>.
/// </para>
/// <para>
/// The text-alignment flags are not necessarily single bit flags and may be equal to zero. The flags must be examined in groups of
/// related flags, as shown in the following list.
/// </para>
/// <list type="bullet">
/// <item>
/// <term>TA_LEFT, TA_RIGHT, and TA_CENTER</term>
/// </item>
/// <item>
/// <term>TA_BOTTOM, TA_TOP, and TA_BASELINE</term>
/// </item>
/// <item>
/// <term>TA_NOUPDATECP and TA_UPDATECP</term>
/// </item>
/// </list>
/// <para>If the current font has a vertical default base line, the related flags are as shown in the following list.</para>
/// <list type="bullet">
/// <item>
/// <term>TA_LEFT, TA_RIGHT, and VTA_BASELINE</term>
/// </item>
/// <item>
/// <term>TA_BOTTOM, TA_TOP, and VTA_CENTER</term>
/// </item>
/// <item>
/// <term>TA_NOUPDATECP and TA_UPDATECP</term>
/// </item>
/// </list>
/// <para><c>To verify that a particular flag is set in the return value of this function:</c></para>
/// <list type="number">
/// <item>
/// <term>Apply the bitwise OR operator to the flag and its related flags.</term>
/// </item>
/// <item>
/// <term>Apply the bitwise AND operator to the result and the return value.</term>
/// </item>
/// <item>
/// <term>Test for the equality of this result and the flag.</term>
/// </item>
/// </list>
/// <para>Examples</para>
/// <para>For an example, see Setting the Text Alignment.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextalign UINT GetTextAlign( HDC hdc );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "d3ec0350-2eb8-4843-88bb-d72cece710e7")]
public static extern TextAlign GetTextAlign(HDC hdc);
/// <summary>
/// The <c>GetTextCharacterExtra</c> function retrieves the current intercharacter spacing for the specified device context.
/// </summary>
/// <param name="hdc">Handle to the device context.</param>
/// <returns>
/// <para>If the function succeeds, the return value is the current intercharacter spacing, in logical coordinates.</para>
/// <para>If the function fails, the return value is 0x8000000.</para>
/// </returns>
/// <remarks>
/// The intercharacter spacing defines the extra space, in logical units along the base line, that the TextOut or ExtTextOut
/// functions add to each character as a line is written. The spacing is used to expand lines of text.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextcharacterextra int GetTextCharacterExtra( HDC hdc );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "44d5145d-1c42-429e-89c4-dc31d275bc73")]
public static extern int GetTextCharacterExtra(HDC hdc);
/// <summary>The <c>GetTextColor</c> function retrieves the current text color for the specified device context.</summary>
/// <param name="hdc">Handle to the device context.</param>
/// <returns>
/// <para>If the function succeeds, the return value is the current text color as a COLORREF value.</para>
/// <para>If the function fails, the return value is CLR_INVALID. No extended error information is available.</para>
/// </returns>
/// <remarks>The text color defines the foreground color of characters drawn by using the TextOut or ExtTextOut function.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextcolor COLORREF GetTextColor( HDC hdc );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "d3d91b86-5143-431a-ba18-b951b832d7b6")]
public static extern COLORREF GetTextColor(HDC hdc);
/// <summary>
/// The <c>GetTextExtentExPoint</c> function retrieves the number of characters in a specified string that will fit within a
/// specified space and fills an array with the text extent for each of those characters. (A text extent is the distance between the
/// beginning of the space and a character that will fit in the space.) This information is useful for word-wrapping calculations.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="lpszString">A pointer to the null-terminated string for which extents are to be retrieved.</param>
/// <param name="cchString">
/// The number of characters in the string pointed to by the lpszStr parameter. For an ANSI call it specifies the string length in
/// bytes and for a Unicode it specifies the string length in WORDs. Note that for the ANSI function, characters in SBCS code pages
/// take one byte each, while most characters in DBCS code pages take two bytes; for the Unicode function, most currently defined
/// Unicode characters (those in the Basic Multilingual Plane (BMP)) are one WORD while Unicode surrogates are two WORDs.
/// </param>
/// <param name="nMaxExtent">The maximum allowable width, in logical units, of the formatted string.</param>
/// <param name="lpnFit">
/// A pointer to an integer that receives a count of the maximum number of characters that will fit in the space specified by the
/// nMaxExtent parameter. When the lpnFit parameter is <c>NULL</c>, the nMaxExtent parameter is ignored.
/// </param>
/// <param name="lpnDx">
/// <para>
/// A pointer to an array of integers that receives partial string extents. Each element in the array gives the distance, in logical
/// units, between the beginning of the string and one of the characters that fits in the space specified by the nMaxExtent
/// parameter. This array must have at least as many elements as characters specified by the cchString parameter because the entire
/// array is used internally. The function fills the array with valid extents for as many characters as are specified by the lpnFit
/// parameter. Any values in the rest of the array should be ignored. If alpDx is <c>NULL</c>, the function does not compute partial
/// string widths.
/// </para>
/// <para>
/// For complex scripts, where a sequence of characters may be represented by any number of glyphs, the values in the alpDx array up
/// to the number specified by the lpnFit parameter match one-to-one with code points. Again, you should ignore the rest of the
/// values in the alpDx array.
/// </para>
/// </param>
/// <param name="lpSize">
/// A pointer to a SIZE structure that receives the dimensions of the string, in logical units. This parameter cannot be <c>NULL</c>.
/// </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 both the lpnFit and alpDx parameters are <c>NULL</c>, calling the <c>GetTextExtentExPoint</c> function is equivalent to
/// calling the GetTextExtentPoint function.
/// </para>
/// <para>
/// For the ANSI version of <c>GetTextExtentExPoint</c>, the lpDx array has the same number of INT values as there are bytes in
/// lpString. The INT values that correspond to the two bytes of a DBCS character are each the extent of the entire composite character.
/// </para>
/// <para>
/// Note, the alpDx values for <c>GetTextExtentExPoint</c> are not the same as the lpDx values for ExtTextOut. To use the alpDx
/// values in lpDx, you must first process them.
/// </para>
/// <para>
/// When this function returns the text extent, it assumes that the text is horizontal, that is, that the escapement is always 0.
/// This is true for both the horizontal and vertical measurements of the text. Even if you use a font that specifies a nonzero
/// escapement, this function doesn't use the angle while it computes the text extent. The app must convert it explicitly. However,
/// when the graphics mode is set to GM_ADVANCED and the character orientation is 90 degrees from the print orientation, the values
/// that this function return do not follow this rule. When the character orientation and the print orientation match for a given
/// string, this function returns the dimensions of the string in the SIZE structure as { cx : 116, cy : 18 }. When the character
/// orientation and the print orientation are 90 degrees apart for the same string, this function returns the dimensions of the
/// string in the <c>SIZE</c> structure as { cx : 18, cy : 116 }.
/// </para>
/// <para>
/// This function returns the extent of each successive character in a string. When these are rounded to logical units, you get
/// different results than what is returned from the GetCharWidth, which returns the width of each individual character rounded to
/// logical units.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextextentexpointa BOOL GetTextExtentExPointA( HDC hdc,
// LPCSTR lpszString, int cchString, int nMaxExtent, LPINT lpnFit, LPINT lpnDx, LPSIZE lpSize );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "b873a059-5aa3-47d0-b109-7acd542c7d79")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetTextExtentExPoint(HDC hdc, string lpszString, int cchString, int nMaxExtent, out int lpnFit, [Out] int[] lpnDx, out SIZE lpSize);
/// <summary>
/// The <c>GetTextExtentExPointI</c> function retrieves the number of characters in a specified string that will fit within a
/// specified space and fills an array with the text extent for each of those characters. (A text extent is the distance between the
/// beginning of the space and a character that will fit in the space.) This information is useful for word-wrapping calculations.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="lpwszString">A pointer to an array of glyph indices for which extents are to be retrieved.</param>
/// <param name="cwchString">The number of glyphs in the array pointed to by the pgiIn parameter.</param>
/// <param name="nMaxExtent">The maximum allowable width, in logical units, of the formatted string.</param>
/// <param name="lpnFit">
/// A pointer to an integer that receives a count of the maximum number of characters that will fit in the space specified by the
/// nMaxExtent parameter. When the lpnFit parameter is <c>NULL</c>, the nMaxExtent parameter is ignored.
/// </param>
/// <param name="lpnDx">
/// A pointer to an array of integers that receives partial glyph extents. Each element in the array gives the distance, in logical
/// units, between the beginning of the glyph indices array and one of the glyphs that fits in the space specified by the nMaxExtent
/// parameter. Although this array should have at least as many elements as glyph indices specified by the cgi parameter, the
/// function fills the array with extents only for as many glyph indices as are specified by the lpnFit parameter. If lpnFit is
/// <c>NULL</c>, the function does not compute partial string widths.
/// </param>
/// <param name="lpSize">
/// A pointer to a SIZE structure that receives the dimensions of the glyph indices array, in logical units. This value cannot be <c>NULL</c>.
/// </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 both the lpnFit and alpDx parameters are <c>NULL</c>, calling the <c>GetTextExtentExPointI</c> function is equivalent to
/// calling the GetTextExtentPointI function.
/// </para>
/// <para>
/// When this function returns the text extent, it assumes that the text is horizontal, that is, that the escapement is always 0.
/// This is true for both the horizontal and vertical measurements of the text. Even if you use a font that specifies a nonzero
/// escapement, this function doesn't use the angle while it computes the text extent. The app must convert it explicitly. However,
/// when the graphics mode is set to GM_ADVANCED and the character orientation is 90 degrees from the print orientation, the values
/// that this function return do not follow this rule. When the character orientation and the print orientation match for a given
/// string, this function returns the dimensions of the string in the SIZE structure as { cx : 116, cy : 18 }. When the character
/// orientation and the print orientation are 90 degrees apart for the same string, this function returns the dimensions of the
/// string in the <c>SIZE</c> structure as { cx : 18, cy : 116 }.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextextentexpointi BOOL GetTextExtentExPointI( HDC hdc,
// LPWORD lpwszString, int cwchString, int nMaxExtent, LPINT lpnFit, LPINT lpnDx, LPSIZE lpSize );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "d543ec43-f6f1-4463-b27d-a1abf1cf3961")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetTextExtentExPointI(HDC hdc, [In] ushort[] lpwszString, int cwchString, int nMaxExtent, out int lpnFit, [Out] int[] lpnDx, out SIZE lpSize);
/// <summary>
/// <para>The <c>GetTextExtentPoint</c> function computes the width and height of the specified string of text.</para>
/// <para>
/// <c>Note</c> This function is provided only for compatibility with 16-bit versions of Windows. Applications should call the
/// GetTextExtentPoint32 function, which provides more accurate results.
/// </para>
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="lpString">
/// A pointer to the string that specifies the text. The string does not need to be zero-terminated, since cbString specifies the
/// length of the string.
/// </param>
/// <param name="c">The length of the string pointed to by lpString.</param>
/// <param name="lpsz">A pointer to a SIZE structure that receives the dimensions of the string, 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>
/// The <c>GetTextExtentPoint</c> function uses the currently selected font to compute the dimensions of the string. The width and
/// height, in logical units, are computed without considering any clipping. Also, this function assumes that the text is horizontal,
/// that is, that the escapement is always 0. This is true for both the horizontal and vertical measurements of the text. Even if
/// using a font specifying a nonzero escapement, this function will not use the angle while computing the text extent. The
/// application must convert it explicitly.
/// </para>
/// <para>
/// Because some devices kern characters, the sum of the extents of the characters in a string may not be equal to the extent of the string.
/// </para>
/// <para>The calculated string width takes into account the intercharacter spacing set by the SetTextCharacterExtra function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextextentpointa BOOL GetTextExtentPointA( HDC hdc, LPCSTR
// lpString, int c, LPSIZE lpsz );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "731085ce-009d-42e1-885f-2f5151e0f6d3")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetTextExtentPoint(HDC hdc, string lpString, int c, out SIZE lpsz);
/// <summary>The <c>GetTextExtentPoint32</c> function computes the width and height of the specified string of text.</summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="lpString">
/// A pointer to a buffer that specifies the text string. The string does not need to be null-terminated, because the c parameter
/// specifies the length of the string.
/// </param>
/// <param name="c">The length of the string pointed to by lpString.</param>
/// <param name="psizl">A pointer to a SIZE structure that receives the dimensions of the string, 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>
/// The <c>GetTextExtentPoint32</c> function uses the currently selected font to compute the dimensions of the string. The width and
/// height, in logical units, are computed without considering any clipping.
/// </para>
/// <para>
/// Because some devices kern characters, the sum of the extents of the characters in a string may not be equal to the extent of the string.
/// </para>
/// <para>
/// The calculated string width takes into account the intercharacter spacing set by the SetTextCharacterExtra function and the
/// justification set by SetTextJustification. This is true for both displaying on a screen and for printing. However, if lpDx is set
/// in ExtTextOut, <c>GetTextExtentPoint32</c> does not take into account either intercharacter spacing or justification. In
/// addition, for EMF, the print result always takes both intercharacter spacing and justification into account.
/// </para>
/// <para>
/// When dealing with text displayed on a screen, the calculated string width takes into account the intercharacter spacing set by
/// the SetTextCharacterExtra function and the justification set by SetTextJustification. However, if lpDx is set in ExtTextOut,
/// <c>GetTextExtentPoint32</c> does not take into account either intercharacter spacing or justification. However, when printing
/// with EMF:
/// </para>
/// <list type="bullet">
/// <item>
/// <term>The print result ignores intercharacter spacing, although <c>GetTextExtentPoint32</c> takes it into account.</term>
/// </item>
/// <item>
/// <term>The print result takes justification into account, although <c>GetTextExtentPoint32</c> ignores it.</term>
/// </item>
/// </list>
/// <para>
/// When this function returns the text extent, it assumes that the text is horizontal, that is, that the escapement is always 0.
/// This is true for both the horizontal and vertical measurements of the text. Even if you use a font that specifies a nonzero
/// escapement, this function doesn't use the angle while it computes the text extent. The app must convert it explicitly. However,
/// when the graphics mode is set to GM_ADVANCED and the character orientation is 90 degrees from the print orientation, the values
/// that this function return do not follow this rule. When the character orientation and the print orientation match for a given
/// string, this function returns the dimensions of the string in the SIZE structure as { cx : 116, cy : 18 }. When the character
/// orientation and the print orientation are 90 degrees apart for the same string, this function returns the dimensions of the
/// string in the <c>SIZE</c> structure as { cx : 18, cy : 116 }.
/// </para>
/// <para>
/// <c>GetTextExtentPoint32</c> doesn't consider "\n" (new line) or "\r\n" (carriage return and new line) characters when it computes
/// the height of a text string.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Drawing Text from Different Fonts on the Same Line.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextextentpoint32a BOOL GetTextExtentPoint32A( HDC hdc,
// LPCSTR lpString, int c, LPSIZE psizl );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "530280ee-dfd8-4905-9b72-6c19efcff133")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetTextExtentPoint32(HDC hdc, string lpString, int c, out SIZE psizl);
/// <summary>The <c>GetTextExtentPointI</c> function computes the width and height of the specified array of glyph indices.</summary>
/// <param name="hdc">Handle to the device context.</param>
/// <param name="pgiIn">Pointer to array of glyph indices.</param>
/// <param name="cgi">Specifies the number of glyph indices.</param>
/// <param name="psize">Pointer to a SIZE structure that receives the dimensions of the string, 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>
/// The <c>GetTextExtentPointI</c> function uses the currently selected font to compute the dimensions of the array of glyph indices.
/// The width and height, in logical units, are computed without considering any clipping.
/// </para>
/// <para>
/// When this function returns the text extent, it assumes that the text is horizontal, that is, that the escapement is always 0.
/// This is true for both the horizontal and vertical measurements of the text. Even if you use a font that specifies a nonzero
/// escapement, this function doesn't use the angle while it computes the text extent. The app must convert it explicitly. However,
/// when the graphics mode is set to GM_ADVANCED and the character orientation is 90 degrees from the print orientation, the values
/// that this function return do not follow this rule. When the character orientation and the print orientation match for a given
/// string, this function returns the dimensions of the string in the SIZE structure as { cx : 116, cy : 18 }. When the character
/// orientation and the print orientation are 90 degrees apart for the same string, this function returns the dimensions of the
/// string in the <c>SIZE</c> structure as { cx : 18, cy : 116 }.
/// </para>
/// <para>
/// Because some devices kern characters, the sum of the extents of the individual glyph indices may not be equal to the extent of
/// the entire array of glyph indices.
/// </para>
/// <para>The calculated string width takes into account the intercharacter spacing set by the SetTextCharacterExtra function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextextentpointi BOOL GetTextExtentPointI( HDC hdc, LPWORD
// pgiIn, int cgi, LPSIZE psize );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "d06a48dd-3f38-4c60-a4c6-954e43f718d1")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetTextExtentPointI(HDC hdc, [In] ushort[] pgiIn, int cgi, out SIZE psize);
/// <summary>
/// The <c>GetTextFace</c> function retrieves the typeface name of the font that is selected into the specified device context.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="c">
/// The length of the buffer pointed to by lpFaceName. For the ANSI function it is a BYTE count and for the Unicode function it is a
/// WORD count. Note that for the ANSI function, characters in SBCS code pages take one byte each, while most characters in DBCS code
/// pages take two bytes; for the Unicode function, most currently defined Unicode characters (those in the Basic Multilingual Plane
/// (BMP)) are one WORD while Unicode surrogates are two WORDs.
/// </param>
/// <param name="lpName">
/// A pointer to the buffer that receives the typeface name. If this parameter is <c>NULL</c>, the function returns the number of
/// characters in the name, including the terminating null character.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the number of characters copied to the buffer.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>The typeface name is copied as a null-terminated character string.</para>
/// <para>If the name is longer than the number of characters specified by the nCount parameter, the name is truncated.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextfacea int GetTextFaceA( HDC hdc, int c, LPSTR lpName );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "c4c8c8f5-3651-481b-a55f-da7f49d92f3a")]
public static extern int GetTextFace(HDC hdc, int c, [Optional] StringBuilder lpName);
/// <summary>The <c>GetTextMetrics</c> function fills the specified buffer with the metrics for the currently selected font.</summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="lptm">A pointer to the TEXTMETRIC structure that receives the text metrics.</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 determine whether a font is a TrueType font, first select it into a DC, then call <c>GetTextMetrics</c>, and then check for
/// TMPF_TRUETYPE in TEXTMETRIC.tmPitchAndFamily. Note that GetDC returns an uninitialized DC, which has "System" (a bitmap font) as
/// the default font; thus the need to select a font into the DC.
/// </para>
/// <para>Examples</para>
/// <para>
/// For an example, see "Displaying Keyboard Input" in Using Keyboard Input or Drawing Text from Different Fonts on the Same Line.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-gettextmetricsa BOOL GetTextMetricsA( HDC hdc, LPTEXTMETRICA
// lptm );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "92d45a3b-12df-42ff-8d87-5c27b44dc481")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool GetTextMetrics(HDC hdc, out TEXTMETRIC lptm);
/// <summary>
/// The <c>PolyTextOut</c> function draws several strings using the font and text colors currently selected in the specified device context.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="ppt">
/// A pointer to an array of POLYTEXT structures describing the strings to be drawn. The array contains one structure for each string
/// to be drawn.
/// </param>
/// <param name="nstrings">The number of POLYTEXT structures in the pptxt array.</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>
/// Each POLYTEXT structure contains the coordinates of a reference point that Windows uses to align the corresponding string of
/// text. An application can specify how the reference point is used by calling the SetTextAlign function. An application can
/// determine the current text-alignment setting for the specified device context by calling the GetTextAlign function.
/// </para>
/// <para>To draw a single string of text, the application should call the ExtTextOut function.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-polytextouta BOOL PolyTextOutA( HDC hdc, const POLYTEXTA *ppt,
// int nstrings );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "643b4f6a-843f-4795-adc8-a90223bdc246")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool PolyTextOut(HDC hdc, [In] POLYTEXT[] ppt, int nstrings);
/// <summary>The <c>RemoveFontMemResourceEx</c> function removes the fonts added from a memory image file.</summary>
/// <param name="h">A handle to the font-resource. This handle is returned by the AddFontMemResourceEx function.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. No extended error information is available.</para>
/// </returns>
/// <remarks>
/// This function removes a font that was added by the AddFontMemResourceEx function. To remove the font, specify the same path and
/// flags as were used in <c>AddFontMemResourceEx</c>. This function will only remove the font that is specified by fh.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-removefontmemresourceex BOOL RemoveFontMemResourceEx( HANDLE h );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "b73c3f1d-c508-418c-a5a2-105a35ec3a9b")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool RemoveFontMemResourceEx(HANDLE h);
/// <summary>
/// <para>The <c>RemoveFontResource</c> function removes the fonts in the specified file from the system font table.</para>
/// <para>If the font was added using the AddFontResourceEx function, you must use the RemoveFontResourceEx function.</para>
/// </summary>
/// <param name="lpFileName">A pointer to a null-terminated string that names a font resource file.</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>
/// We recommend that if an app adds or removes fonts from the system font table that it notify other windows of the change by
/// sending a WM_FONTCHANGE message to all top-level windows in the system. The app sends this message by calling the SendMessage
/// function with the hwnd parameter set to HWND_BROADCAST.
/// </para>
/// <para>
/// If there are outstanding references to a font, the associated resource remains loaded until no device context is using it.
/// Furthermore, if the font is listed in the font registry ( <c>HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
/// NT\CurrentVersion\Fonts</c>) and is installed to any location other than the %windir%\fonts\ folder, it may be loaded into other
/// active sessions (including session 0).
/// </para>
/// <para>
/// When you try to replace an existing font file that contains a font with outstanding references to it, you might get an error that
/// indicates that the original font can't be deleted because it’s in use even after you call <c>RemoveFontResource</c>. If your app
/// requires that the font file be replaced, to reduce the resource count of the original font to zero, call
/// <c>RemoveFontResource</c> in a loop as shown in this example code. If you continue to get errors, this is an indication that the
/// font file remains loaded in other sessions. Make sure the font isn't listed in the font registry and restart the system to ensure
/// the font is unloaded from all sessions.
/// </para>
/// <para>
/// <c>Note</c> Apps where the original font file is in use will still be able to access the original file and won't use the new font
/// until the font reloads. Call AddFontResource to reload the font. We recommend that you call <c>AddFontResource</c> the same
/// number of times as the call to <c>RemoveFontResource</c> succeeded as shown in this example code.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-removefontresourcea BOOL RemoveFontResourceA( LPCSTR
// lpFileName );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "ccc0ac8b-e373-47a9-a362-64fd79a33d0c")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool RemoveFontResource(string lpFileName);
/// <summary>The <c>RemoveFontResourceEx</c> function removes the fonts in the specified file from the system font table.</summary>
/// <param name="name">A pointer to a null-terminated string that names a font resource file.</param>
/// <param name="fl">
/// The characteristics of the font to be removed from the system. In order for the font to be removed, the flags used must be the
/// same as when the font was added with the AddFontResourceEx function. See the <see cref="AddFontResourceEx"/> function for more information.
/// </param>
/// <param name="pdv">Reserved. Must be zero.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero. No extended error information is available.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function will only remove the font if the flags specified are the same as when then font was added with the
/// AddFontResourceEx function.
/// </para>
/// <para>
/// When you try to replace an existing font file that contains a font with outstanding references to it, you might get an error that
/// indicates that the original font can't be deleted because it’s in use even after you call <c>RemoveFontResourceEx</c>. If your
/// app requires that the font file be replaced, to reduce the resource count of the original font to zero, call
/// <c>RemoveFontResourceEx</c> in a loop as shown in this example code. If you continue to get errors, this is an indication that
/// the font file remains loaded in other sessions. Make sure the font isn't listed in the font registry and restart the system to
/// ensure the font is unloaded from all sessions.
/// </para>
/// <para>
/// <c>Note</c> Apps where the original font file is in use will still be able to access the original file and won't use the new font
/// until the font reloads. Call AddFontResourceEx to reload the font. We recommend that you call <c>AddFontResourceEx</c> the same
/// number of times as the call to <c>RemoveFontResourceEx</c> succeeded as shown in this example code.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-removefontresourceexa BOOL RemoveFontResourceExA( LPCSTR name,
// DWORD fl, PVOID pdv );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "18056fe7-1efe-428e-a828-3217c53371eb")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool RemoveFontResourceEx(string name, FR fl, IntPtr pdv = default);
/// <summary>
/// The <c>SetMapperFlags</c> function alters the algorithm the font mapper uses when it maps logical fonts to physical fonts.
/// </summary>
/// <param name="hdc">A handle to the device context that contains the font-mapper flag.</param>
/// <param name="flags">
/// Specifies whether the font mapper should attempt to match a font's aspect ratio to the current device's aspect ratio. If bit zero
/// is set, the mapper selects only matching fonts.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the previous value of the font-mapper flag.</para>
/// <para>If the function fails, the return value is GDI_ERROR.</para>
/// </returns>
/// <remarks>
/// <para>
/// If the dwFlag parameter is set and no matching fonts exist, Windows chooses a new aspect ratio and retrieves a font that matches
/// this ratio.
/// </para>
/// <para>The remaining bits of the dwFlag parameter must be zero.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-setmapperflags DWORD SetMapperFlags( HDC hdc, DWORD flags );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "74cfe0d3-0d20-4382-8e76-55a6e2323308")]
public static extern uint SetMapperFlags(HDC hdc, uint flags);
/// <summary>The <c>SetTextAlign</c> function sets the text-alignment flags for the specified device context.</summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="align">
/// <para>
/// The text alignment by using a mask of the values in the following list. Only one flag can be chosen from those that affect
/// horizontal and vertical alignment. In addition, only one of the two flags that alter the current position can be chosen.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>TA_BASELINE</term>
/// <term>The reference point will be on the base line of the text.</term>
/// </item>
/// <item>
/// <term>TA_BOTTOM</term>
/// <term>The reference point will be on the bottom edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_TOP</term>
/// <term>The reference point will be on the top edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_CENTER</term>
/// <term>The reference point will be aligned horizontally with the center of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_LEFT</term>
/// <term>The reference point will be on the left edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_RIGHT</term>
/// <term>The reference point will be on the right edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_NOUPDATECP</term>
/// <term>The current position is not updated after each text output call. The reference point is passed to the text output function.</term>
/// </item>
/// <item>
/// <term>TA_RTLREADING</term>
/// <term>
/// Middle East language edition of Windows: The text is laid out in right to left reading order, as opposed to the default left to
/// right order. This applies only when the font selected into the device context is either Hebrew or Arabic.
/// </term>
/// </item>
/// <item>
/// <term>TA_UPDATECP</term>
/// <term>The current position is updated after each text output call. The current position is used as the reference point.</term>
/// </item>
/// </list>
/// <para>
/// When the current font has a vertical default base line, as with Kanji, the following values must be used instead of TA_BASELINE
/// and TA_CENTER.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>VTA_BASELINE</term>
/// <term>The reference point will be on the base line of the text.</term>
/// </item>
/// <item>
/// <term>VTA_CENTER</term>
/// <term>The reference point will be aligned vertically with the center of the bounding rectangle.</term>
/// </item>
/// </list>
/// <para>The default values are TA_LEFT, TA_TOP, and TA_NOUPDATECP.</para>
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the previous text-alignment setting.</para>
/// <para>If the function fails, the return value is GDI_ERROR.</para>
/// </returns>
/// <remarks>
/// <para>
/// The TextOut and ExtTextOut functions use the text-alignment flags to position a string of text on a display or other device. The
/// flags specify the relationship between a reference point and a rectangle that bounds the text. The reference point is either the
/// current position or a point passed to a text output function.
/// </para>
/// <para>The rectangle that bounds the text is formed by the character cells in the text string.</para>
/// <para>The best way to get left-aligned text is to use either</para>
/// <para>or</para>
/// <para>You can also use <c>SetTextAlign</c> (hdc, TA_LEFT) for this purpose, but this loses any vertical or right-to-left settings.</para>
/// <para>
/// <c>Note</c> You should not use <c>SetTextAlign</c> with TA_UPDATECP when you are using ScriptStringOut, because selected text is
/// not rendered correctly. If you must use this flag, you can unset and reset it as necessary to avoid the problem.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Setting the Text Alignment.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-settextalign UINT SetTextAlign( HDC hdc, UINT align );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "422868c5-14c9-4374-9cc5-b7bf91ab9eb4")]
public static extern TextAlign SetTextAlign(HDC hdc, TextAlign align);
/// <summary>
/// The <c>SetTextCharacterExtra</c> function sets the intercharacter spacing. Intercharacter spacing is added to each character,
/// including break characters, when the system writes a line of text.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="extra">
/// The amount of extra space, in logical units, to be added to each character. If the current mapping mode is not MM_TEXT, the
/// nCharExtra parameter is transformed and rounded to the nearest pixel.
/// </param>
/// <returns>
/// <para>If the function succeeds, the return value is the previous intercharacter spacing.</para>
/// <para>If the function fails, the return value is 0x80000000.</para>
/// </returns>
/// <remarks>
/// <para>
/// This function is supported mainly for compatibility with existing applications. New applications should generally avoid calling
/// this function, because it is incompatible with complex scripts (scripts that require text shaping; Arabic script is an example of this).
/// </para>
/// <para>
/// The recommended approach is that instead of calling this function and then TextOut, applications should call ExtTextOut and use
/// its lpDx parameter to supply widths.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-settextcharacterextra int SetTextCharacterExtra( HDC hdc, int
// extra );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "83b7d225-4fb9-4c75-bc4a-e1bea7f901f1")]
public static extern int SetTextCharacterExtra(HDC hdc, int extra);
/// <summary>The <c>SetTextColor</c> function sets the text color for the specified device context to the specified color.</summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="color">The color of the text.</param>
/// <returns>
/// <para>If the function succeeds, the return value is a color reference for the previous text color as a COLORREF value.</para>
/// <para>If the function fails, the return value is CLR_INVALID.</para>
/// </returns>
/// <remarks>
/// <para>
/// The text color is used to draw the face of each character written by the TextOut and ExtTextOut functions. The text color is also
/// used in converting bitmaps from color to monochrome and vice versa.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see "Setting Fonts for Menu-Item Text Strings" in Using Menus.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-settextcolor COLORREF SetTextColor( HDC hdc, COLORREF color );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "3875a247-7c32-4917-bf6d-50b2a49848a6")]
public static extern COLORREF SetTextColor(HDC hdc, COLORREF color);
/// <summary>
/// The <c>SetTextJustification</c> function specifies the amount of space the system should add to the break characters in a string
/// of text. The space is added when an application calls the TextOut or ExtTextOut functions.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="extra">
/// The total extra space, in logical units, to be added to the line of text. If the current mapping mode is not MM_TEXT, the value
/// identified by the nBreakExtra parameter is transformed and rounded to the nearest pixel.
/// </param>
/// <param name="count">The number of break characters in the line.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>
/// The break character is usually the space character (ASCII 32), but it may be defined by a font as some other character. The
/// GetTextMetrics function can be used to retrieve a font's break character.
/// </para>
/// <para>The TextOut function distributes the specified extra space evenly among the break characters in the line.</para>
/// <para>
/// The GetTextExtentPoint32 function is always used with the <c>SetTextJustification</c> function. Sometimes the
/// <c>GetTextExtentPoint32</c> function takes justification into account when computing the width of a specified line before
/// justification, and sometimes it does not. For more details on this, see <c>GetTextExtentPoint32</c>. This width must be known
/// before an appropriate nBreakExtra value can be computed.
/// </para>
/// <para>
/// <c>SetTextJustification</c> can be used to justify a line that contains multiple strings in different fonts. In this case, each
/// string must be justified separately.
/// </para>
/// <para>
/// Because rounding errors can occur during justification, the system keeps a running error term that defines the current error
/// value. When justifying a line that contains multiple runs, GetTextExtentPoint automatically uses this error term when it computes
/// the extent of the next run, allowing TextOut to blend the error into the new run. After each line has been justified, this error
/// term must be cleared to prevent it from being incorporated into the next line. The term can be cleared by calling
/// <c>SetTextJustification</c> with nBreakExtra set to zero.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-settextjustification BOOL SetTextJustification( HDC hdc, int
// extra, int count );
[DllImport(Lib.Gdi32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("wingdi.h", MSDNShortId = "55fb5a28-b7da-40d8-8e64-4b42c23fa8b1")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetTextJustification(HDC hdc, int extra, int count);
/// <summary>
/// The <c>TextOut</c> function writes a character string at the specified location, using the currently selected font, background
/// color, and text color.
/// </summary>
/// <param name="hdc">A handle to the device context.</param>
/// <param name="x">The x-coordinate, in logical coordinates, of the reference point that the system uses to align the string.</param>
/// <param name="y">The y-coordinate, in logical coordinates, of the reference point that the system uses to align the string.</param>
/// <param name="lpString">
/// A pointer to the string to be drawn. The string does not need to be zero-terminated, because cchString specifies the length of
/// the string.
/// </param>
/// <param name="c">The length of the string pointed to by lpString, in characters.</param>
/// <returns>
/// <para>If the function succeeds, the return value is nonzero.</para>
/// <para>If the function fails, the return value is zero.</para>
/// </returns>
/// <remarks>
/// <para>
/// The interpretation of the reference point depends on the current text-alignment mode. An application can retrieve this mode by
/// calling the GetTextAlign function; an application can alter this mode by calling the SetTextAlign function. You can use the
/// following values for text alignment. Only one flag can be chosen from those that affect horizontal and vertical alignment. In
/// addition, only one of the two flags that alter the current position can be chosen.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Term</term>
/// <term>Description</term>
/// </listheader>
/// <item>
/// <term>TA_BASELINE</term>
/// <term>The reference point will be on the base line of the text.</term>
/// </item>
/// <item>
/// <term>TA_BOTTOM</term>
/// <term>The reference point will be on the bottom edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_TOP</term>
/// <term>The reference point will be on the top edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_CENTER</term>
/// <term>The reference point will be aligned horizontally with the center of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_LEFT</term>
/// <term>The reference point will be on the left edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_RIGHT</term>
/// <term>The reference point will be on the right edge of the bounding rectangle.</term>
/// </item>
/// <item>
/// <term>TA_NOUPDATECP</term>
/// <term>The current position is not updated after each text output call. The reference point is passed to the text output function.</term>
/// </item>
/// <item>
/// <term>TA_RTLREADING</term>
/// <term>
/// Middle East language edition of Windows: The text is laid out in right to left reading order, as opposed to the default left to
/// right order. This applies only when the font selected into the device context is either Hebrew or Arabic.
/// </term>
/// </item>
/// <item>
/// <term>TA_UPDATECP</term>
/// <term>The current position is updated after each text output call. The current position is used as the reference point.</term>
/// </item>
/// </list>
/// <para>
/// By default, the current position is not used or updated by this function. However, an application can call the SetTextAlign
/// function with the fMode parameter set to TA_UPDATECP to permit the system to use and update the current position each time the
/// application calls <c>TextOut</c> for a specified device context. When this flag is set, the system ignores the nXStart and
/// nYStart parameters on subsequent <c>TextOut</c> calls.
/// </para>
/// <para>
/// When the <c>TextOut</c> function is placed inside a path bracket, the system generates a path for the TrueType text that includes
/// each character plus its character box. The region generated is the character box minus the text, rather than the text itself. You
/// can obtain the region enclosed by the outline of the TrueType text by setting the background mode to transparent before placing
/// the <c>TextOut</c> function in the path bracket. Following is sample code that demonstrates this procedure.
/// </para>
/// <para>Examples</para>
/// <para>For an example, see Enumerating the Installed Fonts.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-textouta BOOL TextOutA( HDC hdc, int x, int y, LPCSTR
// lpString, int c );
[DllImport(Lib.Gdi32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("wingdi.h", MSDNShortId = "0c437ff8-3893-4dc3-827b-fa9ce4bcd7e6")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool TextOut(HDC hdc, int x, int y, string lpString, int c);
/// <summary>The <c>ABC</c> structure contains the width of a character in a TrueType font.</summary>
/// <remarks>
/// The total width of a character is the summation of the A, B, and C spaces. Either the A or the C space can be negative to
/// indicate underhangs or overhangs.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-abc typedef struct _ABC { int abcA; UINT abcB; int abcC; }
// ABC, *PABC, *NPABC, *LPABC;
[PInvokeData("wingdi.h", MSDNShortId = "00000000-0000-0000-0000-000000000001")]
[StructLayout(LayoutKind.Sequential)]
public struct ABC
{
/// <summary>
/// The A spacing of the character. The A spacing is the distance to add to the current position before drawing the character glyph.
/// </summary>
public int abcA;
/// <summary>The B spacing of the character. The B spacing is the width of the drawn portion of the character glyph.</summary>
public uint abcB;
/// <summary>
/// The C spacing of the character. The C spacing is the distance to add to the current position to provide white space to the
/// right of the character glyph.
/// </summary>
public int abcC;
}
/// <summary>The <c>ABCFLOAT</c> structure contains the A, B, and C widths of a font character.</summary>
/// <remarks>
/// <para>The A, B, and C widths are measured along the base line of the font.</para>
/// <para>
/// The character increment (total width) of a character is the sum of the A, B, and C spaces. Either the A or the C space can be
/// negative to indicate underhangs or overhangs.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-abcfloat typedef struct _ABCFLOAT { FLOAT abcfA; FLOAT abcfB;
// FLOAT abcfC; } ABCFLOAT, *PABCFLOAT, *NPABCFLOAT, *LPABCFLOAT;
[PInvokeData("wingdi.h", MSDNShortId = "540bb00c-f0e2-4ddd-98d1-cf3ed86b6ce0")]
[StructLayout(LayoutKind.Sequential)]
public struct ABCFLOAT
{
/// <summary>
/// The A spacing of the character. The A spacing is the distance to add to the current position before drawing the character glyph.
/// </summary>
public float abcfA;
/// <summary>The B spacing of the character. The B spacing is the width of the drawn portion of the character glyph.</summary>
public float abcfB;
/// <summary>
/// The C spacing of the character. The C spacing is the distance to add to the current position to provide white space to the
/// right of the character glyph.
/// </summary>
public float abcfC;
}
/// <summary>The <c>AXESLIST</c> structure contains information on all the axes of a multiple master font.</summary>
/// <remarks>
/// <para>The PostScript Open Type Font does not support multiple master functionality.</para>
/// <para>
/// The information on the axes of a multiple master font are specified by the AXISINFO structures. The <c>axlNumAxes</c> member
/// specifies the actual size of <c>axlAxisInfo</c>, while MM_MAX_NUMAXES, which equals 16, is the maximum allowed size of <c>axlAxisInfo</c>.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-axeslista typedef struct tagAXESLISTA { DWORD axlReserved;
// DWORD axlNumAxes; AXISINFOA axlAxisInfo[MM_MAX_NUMAXES]; } AXESLISTA, *PAXESLISTA, *LPAXESLISTA;
[PInvokeData("wingdi.h", MSDNShortId = "f95f012e-f02b-46c1-94ba-69f426ee7ad9")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct AXESLIST
{
/// <summary>Reserved. Must be STAMP_AXESLIST.</summary>
public uint axlReserved;
/// <summary>Number of axes for a specified multiple master font.</summary>
public uint axlNumAxes;
/// <summary>
/// An array of AXISINFO structures. Each <c>AXISINFO</c> structure contains information on an axis of a specified multiple
/// master font. This corresponds to the <c>dvValues</c> array in the DESIGNVECTOR structure.
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public AXISINFO[] axlAxisInfo;
}
/// <summary>The <c>AXISINFO</c> structure contains information about an axis of a multiple master font.</summary>
/// <remarks>
/// <para>
/// The <c>AXISINFO</c> structure contains the name of an axis in a multiple master font and also the minimum and maximum possible
/// values for the axis. The length of the name is MM_MAX_AXES_NAMELEN, which equals 16. An application queries these values before
/// setting its desired values in the DESIGNVECTOR array.
/// </para>
/// <para>The PostScript Open Type Font does not support multiple master functionality.</para>
/// <para>For the ANSI version of this structure, <c>axAxisName</c> must be an array of bytes.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-axisinfoa typedef struct tagAXISINFOA { LONG axMinValue; LONG
// axMaxValue; BYTE axAxisName[MM_MAX_AXES_NAMELEN]; } AXISINFOA, *PAXISINFOA, *LPAXISINFOA;
[PInvokeData("wingdi.h", MSDNShortId = "a947618e-4b50-453a-82d5-5a6f825faebb")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct AXISINFO
{
/// <summary>The minimum value for this axis.</summary>
public int axMinValue;
/// <summary>The maximum value for this axis.</summary>
public int axMaxValue;
/// <summary>The name of the axis, specified as an array of characters.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
public string axAxisName;
}
/// <summary>
/// The <c>DESIGNVECTOR</c> structure is used by an application to specify values for the axes of a multiple master font.
/// </summary>
/// <remarks>
/// <para>
/// The <c>dvNumAxes</c> member determines the actual size of <c>dvValues</c>, and thus, of <c>DESIGNVECTOR</c>. The constant
/// MM_MAX_NUMAXES, which is 16, specifies the maximum allowed size of the <c>dvValues</c> array.
/// </para>
/// <para>The PostScript Open Type Font does not support multiple master functionality.</para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-designvector typedef struct tagDESIGNVECTOR { DWORD
// dvReserved; DWORD dvNumAxes; LONG dvValues[MM_MAX_NUMAXES]; } DESIGNVECTOR, *PDESIGNVECTOR, *LPDESIGNVECTOR;
[PInvokeData("wingdi.h", MSDNShortId = "aeff9901-2405-44aa-ba46-8d784afd6b76")]
[StructLayout(LayoutKind.Sequential)]
public struct DESIGNVECTOR
{
/// <summary>Reserved. Must be STAMP_DESIGNVECTOR.</summary>
public uint dvReserved;
/// <summary>Number of values in the <c>dvValues</c> array.</summary>
public uint dvNumAxes;
/// <summary>
/// An array specifying the values of the axes of a multiple master OpenType font. This array corresponds to the
/// <c>axlAxisInfo</c> array in the AXESLIST structure.
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public int[] dvValues;
}
/// <summary>
/// The <c>ENUMLOGFONT</c> structure defines the attributes of a font, the complete name of a font, and the style of a font.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-enumlogfonta typedef struct tagENUMLOGFONTA { LOGFONTA
// elfLogFont; BYTE elfFullName[LF_FULLFACESIZE]; BYTE elfStyle[LF_FACESIZE]; } ENUMLOGFONTA, *LPENUMLOGFONTA;
[PInvokeData("wingdi.h", MSDNShortId = "cfae9e97-c714-40fb-88ab-95e12ea3ffa9")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct ENUMLOGFONT
{
/// <summary>A LOGFONT structure that defines the attributes of a font.</summary>
public LOGFONT elfLogFont;
/// <summary>A unique name for the font. For example, ABCD Font Company TrueType Bold Italic Sans Serif.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)]
public string elfFullName;
/// <summary>The style of the font. For example, Bold Italic.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
public string elfStyle;
}
/// <summary>The <c>ENUMLOGFONTEX</c> structure contains information about an enumerated font.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-enumlogfontexw typedef struct tagENUMLOGFONTEXW { LOGFONTW
// elfLogFont; WCHAR elfFullName[LF_FULLFACESIZE]; WCHAR elfStyle[LF_FACESIZE]; WCHAR elfScript[LF_FACESIZE]; } ENUMLOGFONTEXW, *LPENUMLOGFONTEXW;
[PInvokeData("wingdi.h", MSDNShortId = "2e848e47-5b5f-46ad-9963-55d6bb6748a9")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct ENUMLOGFONTEX
{
/// <summary>A LOGFONT structure that contains values defining the font attributes.</summary>
public LOGFONT elfLogFont;
/// <summary>The unique name of the font. For example, ABC Font Company TrueType Bold Italic Sans Serif.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = LF_FULLFACESIZE)]
public string elfFullName;
/// <summary>The style of the font. For example, Bold Italic.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = LF_FACESIZE)]
public string elfStyle;
/// <summary>The script, that is, the character set, of the font. For example, Cyrillic.</summary>
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = LF_FACESIZE)]
public string elfScript;
}
/// <summary>The <c>ENUMLOGFONTEXDV</c> structure contains the information used to create a font.</summary>
/// <remarks>
/// <para>
/// The actual size of <c>ENUMLOGFONTEXDV</c> depends on that of DESIGNVECTOR, which, in turn depends on its <c>dvNumAxes</c> member.
/// </para>
/// <para>
/// The EnumFonts, EnumFontFamilies, and EnumFontFamiliesEx functions have been modified to return pointers to ENUMTEXTMETRIC and
/// <c>ENUMLOGFONTEXDV</c> to the callback function.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-enumlogfontexdva typedef struct tagENUMLOGFONTEXDVA {
// ENUMLOGFONTEXA elfEnumLogfontEx; DESIGNVECTOR elfDesignVector; } ENUMLOGFONTEXDVA, *PENUMLOGFONTEXDVA, *LPENUMLOGFONTEXDVA;
[PInvokeData("wingdi.h", MSDNShortId = "8d483f52-250e-4c4f-83cf-ff952bb84fd3")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct ENUMLOGFONTEXDV
{
/// <summary>An ENUMLOGFONTEX structure that contains information about the logical attributes of the font.</summary>
public ENUMLOGFONTEX elfEnumLogfontEx;
/// <summary>A DESIGNVECTOR structure. This is zero-filled unless the font described is a multiple master OpenType font.</summary>
public DESIGNVECTOR elfDesignVector;
}
/// <summary>The <c>ENUMTEXTMETRIC</c> structure contains information about a physical font.</summary>
/// <remarks>
/// <para><c>ENUMTEXTMETRIC</c> is an extension of NEWTEXTMETRICEX that includes the axis information for a multiple master font.</para>
/// <para>
/// The EnumFonts, EnumFontFamilies, and EnumFontFamiliesEx functions have been modified to return pointers to the
/// <c>ENUMTEXTMETRIC</c> and ENUMLOGFONTEXDV structures.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-enumtextmetrica typedef struct tagENUMTEXTMETRICA {
// NEWTEXTMETRICEXA etmNewTextMetricEx; AXESLISTA etmAxesList; } ENUMTEXTMETRICA, *PENUMTEXTMETRICA, *LPENUMTEXTMETRICA;
[PInvokeData("wingdi.h", MSDNShortId = "deb81846-3ada-4c88-8c26-74224538d282")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct ENUMTEXTMETRIC
{
/// <summary>A NEWTEXTMETRICEX structure, containing information about a physical font.</summary>
public NEWTEXTMETRICEX etmNewTextMetricEx;
/// <summary>
/// An AXESLIST structure, containing information about the axes for the font. This is only used for multiple master fonts.
/// </summary>
public AXESLIST etmAxesList;
}
/// <summary>The <c>FIXED</c> structure contains the integral and fractional parts of a fixed-point real number.</summary>
/// <remarks>The <c>FIXED</c> structure is used to describe the elements of the MAT2 structure.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-fixed typedef struct _FIXED { #if ... WORD fract; #if ...
// short value; #else short value; #endif #else WORD fract; #endif } FIXED;
[PInvokeData("wingdi.h", MSDNShortId = "b1d94060-e822-447f-82ba-fd1cf2ddaa3b")]
[StructLayout(LayoutKind.Sequential)]
public struct FIXED
{
/// <summary>The integral value.</summary>
public short value;
/// <summary>The fractional value.</summary>
public ushort fract;
/// <summary>Performs an implicit conversion from <see cref="Vanara.PInvoke.Gdi32.FIXED"/> to <see cref="System.Decimal"/>.</summary>
/// <param name="f">The FIXED instance.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator decimal(FIXED f) => decimal.Parse($"{f.value.ToString(NumberFormatInfo.InvariantInfo)}{NumberFormatInfo.InvariantInfo.NumberDecimalSeparator}{f.fract.ToString(NumberFormatInfo.InvariantInfo)}", NumberFormatInfo.InvariantInfo);
/// <summary>Performs an implicit conversion from <see cref="System.Decimal"/> to <see cref="Vanara.PInvoke.Gdi32.FIXED"/>.</summary>
/// <param name="d">The decimal value.</param>
/// <returns>The result of the conversion.</returns>
public static implicit operator FIXED(decimal d) => new FIXED { value = (short)Math.Truncate(d), fract = ushort.Parse(d.ToString(NumberFormatInfo.InvariantInfo).Split(new[] { NumberFormatInfo.InvariantInfo.NumberDecimalSeparator }, StringSplitOptions.None)[1], NumberFormatInfo.InvariantInfo) };
/// <summary>Converts to string.</summary>
/// <returns>A <see cref="string"/> that represents this instance.</returns>
public override string ToString() => ((decimal)this).ToString();
}
/// <summary>Contains information identifying the code pages and Unicode subranges for which a given font provides glyphs.</summary>
/// <remarks>
/// GDI relies on Windows code pages fitting within a 32-bit value. Furthermore, the highest 2 bits within this value are reserved
/// for GDI internal use and may not be assigned to code pages.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-fontsignature typedef struct tagFONTSIGNATURE { DWORD
// fsUsb[4]; DWORD fsCsb[2]; } FONTSIGNATURE, *PFONTSIGNATURE, *LPFONTSIGNATURE;
[PInvokeData("wingdi.h", MSDNShortId = "5331da53-7e3d-46e9-a922-da04fedc8382")]
[StructLayout(LayoutKind.Sequential)]
public struct FONTSIGNATURE
{
/// <summary>
/// A 128-bit Unicode subset bitfield (USB) identifying up to 126 Unicode subranges. Each bit, except the two most significant
/// bits, represents a single subrange. The most significant bit is always 1 and identifies the bitfield as a font signature; the
/// second most significant bit is reserved and must be 0. Unicode subranges are numbered in accordance with the ISO 10646
/// standard. For more information, see Unicode Subset Bitfields.
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public uint[] fsUsb;
/// <summary>
/// A 64-bit, code-page bitfield (CPB) that identifies a specific character set or code page. Code pages are in the lower 32 bits
/// of this bitfield. The high 32 are used for non-Windows code pages. For more information, see Code Page Bitfields.
/// </summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
public uint[] fsCsb;
}
/// <summary>
/// The <c>GCP_RESULTS</c> structure contains information about characters in a string. This structure receives the results of the
/// GetCharacterPlacement function. For some languages, the first element in the arrays may contain more, language-dependent information.
/// </summary>
/// <remarks>
/// <para>
/// Whether the <c>lpGlyphs</c>, <c>lpOutString</c>, or neither is required depends on the results of the GetFontLanguageInfo call.
/// </para>
/// <para>
/// In the case of a font for a language such as English, in which none of the GCP_DBCS, GCP_REORDER, GCP_GLYPHSHAPE, GCP_LIGATE,
/// GCP_DIACRITIC, or GCP_KASHIDA flags are returned, neither of the arrays is required for proper operation. (Though not required,
/// they can still be used. If the <c>lpOutString</c> array is used, it will be exactly the same as the lpInputString passed to
/// GetCharacterPlacement.) Note, however, that if GCP_MAXEXTENT is used, then <c>lpOutString</c> will contain the truncated string
/// if it is used, NOT an exact copy of the original.
/// </para>
/// <para>
/// In the case of fonts for languages such as Hebrew, which DO have reordering but do not typically have extra glyph shapes,
/// <c>lpOutString</c> should be used. This will give the string on the screen-readable order. However, the <c>lpGlyphs</c> array is
/// not typically needed. (Hebrew can have extra glyphs, if the font is a TrueType/Open font.)
/// </para>
/// <para>
/// In the case of languages such as Thai or Arabic, in which GetFontLanguageInfo returns the GCP_GLYPHSHAPE flag, the
/// <c>lpOutString</c> will give the display-readable order of the string passed to GetCharacterPlacement, but the values will still
/// be the unshaped characters. For proper display, the <c>lpGlyphs</c> array must be used.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-gcp_resultsa typedef struct tagGCP_RESULTSA { DWORD
// lStructSize; LPSTR lpOutString; UINT *lpOrder; int *lpDx; int *lpCaretPos; LPSTR lpClass; LPWSTR lpGlyphs; UINT nGlyphs; int
// nMaxFit; } GCP_RESULTSA, *LPGCP_RESULTSA;
[PInvokeData("wingdi.h", MSDNShortId = "7692637e-963a-4e0a-8a04-e05a6d01c417")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct GCP_RESULTS
{
/// <summary>The size, in bytes, of the structure.</summary>
public uint lStructSize;
/// <summary>
/// A pointer to the buffer that receives the output string or is <c>NULL</c> if the output string is not needed. The output
/// string is a version of the original string that is in the order that will be displayed on a specified device. Typically the
/// output string is identical to the original string, but may be different if the string needs reordering and the GCP_REORDER
/// flag is set or if the original string exceeds the maximum extent and the GCP_MAXEXTENT flag is set.
/// </summary>
[MarshalAs(UnmanagedType.LPTStr)]
public string lpOutString;
/// <summary>
/// <para>
/// A pointer to the array that receives ordering indexes or is <c>NULL</c> if the ordering indexes are not needed. However, its
/// meaning depends on the other elements of <c>GCP_RESULTS</c>. If glyph indexes are to be returned, the indexes are for the
/// <c>lpGlyphs</c> array; if glyphs indexes are not returned and <c>lpOrder</c> is requested, the indexes are for
/// <c>lpOutString</c>. For example, in the latter case the value of <c>lpOrder</c>[i] is the position of <c>lpString</c>[i] in
/// the output string lpOutString.
/// </para>
/// <para>
/// This is typically used when GetFontLanguageInfo returns the GCP_REORDER flag, which indicates that the original string needs
/// reordering. For example, in Hebrew, in which the text runs from right to left, the <c>lpOrder</c> array gives the exact
/// locations of each element in the original string.
/// </para>
/// </summary>
public IntPtr lpOrder;
/// <summary>
/// <para>
/// A pointer to the array that receives the distances between adjacent character cells or is <c>NULL</c> if these distances are
/// not needed. If glyph rendering is done, the distances are for the glyphs not the characters, so the resulting array can be
/// used with the ExtTextOut function.
/// </para>
/// <para>
/// The distances in this array are in display order. To find the distance for the i character in the original string, use the
/// <c>lpOrder</c> array as follows:
/// </para>
/// <para>width = lpDx[lpOrder[i]];</para>
/// </summary>
public IntPtr lpDx;
/// <summary>
/// <para>
/// A pointer to the array that receives the caret position values or is <c>NULL</c> if caret positions are not needed. Each
/// value specifies the caret position immediately before the corresponding character. In some languages the position of the
/// caret for each character may not be immediately to the left of the character. For example, in Hebrew, in which the text runs
/// from right to left, the caret position is to the right of the character. If glyph ordering is done, <c>lpCaretPos</c> matches
/// the original string, not the output string. This means that some adjacent values may be the same.
/// </para>
/// <para>
/// The values in this array are in input order. To find the caret position value for the i character in the original string, use
/// the array as follows:
/// </para>
/// <para>position = lpCaretPos[i];</para>
/// </summary>
public IntPtr lpCaretPos;
/// <summary>
/// <para>
/// A pointer to the array that contains and/or receives character classifications. The values indicate how to lay out characters
/// in the string and are similar (but not identical) to the CT_CTYPE2 values returned by the GetStringTypeEx function. Each
/// element of the array can be set to zero or one of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GCPCLASS_ARABIC</term>
/// <term>Arabic character.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_HEBREW</term>
/// <term>Hebrew character.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_LATIN</term>
/// <term>Character from a Latin or other single-byte character set for a left-to-right language.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_LATINNUMBER</term>
/// <term>Digit from a Latin or other single-byte character set for a left-to-right language.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_LOCALNUMBER</term>
/// <term>Digit from the character set associated with the current font.</term>
/// </item>
/// </list>
/// <para>In addition, the following can be used when supplying values in the <c>lpClass</c> array with the GCP_CLASSIN flag.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GCPCLASS_LATINNUMERICSEPARATOR</term>
/// <term>Input only. Character used to separate Latin digits, such as a comma or decimal point.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_LATINNUMERICTERMINATOR</term>
/// <term>Input only. Character used to terminate Latin digits, such as a plus or minus sign.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_NEUTRAL</term>
/// <term>Input only. Character has no specific classification.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_NUMERICSEPARATOR</term>
/// <term>Input only. Character used to separate digits, such as a comma or decimal point.</term>
/// </item>
/// </list>
/// <para>
/// For languages that use the GCP_REORDER flag, the following values can also be used with the GCP_CLASSIN flag. Unlike the
/// preceding values, which can be used anywhere in the <c>lpClass</c> array, all of the following values are used only in the
/// first location in the array. All combine with other classifications.
/// </para>
/// <para>Note that GCPCLASS_PREBOUNDLTR and GCPCLASS_PREBOUNDRTL are mutually exclusive, as are GCPCLASSPOSTBOUNDLTR and GCPCLASSPOSTBOUNDRTL.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GCPCLASS_PREBOUNDLTR</term>
/// <term>Set lpClass[0] to GCPCLASS_PREBOUNDLTR to bind the string to left-to-right reading order before the string.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_PREBOUNDRTL</term>
/// <term>Set lpClass[0] to GCPCLASS_PREBOUNDRTL to bind the string to right-to-left reading order before the string.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_POSTBOUNDLTR</term>
/// <term>Set lpClass[0] to GCPCLASS_POSTBOUNDLTR to bind the string to left-to-right reading order after the string.</term>
/// </item>
/// <item>
/// <term>GCPCLASS_POSTBOUNDRTL</term>
/// <term>Set lpClass[0] to GCPCLASS_POSTBOUNDRTL to bind the string to right-to-left reading order after the string.</term>
/// </item>
/// </list>
/// <para>
/// To force the layout of a character to be carried out in a specific way, preset the classification for the corresponding array
/// element; the function leaves such preset classifications unchanged and computes classifications only for array elements that
/// have been set to zero. Preset classifications are used only if the GCP_CLASSIN flag is set and the <c>lpClass</c> array is supplied.
/// </para>
/// <para>If GetFontLanguageInfo does not return GCP_REORDER for the current font, only the GCPCLASS_LATIN value is meaningful.</para>
/// </summary>
public IntPtr lpClass;
/// <summary>
/// <para>
/// A pointer to the array that receives the values identifying the glyphs used for rendering the string or is <c>NULL</c> if
/// glyph rendering is not needed. The number of glyphs in the array may be less than the number of characters in the original
/// string if the string contains ligated glyphs. Also if reordering is required, the order of the glyphs may not be sequential.
/// </para>
/// <para>
/// This array is useful if more than one operation is being done on a string which has any form of ligation, kerning or
/// order-switching. Using the values in this array for subsequent operations saves the time otherwise required to generate the
/// glyph indices each time.
/// </para>
/// <para>
/// This array always contains glyph indices and the ETO_GLYPH_INDEX value must always be used when this array is used with the
/// ExtTextOut function.
/// </para>
/// <para>
/// When GCP_LIGATE is used, you can limit the number of characters that will be ligated together. (In Arabic for example,
/// three-character ligations are common). This is done by setting the maximum required in lpGcpResults-&gt;lpGlyphs[0]. If no
/// maximum is required, you should set this field to zero.
/// </para>
/// <para>
/// For languages such as Arabic, where GetFontLanguageInfo returns the GCP_GLYPHSHAPE flag, the glyphs for a character will be
/// different depending on whether the character is at the beginning, middle, or end of a word. Typically, the first character in
/// the input string will also be the first character in a word, and the last character in the input string will be treated as
/// the last character in a word. However, if the displayed string is a subset of the complete string, such as when displaying a
/// section of scrolled text, this may not be true. In these cases, it is desirable to force the first or last characters to be
/// shaped as not being initial or final forms. To do this, again, the first location in the <c>lpGlyphs</c> array is used by
/// performing an OR operation of the ligation value above with the values GCPGLYPH_LINKBEFORE and/or GCPGLYPH_LINKAFTER. For
/// example, a value of GCPGLYPH_LINKBEFORE | 2 means that two-character ligatures are the maximum required, and the first
/// character in the string should be treated as if it is in the middle of a word.
/// </para>
/// </summary>
public IntPtr lpGlyphs;
/// <summary>
/// On input, this member must be set to the size of the arrays pointed to by the array pointer members. On output, this is set
/// to the number of glyphs filled in, in the output arrays. If glyph substitution is not required (that is, each input character
/// maps to exactly one glyph), this member is the same as it is on input.
/// </summary>
public uint nGlyphs;
/// <summary>
/// The number of characters that fit within the extents specified by the nMaxExtent parameter of the GetCharacterPlacement
/// function. If the GCP_MAXEXTENT or GCP_JUSTIFY value is set, this value may be less than the number of characters in the
/// original string. This member is set regardless of whether the GCP_MAXEXTENT or GCP_JUSTIFY value is specified. Unlike
/// <c>nGlyphs</c>, which specifies the number of output glyphs, <c>nMaxFit</c> refers to the number of characters from the input
/// string. For Latin SBCS languages, this will be the same.
/// </summary>
public int nMaxFit;
/// <summary>The default instance of this structure with the structure size value set.</summary>
public static GCP_RESULTS Default = new GCP_RESULTS { lStructSize = (uint)Marshal.SizeOf(typeof(GCP_RESULTS)) };
}
/// <summary>
/// The <c>GLYPHMETRICS</c> structure contains information about the placement and orientation of a glyph in a character cell.
/// </summary>
/// <remarks>Values in the <c>GLYPHMETRICS</c> structure are specified in device units.</remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-glyphmetrics typedef struct _GLYPHMETRICS { UINT gmBlackBoxX;
// UINT gmBlackBoxY; POINT gmptGlyphOrigin; short gmCellIncX; short gmCellIncY; } GLYPHMETRICS, *LPGLYPHMETRICS;
[PInvokeData("wingdi.h", MSDNShortId = "a6fa3813-56f7-4b54-b21d-8aabc2309a34")]
[StructLayout(LayoutKind.Sequential)]
public struct GLYPHMETRICS
{
/// <summary>The width of the smallest rectangle that completely encloses the glyph (its black box).</summary>
public uint gmBlackBoxX;
/// <summary>The height of the smallest rectangle that completely encloses the glyph (its black box).</summary>
public uint gmBlackBoxY;
/// <summary>The x- and y-coordinates of the upper left corner of the smallest rectangle that completely encloses the glyph.</summary>
public POINT gmptGlyphOrigin;
/// <summary>The horizontal distance from the origin of the current character cell to the origin of the next character cell.</summary>
public short gmCellIncX;
/// <summary>The vertical distance from the origin of the current character cell to the origin of the next character cell.</summary>
public short gmCellIncY;
}
/// <summary>The <c>GLYPHSET</c> structure contains information about a range of Unicode code points.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-glyphset typedef struct tagGLYPHSET { DWORD cbThis; DWORD
// flAccel; DWORD cGlyphsSupported; DWORD cRanges; WCRANGE ranges[1]; } GLYPHSET, *PGLYPHSET, *LPGLYPHSET;
[PInvokeData("wingdi.h", MSDNShortId = "b8ac8d3f-b062-491c-966f-02f3d4c11419")]
[VanaraMarshaler(typeof(SafeAnysizeStructMarshaler<GLYPHSET>), nameof(cRanges))]
[StructLayout(LayoutKind.Sequential)]
public struct GLYPHSET
{
/// <summary>The size, in bytes, of this structure.</summary>
public uint cbThis;
/// <summary>
/// <para>Flags describing the maximum size of the glyph indices. This member can be the following value.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>GS_8BIT_INDICES</term>
/// <term>Treat glyph indices as 8-bit wide values. Otherwise, they are 16-bit wide values.</term>
/// </item>
/// </list>
/// </summary>
public GSISize flAccel;
/// <summary>The total number of Unicode code points supported in the font.</summary>
public uint cGlyphsSupported;
/// <summary>The total number of Unicode ranges in <c>ranges</c>.</summary>
public uint cRanges;
/// <summary>Array of Unicode ranges that are supported in the font.</summary>
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)]
public WCRANGE[] ranges;
}
/// <summary>The <c>KERNINGPAIR</c> structure defines a kerning pair.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-kerningpair typedef struct tagKERNINGPAIR { WORD wFirst; WORD
// wSecond; int iKernAmount; } KERNINGPAIR, *LPKERNINGPAIR;
[PInvokeData("wingdi.h", MSDNShortId = "af7bfcf7-467b-4ea9-87c5-3622303b1d8b")]
[StructLayout(LayoutKind.Sequential)]
public struct KERNINGPAIR
{
/// <summary>The character code for the first character in the kerning pair.</summary>
public ushort wFirst;
/// <summary>The character code for the second character in the kerning pair.</summary>
public ushort wSecond;
/// <summary>
/// The amount this pair will be kerned if they appear side by side in the same font and size. This value is typically negative,
/// because pair kerning usually results in two characters being set more tightly than normal. The value is specified in logical
/// units; that is, it depends on the current mapping mode.
/// </summary>
public int iKernAmount;
}
/// <summary>The <c>MAT2</c> structure contains the values for a transformation matrix used by the GetGlyphOutline function.</summary>
/// <remarks>
/// The identity matrix produces a transformation in which the transformed graphical object is identical to the source object. In the
/// identity matrix, the value of <c>eM11</c> is 1, the value of <c>eM12</c> is zero, the value of <c>eM21</c> is zero, and the value
/// of <c>eM22</c> is 1.
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-mat2 typedef struct _MAT2 { FIXED eM11; FIXED eM12; FIXED
// eM21; FIXED eM22; } MAT2, *LPMAT2;
[PInvokeData("wingdi.h", MSDNShortId = "841883d6-bc4d-46ef-abf4-f179771d255b")]
[StructLayout(LayoutKind.Sequential)]
public struct MAT2
{
/// <summary>A fixed-point value for the M11 component of a 3 by 3 transformation matrix.</summary>
public FIXED eM11;
/// <summary>A fixed-point value for the M12 component of a 3 by 3 transformation matrix.</summary>
public FIXED eM12;
/// <summary>A fixed-point value for the M21 component of a 3 by 3 transformation matrix.</summary>
public FIXED eM21;
/// <summary>A fixed-point value for the M22 component of a 3 by 3 transformation matrix.</summary>
public FIXED eM22;
/// <summary>The identity matrix value.</summary>
public static readonly MAT2 IdentityMatrix = new MAT2 { eM11 = new FIXED { fract = 1 }, eM22 = new FIXED { fract = 1 } };
}
/// <summary>The <c>NEWTEXTMETRIC</c> structure contains data that describes a physical font.</summary>
/// <remarks>
/// <para>
/// The last four members of the <c>NEWTEXTMETRIC</c> structure are not included in the TEXTMETRIC structure; in all other respects,
/// the structures are identical.
/// </para>
/// <para>
/// The sizes in the <c>NEWTEXTMETRIC</c> structure are typically specified in logical units; that is, they depend on the current
/// mapping mode of the display context.
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-newtextmetrica typedef struct tagNEWTEXTMETRICA { LONG
// tmHeight; LONG tmAscent; LONG tmDescent; LONG tmInternalLeading; LONG tmExternalLeading; LONG tmAveCharWidth; LONG tmMaxCharWidth;
// LONG tmWeight; LONG tmOverhang; LONG tmDigitizedAspectX; LONG tmDigitizedAspectY; BYTE tmFirstChar; BYTE tmLastChar; BYTE
// tmDefaultChar; BYTE tmBreakChar; BYTE tmItalic; BYTE tmUnderlined; BYTE tmStruckOut; BYTE tmPitchAndFamily; BYTE tmCharSet; DWORD
// ntmFlags; UINT ntmSizeEM; UINT ntmCellHeight; UINT ntmAvgWidth; } NEWTEXTMETRICA, *PNEWTEXTMETRICA, *NPNEWTEXTMETRICA, *LPNEWTEXTMETRICA;
[PInvokeData("wingdi.h", MSDNShortId = "0dd7fee0-0771-4c72-9843-0fee308da5cc")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct NEWTEXTMETRIC
{
/// <summary>The height (ascent + descent) of characters.</summary>
public int tmHeight;
/// <summary>The ascent (units above the base line) of characters.</summary>
public int tmAscent;
/// <summary>The descent (units below the base line) of characters.</summary>
public int tmDescent;
/// <summary>
/// The amount of leading (space) inside the bounds set by the <c>tmHeight</c> member. Accent marks and other diacritical
/// characters may occur in this area. The designer may set this member to zero.
/// </summary>
public int tmInternalLeading;
/// <summary>
/// The amount of extra leading (space) that the application adds between rows. Since this area is outside the font, it contains
/// no marks and is not altered by text output calls in either OPAQUE or TRANSPARENT mode. The designer may set this member to zero.
/// </summary>
public int tmExternalLeading;
/// <summary>
/// The average width of characters in the font (generally defined as the width of the letter x). This value does not include
/// overhang required for bold or italic characters.
/// </summary>
public int tmAveCharWidth;
/// <summary>The width of the widest character in the font.</summary>
public int tmMaxCharWidth;
/// <summary>The weight of the font.</summary>
public int tmWeight;
/// <summary>
/// <para>
/// The extra width per string that may be added to some synthesized fonts. When synthesizing some attributes, such as bold or
/// italic, graphics device interface (GDI) or a device may have to add width to a string on both a per-character and per-string
/// basis. For example, GDI makes a string bold by expanding the spacing of each character and overstriking by an offset value;
/// it italicizes a font by shearing the string. In either case, there is an overhang past the basic string. For bold strings,
/// the overhang is the distance by which the overstrike is offset. For italic strings, the overhang is the amount the top of the
/// font is sheared past the bottom of the font.
/// </para>
/// <para>
/// The <c>tmOverhang</c> member enables the application to determine how much of the character width returned by a
/// GetTextExtentPoint32 function call on a single character is the actual character width and how much is the per-string extra
/// width. The actual width is the extent minus the overhang.
/// </para>
/// </summary>
public int tmOverhang;
/// <summary>The horizontal aspect of the device for which the font was designed.</summary>
public int tmDigitizedAspectX;
/// <summary>
/// The vertical aspect of the device for which the font was designed. The ratio of the <c>tmDigitizedAspectX</c> and
/// <c>tmDigitizedAspectY</c> members is the aspect ratio of the device for which the font was designed.
/// </summary>
public int tmDigitizedAspectY;
/// <summary>The value of the first character defined in the font.</summary>
public char tmFirstChar;
/// <summary>The value of the last character defined in the font.</summary>
public char tmLastChar;
/// <summary>The value of the character to be substituted for characters that are not in the font.</summary>
public char tmDefaultChar;
/// <summary>The value of the character to be used to define word breaks for text justification.</summary>
public char tmBreakChar;
/// <summary>An italic font if it is nonzero.</summary>
public byte tmItalic;
/// <summary>An underlined font if it is nonzero.</summary>
public byte tmUnderlined;
/// <summary>A strikeout font if it is nonzero.</summary>
public byte tmStruckOut;
/// <summary>
/// <para>
/// The pitch and family of the selected font. The low-order bit (bit 0) specifies the pitch of the font. If it is 1, the font is
/// variable pitch (or proportional). If it is 0, the font is fixed pitch (or monospace). Bits 1 and 2 specify the font type. If
/// both bits are 0, the font is a raster font; if bit 1 is 1 and bit 2 is 0, the font is a vector font; if bit 1 is 0 and bit 2
/// is set, or if both bits are 1, the font is some other type. Bit 3 is 1 if the font is a device font; otherwise, it is 0.
/// </para>
/// <para>
/// The four high-order bits designate the font family. The <c>tmPitchAndFamily</c> member can be combined with the hexadecimal
/// value 0xF0 by using the bitwise AND operator and can then be compared with the font family names for an identical match. For
/// more information about the font families, see LOGFONT.
/// </para>
/// </summary>
public byte tmPitchAndFamily;
/// <summary>The character set of the font.</summary>
public byte tmCharSet;
/// <summary>
/// <para>
/// Specifies whether the font is italic, underscored, outlined, bold, and so forth. May be any reasonable combination of the
/// following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Bit</term>
/// <term>Name</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>0</term>
/// <term>NTM_ITALIC</term>
/// <term>italic</term>
/// </item>
/// <item>
/// <term>5</term>
/// <term>NTM_BOLD</term>
/// <term>bold</term>
/// </item>
/// <item>
/// <term>8</term>
/// <term>NTM_REGULAR</term>
/// <term>regular</term>
/// </item>
/// <item>
/// <term>16</term>
/// <term>NTM_NONNEGATIVE_AC</term>
/// <term>no glyph in a font at any size has a negative A or C space.</term>
/// </item>
/// <item>
/// <term>17</term>
/// <term>NTM_PS_OPENTYPE</term>
/// <term>PostScript OpenType font</term>
/// </item>
/// <item>
/// <term>18</term>
/// <term>NTM_TT_OPENTYPE</term>
/// <term>TrueType OpenType font</term>
/// </item>
/// <item>
/// <term>19</term>
/// <term>NTM_MULTIPLEMASTER</term>
/// <term>multiple master font</term>
/// </item>
/// <item>
/// <term>20</term>
/// <term>NTM_TYPE1</term>
/// <term>Type 1 font</term>
/// </item>
/// <item>
/// <term>21</term>
/// <term>NTM_DSIG</term>
/// <term>font with a digital signature. This allows traceability and ensures that the font has been tested and is not corrupted</term>
/// </item>
/// </list>
/// </summary>
public uint ntmFlags;
/// <summary>
/// The size of the em square for the font. This value is in notional units (that is, the units for which the font was designed).
/// </summary>
public uint ntmSizeEM;
/// <summary>
/// The height, in notional units, of the font. This value should be compared with the value of the <c>ntmSizeEM</c> member.
/// </summary>
public uint ntmCellHeight;
/// <summary>
/// The average width of characters in the font, in notional units. This value should be compared with the value of the
/// <c>ntmSizeEM</c> member.
/// </summary>
public uint ntmAvgWidth;
}
/// <summary>The <c>NEWTEXTMETRICEX</c> structure contains information about a physical font.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-newtextmetricexa typedef struct tagNEWTEXTMETRICEXA {
// NEWTEXTMETRICA ntmTm; FONTSIGNATURE ntmFontSig; } NEWTEXTMETRICEXA;
[PInvokeData("wingdi.h", MSDNShortId = "b85ff705-2dd4-4877-9905-d4c2a0894e24")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct NEWTEXTMETRICEX
{
/// <summary>A NEWTEXTMETRIC structure.</summary>
public NEWTEXTMETRIC ntmTm;
/// <summary>A FONTSIGNATURE structure indicating the coverage of the font.</summary>
public FONTSIGNATURE ntmFontSig;
}
/// <summary>The <c>OUTLINETEXTMETRIC</c> structure contains metrics describing a TrueType font.</summary>
/// <remarks>
/// <para>
/// The sizes returned in <c>OUTLINETEXTMETRIC</c> are specified in logical units; that is, they depend on the current mapping mode
/// of the specified display context.
/// </para>
/// <para>
/// Note, <c>OUTLINETEXTMETRIC</c> is defined using the current pack setting. To avoid problems, make sure that the application is
/// built using the platform default packing. For example, 32-bit Windows uses a default of 8-byte packing. For more information, see
/// the MSDN topic "C-Compiler Packing Issues".
/// </para>
/// </remarks>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-outlinetextmetrica typedef struct _OUTLINETEXTMETRICA { UINT
// otmSize; TEXTMETRICA otmTextMetrics; BYTE otmFiller; PANOSE otmPanoseNumber; UINT otmfsSelection; UINT otmfsType; int
// otmsCharSlopeRise; int otmsCharSlopeRun; int otmItalicAngle; UINT otmEMSquare; int otmAscent; int otmDescent; UINT otmLineGap;
// UINT otmsCapEmHeight; UINT otmsXHeight; RECT otmrcFontBox; int otmMacAscent; int otmMacDescent; UINT otmMacLineGap; UINT
// otmusMinimumPPEM; POINT otmptSubscriptSize; POINT otmptSubscriptOffset; POINT otmptSuperscriptSize; POINT otmptSuperscriptOffset;
// UINT otmsStrikeoutSize; int otmsStrikeoutPosition; int otmsUnderscoreSize; int otmsUnderscorePosition; PSTR otmpFamilyName; PSTR
// otmpFaceName; PSTR otmpStyleName; PSTR otmpFullName; } OUTLINETEXTMETRICA, *POUTLINETEXTMETRICA, *NPOUTLINETEXTMETRICA, *LPOUTLINETEXTMETRICA;
[PInvokeData("wingdi.h", MSDNShortId = "79d77df0-193a-49a8-b93d-4ef5807c3c9b")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct OUTLINETEXTMETRIC
{
/// <summary>The size, in bytes, of the <c>OUTLINETEXTMETRIC</c> structure.</summary>
public uint otmSize;
/// <summary>A TEXTMETRIC structure containing further information about the font.</summary>
public TEXTMETRIC otmTextMetrics;
/// <summary>A value that causes the structure to be byte-aligned.</summary>
public byte otmFiller;
/// <summary>The PANOSE number for this font.</summary>
public PANOSE otmPanoseNumber;
/// <summary>
/// <para>The nature of the font pattern. This member can be a combination of the following bits.</para>
/// <list type="table">
/// <listheader>
/// <term>Bit</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>0</term>
/// <term>Italic</term>
/// </item>
/// <item>
/// <term>1</term>
/// <term>Underscore</term>
/// </item>
/// <item>
/// <term>2</term>
/// <term>Negative</term>
/// </item>
/// <item>
/// <term>3</term>
/// <term>Outline</term>
/// </item>
/// <item>
/// <term>4</term>
/// <term>Strikeout</term>
/// </item>
/// <item>
/// <term>5</term>
/// <term>Bold</term>
/// </item>
/// </list>
/// </summary>
public uint otmfsSelection;
/// <summary>
/// Indicates whether the font is licensed. Licensed fonts must not be modified or exchanged. If bit 1 is set, the font may not
/// be embedded in a document. If bit 1 is clear, the font can be embedded. If bit 2 is set, the embedding is read-only.
/// </summary>
public uint otmfsType;
/// <summary>
/// The slope of the cursor. This value is 1 if the slope is vertical. Applications can use this value and the value of the
/// <c>otmsCharSlopeRun</c> member to create an italic cursor that has the same slope as the main italic angle (specified by the
/// <c>otmItalicAngle</c> member).
/// </summary>
public int otmsCharSlopeRise;
/// <summary>
/// The slope of the cursor. This value is zero if the slope is vertical. Applications can use this value and the value of the
/// <c>otmsCharSlopeRise</c> member to create an italic cursor that has the same slope as the main italic angle (specified by the
/// <c>otmItalicAngle</c> member).
/// </summary>
public int otmsCharSlopeRun;
/// <summary>
/// The main italic angle of the font, in tenths of a degree counterclockwise from vertical. Regular (roman) fonts have a value
/// of zero. Italic fonts typically have a negative italic angle (that is, they lean to the right).
/// </summary>
public int otmItalicAngle;
/// <summary>
/// The number of logical units defining the x- or y-dimension of the em square for this font. (The number of units in the x- and
/// y-directions are always the same for an em square.)
/// </summary>
public uint otmEMSquare;
/// <summary>
/// The maximum distance characters in this font extend above the base line. This is the typographic ascent for the font.
/// </summary>
public int otmAscent;
/// <summary>
/// The maximum distance characters in this font extend below the base line. This is the typographic descent for the font.
/// </summary>
public int otmDescent;
/// <summary>The typographic line spacing.</summary>
public uint otmLineGap;
/// <summary>Not supported.</summary>
public uint otmsCapEmHeight;
/// <summary>Not supported.</summary>
public uint otmsXHeight;
/// <summary>The bounding box for the font.</summary>
public RECT otmrcFontBox;
/// <summary>The maximum distance characters in this font extend above the base line for the Macintosh computer.</summary>
public int otmMacAscent;
/// <summary>The maximum distance characters in this font extend below the base line for the Macintosh computer.</summary>
public int otmMacDescent;
/// <summary>The line-spacing information for the Macintosh computer.</summary>
public uint otmMacLineGap;
/// <summary>The smallest recommended size for this font, in pixels per em-square.</summary>
public uint otmusMinimumPPEM;
/// <summary>The recommended horizontal and vertical size for subscripts in this font.</summary>
public POINT otmptSubscriptSize;
/// <summary>
/// The recommended horizontal and vertical offset for subscripts in this font. The subscript offset is measured from the
/// character origin to the origin of the subscript character.
/// </summary>
public POINT otmptSubscriptOffset;
/// <summary>The recommended horizontal and vertical size for superscripts in this font.</summary>
public POINT otmptSuperscriptSize;
/// <summary>
/// The recommended horizontal and vertical offset for superscripts in this font. The superscript offset is measured from the
/// character base line to the base line of the superscript character.
/// </summary>
public POINT otmptSuperscriptOffset;
/// <summary>The width of the strikeout stroke for this font. Typically, this is the width of the em dash for the font.</summary>
public uint otmsStrikeoutSize;
/// <summary>
/// The position of the strikeout stroke relative to the base line for this font. Positive values are above the base line and
/// negative values are below.
/// </summary>
public int otmsStrikeoutPosition;
/// <summary>The thickness of the underscore character for this font.</summary>
public int otmsUnderscoreSize;
/// <summary>The position of the underscore character for this font.</summary>
public int otmsUnderscorePosition;
/// <summary>The offset from the beginning of the structure to a string specifying the family name for the font.</summary>
public IntPtr otmpFamilyName;
/// <summary>
/// The offset from the beginning of the structure to a string specifying the typeface name for the font. (This typeface name
/// corresponds to the name specified in the LOGFONT structure.)
/// </summary>
public IntPtr otmpFaceName;
/// <summary>The offset from the beginning of the structure to a string specifying the style name for the font.</summary>
public IntPtr otmpStyleName;
/// <summary>
/// The offset from the beginning of the structure to a string specifying the full name for the font. This name is unique for the
/// font and often contains a version number or other identifying information.
/// </summary>
public IntPtr otmpFullName;
}
/// <summary>
/// The <c>PANOSE</c> structure describes the PANOSE font-classification values for a TrueType font. These characteristics are then
/// used to associate the font with other fonts of similar appearance but different names.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-panose typedef struct tagPANOSE { BYTE bFamilyType; BYTE
// bSerifStyle; BYTE bWeight; BYTE bProportion; BYTE bContrast; BYTE bStrokeVariation; BYTE bArmStyle; BYTE bLetterform; BYTE
// bMidline; BYTE bXHeight; } PANOSE, *LPPANOSE;
[PInvokeData("wingdi.h", MSDNShortId = "18aa4a36-8e47-4e35-973f-376d412ed923")]
[StructLayout(LayoutKind.Sequential)]
public struct PANOSE
{
/// <summary>
/// <para>For Latin fonts, one of one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_FAMILY_TEXT_DISPLAY</term>
/// <term>Text and display</term>
/// </item>
/// <item>
/// <term>PAN_FAMILY_SCRIPT</term>
/// <term>Script</term>
/// </item>
/// <item>
/// <term>PAN_FAMILY_DECORATIVE</term>
/// <term>Decorative</term>
/// </item>
/// <item>
/// <term>PAN_FAMILY_PICTORIAL</term>
/// <term>Pictorial</term>
/// </item>
/// </list>
/// </summary>
public PAN_FAMILY bFamilyType;
/// <summary>
/// <para>The serif style. For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_COVE</term>
/// <term>Cove</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_OBTUSE_COVE</term>
/// <term>Obtuse cove</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_SQUARE_COVE</term>
/// <term>Square cove</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_OBTUSE_SQUARE_COVE</term>
/// <term>Obtuse square cove</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_SQUARE</term>
/// <term>Square</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_THIN</term>
/// <term>Thin</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_BONE</term>
/// <term>Bone</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_EXAGGERATED</term>
/// <term>Exaggerated</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_TRIANGLE</term>
/// <term>Triangle</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_NORMAL_SANS</term>
/// <term>Normal sans serif</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_OBTUSE_SANS</term>
/// <term>Obtuse sans serif</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_PERP_SANS</term>
/// <term>Perp sans serif</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_FLARED</term>
/// <term>Flared</term>
/// </item>
/// <item>
/// <term>PAN_SERIF_ROUNDED</term>
/// <term>Rounded</term>
/// </item>
/// </list>
/// </summary>
public PAN_SERIF bSerifStyle;
/// <summary>
/// <para>For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_VERY_LIGHT</term>
/// <term>Very light</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_LIGHT</term>
/// <term>Light</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_THIN</term>
/// <term>Thin</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_BOOK</term>
/// <term>Book</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_MEDIUM</term>
/// <term>Medium</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_DEMI</term>
/// <term>Demibold</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_BOLD</term>
/// <term>Bold</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_HEAVY</term>
/// <term>Heavy</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_BLACK</term>
/// <term>Black</term>
/// </item>
/// <item>
/// <term>PAN_WEIGHT_NORD</term>
/// <term>Nord</term>
/// </item>
/// </list>
/// </summary>
public PAN_WEIGHT bWeight;
/// <summary>
/// <para>For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_PROP_OLD_STYLE</term>
/// <term>Old style</term>
/// </item>
/// <item>
/// <term>PAN_PROP_MODERN</term>
/// <term>Modern</term>
/// </item>
/// <item>
/// <term>PAN_PROP_EVEN_WIDTH</term>
/// <term>Even width</term>
/// </item>
/// <item>
/// <term>PAN_PROP_EXPANDED</term>
/// <term>Expanded</term>
/// </item>
/// <item>
/// <term>PAN_PROP_CONDENSED</term>
/// <term>Condensed</term>
/// </item>
/// <item>
/// <term>PAN_PROP_VERY_EXPANDED</term>
/// <term>Very expanded</term>
/// </item>
/// <item>
/// <term>PAN_PROP_VERY_CONDENSED</term>
/// <term>Very condensed</term>
/// </item>
/// <item>
/// <term>PAN_PROP_MONOSPACED</term>
/// <term>Monospaced</term>
/// </item>
/// </list>
/// </summary>
public PAN_PROP bProportion;
/// <summary>
/// <para>For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_CONTRAST_NONE</term>
/// <term>None</term>
/// </item>
/// <item>
/// <term>PAN_CONTRAST_VERY_LOW</term>
/// <term>Very low</term>
/// </item>
/// <item>
/// <term>PAN_CONTRAST_LOW</term>
/// <term>Low</term>
/// </item>
/// <item>
/// <term>PAN_CONTRAST_MEDIUM_LOW</term>
/// <term>Medium low</term>
/// </item>
/// <item>
/// <term>PAN_CONTRAST_MEDIUM</term>
/// <term>Medium</term>
/// </item>
/// <item>
/// <term>PAN_CONTRAST_MEDIUM_HIGH</term>
/// <term>Medium high</term>
/// </item>
/// <item>
/// <term>PAN_CONTRAST_HIGH</term>
/// <term>High</term>
/// </item>
/// <item>
/// <term>PAN_CONTRAST_VERY_HIGH</term>
/// <term>Very high</term>
/// </item>
/// </list>
/// </summary>
public PAN_CONTRAST bContrast;
/// <summary>
/// <para>For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_STROKE_GRADUAL_DIAG</term>
/// <term>Gradual/diagonal</term>
/// </item>
/// <item>
/// <term>PAN_STROKE_GRADUAL_TRAN</term>
/// <term>Gradual/transitional</term>
/// </item>
/// <item>
/// <term>PAN_STROKE_GRADUAL_VERT</term>
/// <term>Gradual/vertical</term>
/// </item>
/// <item>
/// <term>PAN_STROKE_GRADUAL_HORZ</term>
/// <term>Gradual/horizontal</term>
/// </item>
/// <item>
/// <term>PAN_STROKE_RAPID_VERT</term>
/// <term>Rapid/vertical</term>
/// </item>
/// <item>
/// <term>PAN_STROKE_RAPID_HORZ</term>
/// <term>Rapid/horizontal</term>
/// </item>
/// <item>
/// <term>PAN_STROKE_INSTANT_VERT</term>
/// <term>Instant/vertical</term>
/// </item>
/// </list>
/// </summary>
public PAN_STROKE bStrokeVariation;
/// <summary>
/// <para>For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_STRAIGHT_ARMS_HORZ</term>
/// <term>Straight arms/horizontal</term>
/// </item>
/// <item>
/// <term>PAN_STRAIGHT_ARMS_WEDGE</term>
/// <term>Straight arms/wedge</term>
/// </item>
/// <item>
/// <term>PAN_STRAIGHT_ARMS_VERT</term>
/// <term>Straight arms/vertical</term>
/// </item>
/// <item>
/// <term>PAN_STRAIGHT_ARMS_SINGLE_SERIF</term>
/// <term>Straight arms/single-serif</term>
/// </item>
/// <item>
/// <term>PAN_STRAIGHT_ARMS_DOUBLE_SERIF</term>
/// <term>Straight arms/double-serif</term>
/// </item>
/// <item>
/// <term>PAN_BENT_ARMS_HORZ</term>
/// <term>Nonstraight arms/horizontal</term>
/// </item>
/// <item>
/// <term>PAN_BENT_ARMS_WEDGE</term>
/// <term>Nonstraight arms/wedge</term>
/// </item>
/// <item>
/// <term>PAN_BENT_ARMS_VERT</term>
/// <term>Nonstraight arms/vertical</term>
/// </item>
/// <item>
/// <term>PAN_BENT_ARMS_SINGLE_SERIF</term>
/// <term>Nonstraight arms/single-serif</term>
/// </item>
/// <item>
/// <term>PAN_BENT_ARMS_DOUBLE_SERIF</term>
/// <term>Nonstraight arms/double-serif</term>
/// </item>
/// </list>
/// </summary>
public PAN_ARMS bArmStyle;
/// <summary>
/// <para>For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_LETT_NORMAL_CONTACT</term>
/// <term>Normal/contact</term>
/// </item>
/// <item>
/// <term>PAN_LETT_NORMAL_WEIGHTED</term>
/// <term>Normal/weighted</term>
/// </item>
/// <item>
/// <term>PAN_LETT_NORMAL_BOXED</term>
/// <term>Normal/boxed</term>
/// </item>
/// <item>
/// <term>PAN_LETT_NORMAL_FLATTENED</term>
/// <term>Normal/flattened</term>
/// </item>
/// <item>
/// <term>PAN_LETT_NORMAL_ROUNDED</term>
/// <term>Normal/rounded</term>
/// </item>
/// <item>
/// <term>PAN_LETT_NORMAL_OFF_CENTER</term>
/// <term>Normal/off center</term>
/// </item>
/// <item>
/// <term>PAN_LETT_NORMAL_SQUARE</term>
/// <term>Normal/square</term>
/// </item>
/// <item>
/// <term>PAN_LETT_OBLIQUE_CONTACT</term>
/// <term>Oblique/contact</term>
/// </item>
/// <item>
/// <term>PAN_LETT_OBLIQUE_WEIGHTED</term>
/// <term>Oblique/weighted</term>
/// </item>
/// <item>
/// <term>PAN_LETT_OBLIQUE_BOXED</term>
/// <term>Oblique/boxed</term>
/// </item>
/// <item>
/// <term>PAN_LETT_OBLIQUE_FLATTENED</term>
/// <term>Oblique/flattened</term>
/// </item>
/// <item>
/// <term>PAN_LETT_OBLIQUE_ROUNDED</term>
/// <term>Oblique/rounded</term>
/// </item>
/// <item>
/// <term>PAN_LETT_OBLIQUE_OFF_CENTER</term>
/// <term>Oblique/off center</term>
/// </item>
/// <item>
/// <term>PAN_LETT_OBLIQUE_SQUARE</term>
/// <term>Oblique/square</term>
/// </item>
/// </list>
/// </summary>
public PAN_LETT bLetterform;
/// <summary>
/// <para>For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_STANDARD_TRIMMED</term>
/// <term>Standard/trimmed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_STANDARD_POINTED</term>
/// <term>Standard/pointed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_STANDARD_SERIFED</term>
/// <term>Standard/serifed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_HIGH_TRIMMED</term>
/// <term>High/trimmed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_HIGH_POINTED</term>
/// <term>High/pointed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_HIGH_SERIFED</term>
/// <term>High/serifed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_CONSTANT_TRIMMED</term>
/// <term>Constant/trimmed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_CONSTANT_POINTED</term>
/// <term>Constant/pointed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_CONSTANT_SERIFED</term>
/// <term>Constant/serifed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_LOW_TRIMMED</term>
/// <term>Low/trimmed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_LOW_POINTED</term>
/// <term>Low/pointed</term>
/// </item>
/// <item>
/// <term>PAN_MIDLINE_LOW_SERIFED</term>
/// <term>Low/serifed</term>
/// </item>
/// </list>
/// </summary>
public PAN_MIDLINE bMidline;
/// <summary>
/// <para>For Latin fonts, one of the following values.</para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>PAN_ANY</term>
/// <term>Any</term>
/// </item>
/// <item>
/// <term>PAN_NO_FIT</term>
/// <term>No fit</term>
/// </item>
/// <item>
/// <term>PAN_XHEIGHT_CONSTANT_SMALL</term>
/// <term>Constant/small</term>
/// </item>
/// <item>
/// <term>PAN_XHEIGHT_CONSTANT_STD</term>
/// <term>Constant/standard</term>
/// </item>
/// <item>
/// <term>PAN_XHEIGHT_CONSTANT_LARGE</term>
/// <term>Constant/large</term>
/// </item>
/// <item>
/// <term>PAN_XHEIGHT_DUCKING_SMALL</term>
/// <term>Ducking/small</term>
/// </item>
/// <item>
/// <term>PAN_XHEIGHT_DUCKING_STD</term>
/// <term>Ducking/standard</term>
/// </item>
/// <item>
/// <term>PAN_XHEIGHT_DUCKING_LARGE</term>
/// <term>Ducking/large</term>
/// </item>
/// </list>
/// </summary>
public PAN_XHEIGHT bXHeight;
}
/// <summary>The <c>POLYTEXT</c> structure describes how the PolyTextOut function should draw a string of text.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-polytextw typedef struct tagPOLYTEXTW { int x; int y; UINT n;
// LPCWSTR lpstr; UINT uiFlags; RECT rcl; int *pdx; } POLYTEXTW, *PPOLYTEXTW, *NPPOLYTEXTW, *LPPOLYTEXTW;
[PInvokeData("wingdi.h", MSDNShortId = "6f03e2ff-c15f-498c-8c3d-33106222279e")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct POLYTEXT
{
/// <summary>
/// The horizontal reference point for the string. The string is aligned to this point using the current text-alignment mode.
/// </summary>
public int x;
/// <summary>
/// The vertical reference point for the string. The string is aligned to this point using the current text-alignment mode.
/// </summary>
public int y;
/// <summary>The length of the string pointed to by <c>lpstr</c>.</summary>
public uint n;
/// <summary>
/// Pointer to a string of text to be drawn by the PolyTextOut function. This string need not be null-terminated, since <c>n</c>
/// specifies the length of the string.
/// </summary>
[MarshalAs(UnmanagedType.LPTStr)] public string lpstr;
/// <summary>
/// <para>
/// Specifies whether the string is to be opaque or clipped and whether the string is accompanied by an array of character-width
/// values. This member can be one or more of the following values.
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Value</term>
/// <term>Meaning</term>
/// </listheader>
/// <item>
/// <term>ETO_OPAQUE</term>
/// <term>The rectangle for each string is to be opaqued with the current background color.</term>
/// </item>
/// <item>
/// <term>ETO_CLIPPED</term>
/// <term>Each string is to be clipped to its specified rectangle.</term>
/// </item>
/// </list>
/// </summary>
public ETO uiFlags;
/// <summary>
/// A rectangle structure that contains the dimensions of the opaquing or clipping rectangle. This member is ignored if neither
/// of the ETO_OPAQUE nor the ETO_CLIPPED value is specified for the <c>uiFlags</c> member.
/// </summary>
public RECT rcl;
/// <summary>Pointer to an array containing the width value for each character in the string.</summary>
public IntPtr pdx;
}
/// <summary>
/// The <c>RASTERIZER_STATUS</c> structure contains information about whether TrueType is installed. This structure is filled when an
/// application calls the GetRasterizerCaps function.
/// </summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-rasterizer_status typedef struct _RASTERIZER_STATUS { short
// nSize; short wFlags; short nLanguageID; } RASTERIZER_STATUS, *LPRASTERIZER_STATUS;
[PInvokeData("wingdi.h", MSDNShortId = "40bb4b59-90a4-4780-ae5f-fef8a6fa62cb")]
[StructLayout(LayoutKind.Sequential)]
public struct RASTERIZER_STATUS
{
/// <summary>The size, in bytes, of the <c>RASTERIZER_STATUS</c> structure.</summary>
public short nSize;
/// <summary>
/// Specifies whether at least one TrueType font is installed and whether TrueType is enabled. This value is TT_AVAILABLE,
/// TT_ENABLED, or both if TrueType is on the system.
/// </summary>
public TT wFlags;
/// <summary>The language in the system's Setup.inf file.</summary>
public short nLanguageID;
}
/// <summary>The <c>WCRANGE</c> structure specifies a range of Unicode characters.</summary>
// https://docs.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-wcrange typedef struct tagWCRANGE { WCHAR wcLow; USHORT
// cGlyphs; } WCRANGE, *PWCRANGE, *LPWCRANGE;
[PInvokeData("wingdi.h", MSDNShortId = "20959057-6062-4c1e-a23d-535584ba6ea3")]
[StructLayout(LayoutKind.Sequential)]
public struct WCRANGE
{
/// <summary>Low Unicode code point in the range of supported Unicode code points.</summary>
public ushort wcLow;
/// <summary>Number of supported Unicode code points in this range.</summary>
public ushort cGlyphs;
}
}
}
Reference in New Issue View Git Blame Copy Permalink