mirror of https://github.com/dahall/Vanara.git
1878 lines
88 KiB
C#
1878 lines
88 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Vanara.PInvoke
|
|
{
|
|
public static partial class User32_Gdi
|
|
{
|
|
/// <summary>
|
|
/// The <c>DrawStateProc</c> function is an application-defined callback function that renders a complex image for the DrawState
|
|
/// function. The <c>DRAWSTATEPROC</c> type defines a pointer to this callback function. <c>DrawStateProc</c> is a placeholder for
|
|
/// the application-defined function name.
|
|
/// </summary>
|
|
/// <param name="hdc">
|
|
/// A handle to the device context to draw in. The device context is a memory device context with a bitmap selected, the dimensions
|
|
/// of which are at least as great as those specified by the <c>cx</c> and <c>cy</c> parameters.
|
|
/// </param>
|
|
/// <param name="lData">Specifies information about the image, which the application passed to DrawState.</param>
|
|
/// <param name="wData">Specifies information about the image, which the application passed to DrawState.</param>
|
|
/// <param name="cx">The image width, in device units, as specified by the call to DrawState.</param>
|
|
/// <param name="cy">The image height, in device units, as specified by the call to DrawState.</param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is <c>TRUE</c>.</para>
|
|
/// <para>If the function fails, the return value is <c>FALSE</c>.</para>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nc-winuser-drawstateproc DRAWSTATEPROC Drawstateproc; BOOL
|
|
// Drawstateproc( HDC hdc, LPARAM lData, WPARAM wData, int cx, int cy ) {...}
|
|
[PInvokeData("winuser.h", MSDNShortId = "a95a4020-e433-4b2c-96e7-f272e28e5a43")]
|
|
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public delegate bool DrawStateProc(HDC hdc, IntPtr lData, IntPtr wData, int cx, int cy);
|
|
|
|
/// <summary>
|
|
/// The <c>OutputProc</c> function is an application-defined callback function used with the GrayString function. It is used to draw
|
|
/// a string. The <c>GRAYSTRINGPROC</c> type defines a pointer to this callback function. <c>OutputProc</c> is a placeholder for the
|
|
/// application-defined or library-defined function name.
|
|
/// </summary>
|
|
/// <param name="hdc">
|
|
/// A handle to a device context with a bitmap of at least the width and height specified by the nWidth and nHeight parameters passed
|
|
/// to GrayString.
|
|
/// </param>
|
|
/// <param name="lpData">A pointer to the string to be drawn.</param>
|
|
/// <param name="cchData">The length, in characters, of the string.</param>
|
|
/// <returns>
|
|
/// <para>If it succeeds, the callback function should return <c>TRUE</c>.</para>
|
|
/// <para>If the function fails, the return value is <c>FALSE</c>.</para>
|
|
/// </returns>
|
|
/// <remarks>The callback function must draw an image relative to the coordinates (0,0).</remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nc-winuser-graystringproc GRAYSTRINGPROC Graystringproc; BOOL
|
|
// Graystringproc( HDC Arg1, LPARAM Arg2, int Arg3 ) {...}
|
|
[PInvokeData("winuser.h", MSDNShortId = "4d9145d2-5be4-4da3-9d03-01ebd74e0d06")]
|
|
[UnmanagedFunctionPointer(CallingConvention.Winapi, CharSet = CharSet.Auto)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public delegate bool OutputProc(HDC hdc, string lpData, int cchData);
|
|
|
|
/// <summary>Flags used by the <see cref="DrawEdge"/> method.</summary>
|
|
[PInvokeData("WinUser.h")]
|
|
[Flags]
|
|
public enum BorderFlags : uint
|
|
{
|
|
/// <summary>Left side of border rectangle.</summary>
|
|
BF_LEFT = 0x0001,
|
|
|
|
/// <summary>Top of border rectangle.</summary>
|
|
BF_TOP = 0x0002,
|
|
|
|
/// <summary>Right side of border rectangle.</summary>
|
|
BF_RIGHT = 0x0004,
|
|
|
|
/// <summary>Bottom of border rectangle.</summary>
|
|
BF_BOTTOM = 0x0008,
|
|
|
|
/// <summary>Top and left side of border rectangle.</summary>
|
|
BF_TOPLEFT = BF_TOP | BF_LEFT,
|
|
|
|
/// <summary>Top and right side of border rectangle.</summary>
|
|
BF_TOPRIGHT = BF_TOP | BF_RIGHT,
|
|
|
|
/// <summary>Bottom and left side of border rectangle.</summary>
|
|
BF_BOTTOMLEFT = BF_BOTTOM | BF_LEFT,
|
|
|
|
/// <summary>Bottom and right side of border rectangle.</summary>
|
|
BF_BOTTOMRIGHT = BF_BOTTOM | BF_RIGHT,
|
|
|
|
/// <summary>Entire border rectangle.</summary>
|
|
BF_RECT = BF_LEFT | BF_TOP | BF_RIGHT | BF_BOTTOM,
|
|
|
|
/// <summary>Diagonal border.</summary>
|
|
BF_DIAGONAL = 0x0010,
|
|
|
|
/// <summary>Diagonal border. The end point is the top-right corner of the rectangle; the origin is lower-left corner.</summary>
|
|
BF_DIAGONAL_ENDTOPRIGHT = BF_DIAGONAL | BF_TOP | BF_RIGHT,
|
|
|
|
/// <summary>Diagonal border. The end point is the top-left corner of the rectangle; the origin is lower-right corner.</summary>
|
|
BF_DIAGONAL_ENDTOPLEFT = BF_DIAGONAL | BF_TOP | BF_LEFT,
|
|
|
|
/// <summary>Diagonal border. The end point is the lower-left corner of the rectangle; the origin is top-right corner.</summary>
|
|
BF_DIAGONAL_ENDBOTTOMLEFT = BF_DIAGONAL | BF_BOTTOM | BF_LEFT,
|
|
|
|
/// <summary>Diagonal border. The end point is the lower-right corner of the rectangle; the origin is top-left corner.</summary>
|
|
BF_DIAGONAL_ENDBOTTOMRIGHT = BF_DIAGONAL | BF_BOTTOM | BF_RIGHT,
|
|
|
|
/// <summary>Interior of rectangle to be filled.</summary>
|
|
BF_MIDDLE = 0x0800,
|
|
|
|
/// <summary>Soft buttons instead of tiles.</summary>
|
|
BF_SOFT = 0x1000,
|
|
|
|
/// <summary>
|
|
/// The rectangle pointed to by the pDestRect parameter is shrunk to exclude the edges that were drawn; otherwise the rectangle
|
|
/// does not change.
|
|
/// </summary>
|
|
BF_ADJUST = 0x2000,
|
|
|
|
/// <summary>Flat border.</summary>
|
|
BF_FLAT = 0x4000,
|
|
|
|
/// <summary>One-dimensional border.</summary>
|
|
BF_MONO = 0x8000,
|
|
}
|
|
|
|
/// <summary>Styles used by the <see cref="DrawEdge"/> method.</summary>
|
|
[PInvokeData("WinUser.h")]
|
|
[Flags]
|
|
public enum BorderStyles3D : uint
|
|
{
|
|
/// <summary>Raised outer edge</summary>
|
|
BDR_RAISEDOUTER = 0x0001,
|
|
|
|
/// <summary>Sunken outer edge</summary>
|
|
BDR_SUNKENOUTER = 0x0002,
|
|
|
|
/// <summary>Raised inner edge</summary>
|
|
BDR_RAISEDINNER = 0x0004,
|
|
|
|
/// <summary>Sunken inner edge</summary>
|
|
BDR_SUNKENINNER = 0x0008,
|
|
|
|
/// <summary>Combination of BDR_RAISEDOUTER and BDR_SUNKENINNER</summary>
|
|
BDR_OUTER = BDR_RAISEDOUTER | BDR_SUNKENOUTER,
|
|
|
|
/// <summary>Combination of BDR_RAISEDINNER and BDR_SUNKENINNER</summary>
|
|
BDR_INNER = BDR_RAISEDINNER | BDR_SUNKENINNER,
|
|
|
|
/// <summary>Combination of BDR_RAISEDOUTER and BDR_RAISEDINNER</summary>
|
|
BDR_RAISED = BDR_RAISEDOUTER | BDR_RAISEDINNER,
|
|
|
|
/// <summary>Combination of BDR_SUNKENOUTER and BDR_SUNKENINNER</summary>
|
|
BDR_SUNKEN = BDR_SUNKENOUTER | BDR_SUNKENINNER,
|
|
|
|
/// <summary>Combination of BDR_RAISEDOUTER and BDR_RAISEDINNER</summary>
|
|
EDGE_RAISED = BDR_RAISEDOUTER | BDR_RAISEDINNER,
|
|
|
|
/// <summary>Combination of BDR_SUNKENOUTER and BDR_SUNKENINNER</summary>
|
|
EDGE_SUNKEN = BDR_SUNKENOUTER | BDR_SUNKENINNER,
|
|
|
|
/// <summary>Combination of BDR_SUNKENOUTER and BDR_RAISEDINNER</summary>
|
|
EDGE_ETCHED = BDR_SUNKENOUTER | BDR_RAISEDINNER,
|
|
|
|
/// <summary>Combination of BDR_RAISEDOUTER and BDR_SUNKENINNER</summary>
|
|
EDGE_BUMP = BDR_RAISEDOUTER | BDR_SUNKENINNER,
|
|
}
|
|
|
|
/// <summary>Flags used by <see cref="DrawCaption"/>.</summary>
|
|
[PInvokeData("winuser.h", MSDNShortId = "9348e29f-ce56-4664-8862-f5810c797622")]
|
|
[Flags]
|
|
public enum DrawCaptionFlags
|
|
{
|
|
/// <summary>The function uses the colors that denote an active caption.</summary>
|
|
DC_ACTIVE = 0x0001,
|
|
|
|
/// <summary>The function draws a small caption, using the current small caption font.</summary>
|
|
DC_SMALLCAP = 0x0002,
|
|
|
|
/// <summary>The function draws the icon when drawing the caption text.</summary>
|
|
DC_ICON = 0x0004,
|
|
|
|
/// <summary>The function draws the caption text when drawing the caption.</summary>
|
|
DC_TEXT = 0x0008,
|
|
|
|
/// <summary>The function draws the caption as a button.</summary>
|
|
DC_INBUTTON = 0x0010,
|
|
|
|
/// <summary>
|
|
/// When this flag is set, the function uses COLOR_GRADIENTACTIVECAPTION (if the DC_ACTIVE flag was set) or
|
|
/// COLOR_GRADIENTINACTIVECAPTION for the title-bar color.
|
|
/// <para>If this flag is not set, the function uses COLOR_ACTIVECAPTION or COLOR_INACTIVECAPTION for both colors.</para>
|
|
/// </summary>
|
|
DC_GRADIENT = 0x0020,
|
|
|
|
/// <summary>If set, the function draws the buttons in the caption bar (to minimize, restore, or close an application).</summary>
|
|
DC_BUTTONS = 0x1000,
|
|
}
|
|
|
|
/// <summary>Flags used by <see cref="DrawState"/>.</summary>
|
|
[PInvokeData("winuser.h", MSDNShortId = "b92150be-8264-4ea8-a2ea-d70b7fba6361")]
|
|
[Flags]
|
|
public enum DrawStateFlags
|
|
{
|
|
/// <summary>
|
|
/// The image is application defined. To render the image, DrawState calls the callback function specified by the lpOutputFunc parameter.
|
|
/// </summary>
|
|
DST_COMPLEX = 0x0000,
|
|
|
|
/// <summary>
|
|
/// The image is text. The lData parameter is a pointer to the string, and the wData parameter specifies the length. If wData is
|
|
/// zero, the string must be null-terminated.
|
|
/// </summary>
|
|
DST_TEXT = 0x0001,
|
|
|
|
/// <summary>The image is text that may contain an accelerator mnemonic. DrawState interprets the ampersand (&) prefix character
|
|
/// as a directive to underscore the character that follows. The lData parameter is a pointer to the string, and the wData
|
|
/// parameter specifies the length. If wData is zero, the string must be null-terminated.</summary>
|
|
DST_PREFIXTEXT = 0x0002,
|
|
|
|
/// <summary>The image is an icon. The lData parameter is the icon handle.</summary>
|
|
DST_ICON = 0x0003,
|
|
|
|
/// <summary>
|
|
/// The image is a bitmap. The lData parameter is the bitmap handle. Note that the bitmap cannot already be selected into an
|
|
/// existing device context.
|
|
/// </summary>
|
|
DST_BITMAP = 0x0004,
|
|
|
|
/// <summary>Draws the image without any modification.</summary>
|
|
DSS_NORMAL = 0x0000,
|
|
|
|
/// <summary>Dithers the image.</summary>
|
|
DSS_UNION = 0x0010,
|
|
|
|
/// <summary>Embosses the image.</summary>
|
|
DSS_DISABLED = 0x0020,
|
|
|
|
/// <summary>Draws the image using the brush specified by the hbr parameter.</summary>
|
|
DSS_MONO = 0x0080,
|
|
|
|
/// <summary>Ignores the ampersand (&) prefix character in the text, thus the letter that follows will not be underlined. This
|
|
/// must be used with DST_PREFIXTEXT.</summary>
|
|
DSS_HIDEPREFIX = 0x0200,
|
|
|
|
/// <summary>Draws only the underline at the position of the letter after the ampersand (&) prefix character. No text in the
|
|
/// string is drawn. This must be used with DST_PREFIXTEXT.</summary>
|
|
DSS_PREFIXONLY = 0x0400,
|
|
|
|
/// <summary>Aligns the text to the right.</summary>
|
|
DSS_RIGHT = 0x8000,
|
|
}
|
|
|
|
/// <summary>State of the control to draw with <see cref="DrawFrameControl"/>.</summary>
|
|
[PInvokeData("winuser.h", MSDNShortId = "3102007e-e9f7-46d8-ae10-cf156d2131f6")]
|
|
[Flags]
|
|
public enum FrameControlState
|
|
{
|
|
/// <summary>Close button</summary>
|
|
DFCS_CAPTIONCLOSE = 0x0000,
|
|
|
|
/// <summary>Minimize button</summary>
|
|
DFCS_CAPTIONMIN = 0x0001,
|
|
|
|
/// <summary>Maximize button</summary>
|
|
DFCS_CAPTIONMAX = 0x0002,
|
|
|
|
/// <summary>Restore button</summary>
|
|
DFCS_CAPTIONRESTORE = 0x0003,
|
|
|
|
/// <summary>Help button</summary>
|
|
DFCS_CAPTIONHELP = 0x0004,
|
|
|
|
/// <summary>Submenu arrow</summary>
|
|
DFCS_MENUARROW = 0x0000,
|
|
|
|
/// <summary>Check mark</summary>
|
|
DFCS_MENUCHECK = 0x0001,
|
|
|
|
/// <summary>Bullet</summary>
|
|
DFCS_MENUBULLET = 0x0002,
|
|
|
|
/// <summary>
|
|
/// Submenu arrow pointing left. This is used for the right-to-left cascading menus used with right-to-left languages such as
|
|
/// Arabic or Hebrew.
|
|
/// </summary>
|
|
DFCS_MENUARROWRIGHT = 0x0004,
|
|
|
|
/// <summary>Up arrow of scroll bar</summary>
|
|
DFCS_SCROLLUP = 0x0000,
|
|
|
|
/// <summary>Down arrow of scroll bar</summary>
|
|
DFCS_SCROLLDOWN = 0x0001,
|
|
|
|
/// <summary>Left arrow of scroll bar</summary>
|
|
DFCS_SCROLLLEFT = 0x0002,
|
|
|
|
/// <summary>Right arrow of scroll bar</summary>
|
|
DFCS_SCROLLRIGHT = 0x0003,
|
|
|
|
/// <summary>Combo box scroll bar</summary>
|
|
DFCS_SCROLLCOMBOBOX = 0x0005,
|
|
|
|
/// <summary>Size grip in lower-right corner of window</summary>
|
|
DFCS_SCROLLSIZEGRIP = 0x0008,
|
|
|
|
/// <summary>Size grip in lower-left corner of window. This is used with right-to-left languages such as Arabic or Hebrew.</summary>
|
|
DFCS_SCROLLSIZEGRIPRIGHT = 0x0010,
|
|
|
|
/// <summary>Check box</summary>
|
|
DFCS_BUTTONCHECK = 0x0000,
|
|
|
|
/// <summary>Image for radio button (nonsquare needs image)</summary>
|
|
DFCS_BUTTONRADIOIMAGE = 0x0001,
|
|
|
|
/// <summary>Mask for radio button (nonsquare needs mask)</summary>
|
|
DFCS_BUTTONRADIOMASK = 0x0002,
|
|
|
|
/// <summary>Radio button</summary>
|
|
DFCS_BUTTONRADIO = 0x0004,
|
|
|
|
/// <summary>Three-state button</summary>
|
|
DFCS_BUTTON3STATE = 0x0008,
|
|
|
|
/// <summary>Push button</summary>
|
|
DFCS_BUTTONPUSH = 0x0010,
|
|
|
|
/// <summary>Button is inactive (grayed).</summary>
|
|
DFCS_INACTIVE = 0x0100,
|
|
|
|
/// <summary>Button is pushed.</summary>
|
|
DFCS_PUSHED = 0x0200,
|
|
|
|
/// <summary>Button is checked.</summary>
|
|
DFCS_CHECKED = 0x0400,
|
|
|
|
/// <summary>The background remains untouched. This flag can only be combined with DFCS_MENUARROWUP or DFCS_MENUARROWDOWN.</summary>
|
|
DFCS_TRANSPARENT = 0x0800,
|
|
|
|
/// <summary>Button is hot-tracked.</summary>
|
|
DFCS_HOT = 0x1000,
|
|
|
|
/// <summary>Bounding rectangle is adjusted to exclude the surrounding edge of the push button.</summary>
|
|
DFCS_ADJUSTRECT = 0x2000,
|
|
|
|
/// <summary>Button has a flat border.</summary>
|
|
DFCS_FLAT = 0x4000,
|
|
|
|
/// <summary>Button has a monochrome border.</summary>
|
|
DFCS_MONO = 0x8000,
|
|
}
|
|
|
|
/// <summary>Type of control to draw with <see cref="DrawFrameControl"/>.</summary>
|
|
[PInvokeData("winuser.h", MSDNShortId = "3102007e-e9f7-46d8-ae10-cf156d2131f6")]
|
|
public enum FrameControlType
|
|
{
|
|
/// <summary>Title bar.</summary>
|
|
DFC_CAPTION = 1,
|
|
|
|
/// <summary>Menu bar.</summary>
|
|
DFC_MENU = 2,
|
|
|
|
/// <summary>Scroll bar.</summary>
|
|
DFC_SCROLL = 3,
|
|
|
|
/// <summary>Standard button.</summary>
|
|
DFC_BUTTON = 4,
|
|
|
|
/// <summary>Popup menu item.</summary>
|
|
DFC_POPUPMENU = 5,
|
|
}
|
|
|
|
/// <summary>Flags used by <see cref="DrawAnimatedRects"/>.</summary>
|
|
[PInvokeData("winuser.h", MSDNShortId = "54a9234a-0056-4cfe-9158-86635dc31bc6")]
|
|
public enum IDANI
|
|
{
|
|
/// <summary/>
|
|
IDANI_OPEN = 1,
|
|
|
|
/// <summary>
|
|
/// The window caption will animate from the position specified by lprcFrom to the position specified by lprcTo. The effect is
|
|
/// similar to minimizing or maximizing a window.
|
|
/// </summary>
|
|
IDANI_CAPTION = 3
|
|
}
|
|
|
|
/// <summary>Flags used to invalidate or validate a window, control repainting, and control which windows are affected by RedrawWindow.</summary>
|
|
[PInvokeData("winuser.h", MSDNShortId = "c6cb7f74-237e-4d3e-a852-894da36e990c")]
|
|
[Flags]
|
|
public enum RedrawWindowFlags
|
|
{
|
|
/// <summary>Invalidates lprcUpdate or hrgnUpdate (only one may be non-NULL). If both are NULL, the entire window is invalidated.</summary>
|
|
RDW_INVALIDATE = 0x0001,
|
|
|
|
/// <summary>Causes a WM_PAINT message to be posted to the window regardless of whether any portion of the window is invalid.</summary>
|
|
RDW_INTERNALPAINT = 0x0002,
|
|
|
|
/// <summary>
|
|
/// Causes the window to receive a WM_ERASEBKGND message when the window is repainted. The RDW_INVALIDATE flag must also be
|
|
/// specified; otherwise, RDW_ERASE has no effect.
|
|
/// </summary>
|
|
RDW_ERASE = 0x0004,
|
|
|
|
/// <summary>
|
|
/// Validates lprcUpdate or hrgnUpdate (only one may be non-NULL). If both are NULL, the entire window is validated. This flag
|
|
/// does not affect internal WM_PAINT messages.
|
|
/// </summary>
|
|
RDW_VALIDATE = 0x0008,
|
|
|
|
/// <summary>
|
|
/// Suppresses any pending internal WM_PAINT messages. This flag does not affect WM_PAINT messages resulting from a non-NULL
|
|
/// update area.
|
|
/// </summary>
|
|
RDW_NOINTERNALPAINT = 0x0010,
|
|
|
|
/// <summary>Suppresses any pending WM_ERASEBKGND messages.</summary>
|
|
RDW_NOERASE = 0x0020,
|
|
|
|
/// <summary>Excludes child windows, if any, from the repainting operation.</summary>
|
|
RDW_NOCHILDREN = 0x0040,
|
|
|
|
/// <summary>Includes child windows, if any, in the repainting operation.</summary>
|
|
RDW_ALLCHILDREN = 0x0080,
|
|
|
|
/// <summary>
|
|
/// Causes the affected windows (as specified by the RDW_ALLCHILDREN and RDW_NOCHILDREN flags) to receive WM_NCPAINT,
|
|
/// WM_ERASEBKGND, and WM_PAINT messages, if necessary, before the function returns.
|
|
/// </summary>
|
|
RDW_UPDATENOW = 0x0100,
|
|
|
|
/// <summary>
|
|
/// Causes the affected windows (as specified by the RDW_ALLCHILDREN and RDW_NOCHILDREN flags) to receive WM_NCPAINT and
|
|
/// WM_ERASEBKGND messages, if necessary, before the function returns. WM_PAINT messages are received at the ordinary time.
|
|
/// </summary>
|
|
RDW_ERASENOW = 0x0200,
|
|
|
|
/// <summary>
|
|
/// Causes any part of the nonclient area of the window that intersects the update region to receive a WM_NCPAINT message. The
|
|
/// RDW_INVALIDATE flag must also be specified; otherwise, RDW_FRAME has no effect. The WM_NCPAINT message is typically not sent
|
|
/// during the execution of RedrawWindow unless either RDW_UPDATENOW or RDW_ERASENOW is specified.
|
|
/// </summary>
|
|
RDW_FRAME = 0x0400,
|
|
|
|
/// <summary>
|
|
/// Suppresses any pending WM_NCPAINT messages. This flag must be used with RDW_VALIDATE and is typically used with
|
|
/// RDW_NOCHILDREN. RDW_NOFRAME should be used with care, as it could cause parts of a window to be painted improperly.
|
|
/// </summary>
|
|
RDW_NOFRAME = 0x0800,
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>BeginPaint</c> function prepares the specified window for painting and fills a PAINTSTRUCT structure with information
|
|
/// about the painting.
|
|
/// </summary>
|
|
/// <param name="hWnd">Handle to the window to be repainted.</param>
|
|
/// <param name="lpPaint">Pointer to the PAINTSTRUCT structure that will receive painting information.</param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is the handle to a display device context for the specified window.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>, indicating that no display device context is available.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The <c>BeginPaint</c> function automatically sets the clipping region of the device context to exclude any area outside the
|
|
/// update region. The update region is set by the InvalidateRect or InvalidateRgn function and by the system after sizing, moving,
|
|
/// creating, scrolling, or any other operation that affects the client area. If the update region is marked for erasing,
|
|
/// <c>BeginPaint</c> sends a <c>WM_ERASEBKGND</c> message to the window.
|
|
/// </para>
|
|
/// <para>
|
|
/// An application should not call <c>BeginPaint</c> except in response to a <c>WM_PAINT</c> message. Each call to <c>BeginPaint</c>
|
|
/// must have a corresponding call to the EndPaint function.
|
|
/// </para>
|
|
/// <para>If the caret is in the area to be painted, <c>BeginPaint</c> automatically hides the caret to prevent it from being erased.</para>
|
|
/// <para>
|
|
/// If the window's class has a background brush, <c>BeginPaint</c> uses that brush to erase the background of the update region
|
|
/// before returning.
|
|
/// </para>
|
|
/// <para>DPI Virtualization</para>
|
|
/// <para>This API does not participate in DPI virtualization. The output returned is always in terms of physical pixels.</para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see Drawing in the Client Area.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-beginpaint HDC BeginPaint( HWND hWnd, LPPAINTSTRUCT
|
|
// lpPaint );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "513341d7-bed8-469c-a067-ee71dc8860f9")]
|
|
public static extern HDC BeginPaint(HWND hWnd, out PAINTSTRUCT lpPaint);
|
|
|
|
/// <summary>Animates the caption of a window to indicate the opening of an icon or the minimizing or maximizing of a window.</summary>
|
|
/// <param name="hwnd">
|
|
/// A handle to the window whose caption should be animated on the screen. The animation will be clipped to the parent of this window.
|
|
/// </param>
|
|
/// <param name="idAni">
|
|
/// The type of animation. This must be IDANI_CAPTION. With the IDANI_CAPTION animation type, the window caption will animate from
|
|
/// the position specified by lprcFrom to the position specified by lprcTo. The effect is similar to minimizing or maximizing a window.
|
|
/// </param>
|
|
/// <param name="lprcFrom">
|
|
/// A pointer to a RECT structure specifying the location and size of the icon or minimized window. Coordinates are relative to the
|
|
/// clipping window hwnd.
|
|
/// </param>
|
|
/// <param name="lprcTo">
|
|
/// A pointer to a RECT structure specifying the location and size of the restored window. Coordinates are relative to the clipping
|
|
/// window hwnd.
|
|
/// </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>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-drawanimatedrects BOOL DrawAnimatedRects( HWND hwnd, int
|
|
// idAni, const RECT *lprcFrom, const RECT *lprcTo );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "54a9234a-0056-4cfe-9158-86635dc31bc6")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DrawAnimatedRects(HWND hwnd, IDANI idAni, in RECT lprcFrom, in RECT lprcTo);
|
|
|
|
/// <summary>The <c>DrawCaption</c> function draws a window caption.</summary>
|
|
/// <param name="hwnd">A handle to a window that supplies text and an icon for the window caption.</param>
|
|
/// <param name="hdc">A handle to a device context. The function draws the window caption into this device context.</param>
|
|
/// <param name="lprect">
|
|
/// A pointer to a RECT structure that specifies the bounding rectangle for the window caption in logical coordinates.
|
|
/// </param>
|
|
/// <param name="flags">
|
|
/// <para>The drawing options. This parameter can be zero or more of the following values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>DC_ACTIVE</term>
|
|
/// <term>The function uses the colors that denote an active caption.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DC_BUTTONS</term>
|
|
/// <term>If set, the function draws the buttons in the caption bar (to minimize, restore, or close an application).</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DC_GRADIENT</term>
|
|
/// <term>
|
|
/// When this flag is set, the function uses COLOR_GRADIENTACTIVECAPTION (if the DC_ACTIVE flag was set) or
|
|
/// COLOR_GRADIENTINACTIVECAPTION for the title-bar color. If this flag is not set, the function uses COLOR_ACTIVECAPTION or
|
|
/// COLOR_INACTIVECAPTION for both colors.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DC_ICON</term>
|
|
/// <term>The function draws the icon when drawing the caption text.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DC_INBUTTON</term>
|
|
/// <term>The function draws the caption as a button.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DC_SMALLCAP</term>
|
|
/// <term>The function draws a small caption, using the current small caption font.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DC_TEXT</term>
|
|
/// <term>The function draws the caption text when drawing the caption.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>If DC_SMALLCAP is specified, the function draws a normal window caption.</para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is nonzero.</para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-drawcaption BOOL DrawCaption( HWND hwnd, HDC hdc, const
|
|
// RECT *lprect, UINT flags );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "9348e29f-ce56-4664-8862-f5810c797622")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DrawCaption(HWND hwnd, HDC hdc, in RECT lprect, DrawCaptionFlags flags);
|
|
|
|
/// <summary>The <c>DrawEdge</c> function draws one or more edges of rectangle.</summary>
|
|
/// <param name="hdc">A handle to the device context.</param>
|
|
/// <param name="qrc">A pointer to a <c>RECT</c> structure that contains the logical coordinates of the rectangle.</param>
|
|
/// <param name="edge">
|
|
/// <para>
|
|
/// The type of inner and outer edges to draw. This parameter must be a combination of one inner-border flag and one outer-border
|
|
/// flag. The inner-border flags are as follows.
|
|
/// </para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>BDR_RAISEDINNER</term>
|
|
/// <term>Raised inner edge.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BDR_SUNKENINNER</term>
|
|
/// <term>Sunken inner edge.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// <para>The outer-border flags are as follows.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>BDR_RAISEDOUTER</term>
|
|
/// <term>Raised outer edge.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BDR_SUNKENOUTER</term>
|
|
/// <term>Sunken outer edge.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// <para>Alternatively, the edge parameter can specify one of the following flags.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>EDGE_BUMP</term>
|
|
/// <term>Combination of BDR_RAISEDOUTER and BDR_SUNKENINNER.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>EDGE_ETCHED</term>
|
|
/// <term>Combination of BDR_SUNKENOUTER and BDR_RAISEDINNER.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>EDGE_RAISED</term>
|
|
/// <term>Combination of BDR_RAISEDOUTER and BDR_RAISEDINNER.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>EDGE_SUNKEN</term>
|
|
/// <term>Combination of BDR_SUNKENOUTER and BDR_SUNKENINNER.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="grfFlags">
|
|
/// <para>The type of border. This parameter can be a combination of the following values.</para>
|
|
/// <para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>BF_ADJUST</term>
|
|
/// <term>
|
|
/// If this flag is passed, shrink the rectangle pointed to by the qrc parameter to exclude the edges that were drawn.If this flag is
|
|
/// not passed, then do not change the rectangle pointed to by the qrc parameter.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_BOTTOM</term>
|
|
/// <term>Bottom of border rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_BOTTOMLEFT</term>
|
|
/// <term>Bottom and left side of border rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_BOTTOMRIGHT</term>
|
|
/// <term>Bottom and right side of border rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_DIAGONAL</term>
|
|
/// <term>Diagonal border.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_DIAGONAL_ENDBOTTOMLEFT</term>
|
|
/// <term>Diagonal border. The end point is the lower-left corner of the rectangle; the origin is top-right corner.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_DIAGONAL_ENDBOTTOMRIGHT</term>
|
|
/// <term>Diagonal border. The end point is the lower-right corner of the rectangle; the origin is top-left corner.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_DIAGONAL_ENDTOPLEFT</term>
|
|
/// <term>Diagonal border. The end point is the top-left corner of the rectangle; the origin is lower-right corner.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_DIAGONAL_ENDTOPRIGHT</term>
|
|
/// <term>Diagonal border. The end point is the top-right corner of the rectangle; the origin is lower-left corner.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_FLAT</term>
|
|
/// <term>Flat border.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_LEFT</term>
|
|
/// <term>Left side of border rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_MIDDLE</term>
|
|
/// <term>Interior of rectangle to be filled.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_MONO</term>
|
|
/// <term>One-dimensional border.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_RECT</term>
|
|
/// <term>Entire border rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_RIGHT</term>
|
|
/// <term>Right side of border rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_SOFT</term>
|
|
/// <term>Soft buttons instead of tiles.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_TOP</term>
|
|
/// <term>Top of border rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_TOPLEFT</term>
|
|
/// <term>Top and left side of border rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>BF_TOPRIGHT</term>
|
|
/// <term>Top and right side of border rectangle.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is nonzero.</para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
// BOOL DrawEdge( _In_ HDC hdc, _Inout_ LPRECT qrc, _In_ UINT edge, _In_ UINT grfFlags); https://msdn.microsoft.com/en-us/library/windows/desktop/dd162477(v=vs.85).aspx
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("Winuser.h", MSDNShortId = "dd162477")]
|
|
public static extern bool DrawEdge(HDC hdc, ref RECT qrc, BorderStyles3D edge, BorderFlags grfFlags);
|
|
|
|
/// <summary>The <c>DrawFocusRect</c> function draws a rectangle in the style used to indicate that the rectangle has the focus.</summary>
|
|
/// <param name="hDC">A handle to the device context.</param>
|
|
/// <param name="lprc">A pointer to a RECT structure that specifies the logical coordinates of the rectangle.</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>DrawFocusRect</c> works only in MM_TEXT mode.</para>
|
|
/// <para>
|
|
/// Because <c>DrawFocusRect</c> is an XOR function, calling it a second time with the same rectangle removes the rectangle from the screen.
|
|
/// </para>
|
|
/// <para>
|
|
/// This function draws a rectangle that cannot be scrolled. To scroll an area containing a rectangle drawn by this function, call
|
|
/// <c>DrawFocusRect</c> to remove the rectangle from the screen, scroll the area, and then call <c>DrawFocusRect</c> again to draw
|
|
/// the rectangle in the new position.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>Windows XP:</c> The focus rectangle can now be thicker than 1 pixel, so it is more visible for high-resolution, high-density
|
|
/// displays and accessibility needs. This is handled by the SPI_SETFOCUSBORDERWIDTH and SPI_SETFOCUSBORDERHEIGHT in SystemParametersInfo.
|
|
/// </para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see "Creating an Owner-Drawn List Box" in Using List Boxes.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-drawfocusrect BOOL DrawFocusRect( HDC hDC, const RECT
|
|
// *lprc );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "a910d04f-fe4d-4fc9-a518-abac864da6f3")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DrawFocusRect(HDC hDC, in RECT lprc);
|
|
|
|
/// <summary>The <c>DrawFrameControl</c> function draws a frame control of the specified type and style.</summary>
|
|
/// <param name="hdc">Handle to the device context of the window in which to draw the control.</param>
|
|
/// <param name="lprc">
|
|
/// Long pointer to a RECT structure that contains the logical coordinates of the bounding rectangle for frame control.
|
|
/// </param>
|
|
/// <param name="uType">Specifies the type of frame control to draw.</param>
|
|
/// <param name="uState">Specifies the initial state of the frame control.</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 uType is either DFC_MENU or DFC_BUTTON and uState is not DFCS_BUTTONPUSH, the frame control is a black-on-white mask (that is,
|
|
/// a black frame control on a white background). In such cases, the application must pass a handle to a bitmap memory device
|
|
/// control. The application can then use the associated bitmap as the hbmMask parameter to the MaskBlt function, or it can use the
|
|
/// device context as a parameter to the BitBlt function using ROPs such as SRCAND and SRCINVERT.
|
|
/// </para>
|
|
/// <para>DPI Virtualization</para>
|
|
/// <para>
|
|
/// This API does not participate in DPI virtualization. The input given is always in terms of physical pixels, and is not related to
|
|
/// the calling context.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-drawframecontrol BOOL DrawFrameControl( HDC , LPRECT ,
|
|
// UINT , UINT );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "3102007e-e9f7-46d8-ae10-cf156d2131f6")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DrawFrameControl(HDC hdc, in RECT lprc, FrameControlType uType, FrameControlState uState);
|
|
|
|
/// <summary>
|
|
/// The <c>DrawState</c> function displays an image and applies a visual effect to indicate a state, such as a disabled or default state.
|
|
/// </summary>
|
|
/// <param name="hdc">A handle to the device context to draw in.</param>
|
|
/// <param name="hbrFore">
|
|
/// A handle to the brush used to draw the image, if the state specified by the fuFlags parameter is DSS_MONO. This parameter is
|
|
/// ignored for other states.
|
|
/// </param>
|
|
/// <param name="qfnCallBack">
|
|
/// A pointer to an application-defined callback function used to render the image. This parameter is required if the image type in
|
|
/// fuFlags is DST_COMPLEX. It is optional and can be <c>NULL</c> if the image type is DST_TEXT. For all other image types, this
|
|
/// parameter is ignored. For more information about the callback function, see the DrawStateProc function.
|
|
/// </param>
|
|
/// <param name="lData">Information about the image. The meaning of this parameter depends on the image type.</param>
|
|
/// <param name="wData">
|
|
/// Information about the image. The meaning of this parameter depends on the image type. It is, however, zero extended for use with
|
|
/// the DrawStateProc function.
|
|
/// </param>
|
|
/// <param name="x">The horizontal location, in device units, at which to draw the image.</param>
|
|
/// <param name="y">The vertical location, in device units, at which to draw the image.</param>
|
|
/// <param name="cx">
|
|
/// The width of the image, in device units. This parameter is required if the image type is DST_COMPLEX. Otherwise, it can be zero
|
|
/// to calculate the width of the image.
|
|
/// </param>
|
|
/// <param name="cy">
|
|
/// The height of the image, in device units. This parameter is required if the image type is DST_COMPLEX. Otherwise, it can be zero
|
|
/// to calculate the height of the image.
|
|
/// </param>
|
|
/// <param name="uFlags">
|
|
/// <para>The image type and state. This parameter can be one of the following type values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value (type)</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>DST_BITMAP</term>
|
|
/// <term>
|
|
/// The image is a bitmap. The lData parameter is the bitmap handle. Note that the bitmap cannot already be selected into an existing
|
|
/// device context.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DST_COMPLEX</term>
|
|
/// <term>
|
|
/// The image is application defined. To render the image, DrawState calls the callback function specified by the lpOutputFunc parameter.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DST_ICON</term>
|
|
/// <term>The image is an icon. The lData parameter is the icon handle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DST_PREFIXTEXT</term>
|
|
/// <term>
|
|
/// The image is text that may contain an accelerator mnemonic. DrawState interprets the ampersand (&) prefix character as a
|
|
/// directive to underscore the character that follows. The lData parameter is a pointer to the string, and the wData parameter
|
|
/// specifies the length. If wData is zero, the string must be null-terminated.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DST_TEXT</term>
|
|
/// <term>
|
|
/// The image is text. The lData parameter is a pointer to the string, and the wData parameter specifies the length. If wData is
|
|
/// zero, the string must be null-terminated.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>This parameter can also be one of the following state values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value (state)</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>DSS_DISABLED</term>
|
|
/// <term>Embosses the image.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_HIDEPREFIX</term>
|
|
/// <term>
|
|
/// Ignores the ampersand (&) prefix character in the text, thus the letter that follows will not be underlined. This must be
|
|
/// used with DST_PREFIXTEXT.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_MONO</term>
|
|
/// <term>Draws the image using the brush specified by the hbr parameter.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_NORMAL</term>
|
|
/// <term>Draws the image without any modification.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_PREFIXONLY</term>
|
|
/// <term>
|
|
/// Draws only the underline at the position of the letter after the ampersand (&) prefix character. No text in the string is
|
|
/// drawn. This must be used with DST_PREFIXTEXT.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_RIGHT</term>
|
|
/// <term>Aligns the text to the right.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_UNION</term>
|
|
/// <term>Dithers the image.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>For all states except DSS_NORMAL, the image is converted to monochrome before the visual effect is applied.</para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is nonzero.</para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-drawstatea BOOL DrawStateA( HDC hdc, HBRUSH hbrFore,
|
|
// DRAWSTATEPROC qfnCallBack, LPARAM lData, WPARAM wData, int x, int y, int cx, int cy, UINT uFlags );
|
|
[DllImport(Lib.User32, SetLastError = false, CharSet = CharSet.Auto)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "b92150be-8264-4ea8-a2ea-d70b7fba6361")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DrawState(HDC hdc, HBRUSH hbrFore, DrawStateProc qfnCallBack, IntPtr lData, IntPtr wData, int x, int y, int cx, int cy, DrawStateFlags uFlags);
|
|
|
|
/// <summary>
|
|
/// The <c>DrawState</c> function displays an image and applies a visual effect to indicate a state, such as a disabled or default state.
|
|
/// </summary>
|
|
/// <param name="hdc">A handle to the device context to draw in.</param>
|
|
/// <param name="hbrFore">
|
|
/// A handle to the brush used to draw the image, if the state specified by the fuFlags parameter is DSS_MONO. This parameter is
|
|
/// ignored for other states.
|
|
/// </param>
|
|
/// <param name="qfnCallBack">
|
|
/// A pointer to an application-defined callback function used to render the image. This parameter is required if the image type in
|
|
/// fuFlags is DST_COMPLEX. It is optional and can be <c>NULL</c> if the image type is DST_TEXT. For all other image types, this
|
|
/// parameter is ignored. For more information about the callback function, see the DrawStateProc function.
|
|
/// </param>
|
|
/// <param name="lData">Information about the image. The meaning of this parameter depends on the image type.</param>
|
|
/// <param name="wData">
|
|
/// Information about the image. The meaning of this parameter depends on the image type. It is, however, zero extended for use with
|
|
/// the DrawStateProc function.
|
|
/// </param>
|
|
/// <param name="x">The horizontal location, in device units, at which to draw the image.</param>
|
|
/// <param name="y">The vertical location, in device units, at which to draw the image.</param>
|
|
/// <param name="cx">
|
|
/// The width of the image, in device units. This parameter is required if the image type is DST_COMPLEX. Otherwise, it can be zero
|
|
/// to calculate the width of the image.
|
|
/// </param>
|
|
/// <param name="cy">
|
|
/// The height of the image, in device units. This parameter is required if the image type is DST_COMPLEX. Otherwise, it can be zero
|
|
/// to calculate the height of the image.
|
|
/// </param>
|
|
/// <param name="uFlags">
|
|
/// <para>The image type and state. This parameter can be one of the following type values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value (type)</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>DST_BITMAP</term>
|
|
/// <term>
|
|
/// The image is a bitmap. The lData parameter is the bitmap handle. Note that the bitmap cannot already be selected into an existing
|
|
/// device context.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DST_COMPLEX</term>
|
|
/// <term>
|
|
/// The image is application defined. To render the image, DrawState calls the callback function specified by the lpOutputFunc parameter.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DST_ICON</term>
|
|
/// <term>The image is an icon. The lData parameter is the icon handle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DST_PREFIXTEXT</term>
|
|
/// <term>
|
|
/// The image is text that may contain an accelerator mnemonic. DrawState interprets the ampersand (&) prefix character as a
|
|
/// directive to underscore the character that follows. The lData parameter is a pointer to the string, and the wData parameter
|
|
/// specifies the length. If wData is zero, the string must be null-terminated.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DST_TEXT</term>
|
|
/// <term>
|
|
/// The image is text. The lData parameter is a pointer to the string, and the wData parameter specifies the length. If wData is
|
|
/// zero, the string must be null-terminated.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>This parameter can also be one of the following state values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value (state)</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>DSS_DISABLED</term>
|
|
/// <term>Embosses the image.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_HIDEPREFIX</term>
|
|
/// <term>
|
|
/// Ignores the ampersand (&) prefix character in the text, thus the letter that follows will not be underlined. This must be
|
|
/// used with DST_PREFIXTEXT.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_MONO</term>
|
|
/// <term>Draws the image using the brush specified by the hbr parameter.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_NORMAL</term>
|
|
/// <term>Draws the image without any modification.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_PREFIXONLY</term>
|
|
/// <term>
|
|
/// Draws only the underline at the position of the letter after the ampersand (&) prefix character. No text in the string is
|
|
/// drawn. This must be used with DST_PREFIXTEXT.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_RIGHT</term>
|
|
/// <term>Aligns the text to the right.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>DSS_UNION</term>
|
|
/// <term>Dithers the image.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>For all states except DSS_NORMAL, the image is converted to monochrome before the visual effect is applied.</para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is nonzero.</para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-drawstatea BOOL DrawStateA( HDC hdc, HBRUSH hbrFore,
|
|
// DRAWSTATEPROC qfnCallBack, LPARAM lData, WPARAM wData, int x, int y, int cx, int cy, UINT uFlags );
|
|
[DllImport(Lib.User32, SetLastError = false, CharSet = CharSet.Auto)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "b92150be-8264-4ea8-a2ea-d70b7fba6361")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool DrawState(HDC hdc, HBRUSH hbrFore, DrawStateProc qfnCallBack, string lData, IntPtr wData, int x, int y, int cx, int cy, DrawStateFlags uFlags);
|
|
|
|
/// <summary>
|
|
/// The <c>EndPaint</c> function marks the end of painting in the specified window. This function is required for each call to the
|
|
/// BeginPaint function, but only after painting is complete.
|
|
/// </summary>
|
|
/// <param name="hWnd">Handle to the window that has been repainted.</param>
|
|
/// <param name="lpPaint">Pointer to a PAINTSTRUCT structure that contains the painting information retrieved by BeginPaint.</param>
|
|
/// <returns>The return value is always nonzero.</returns>
|
|
/// <remarks>
|
|
/// <para>If the caret was hidden by BeginPaint, <c>EndPaint</c> restores the caret to the screen.</para>
|
|
/// <para><c>EndPaint</c> releases the display device context that BeginPaint retrieved.</para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see Drawing in the Client Area.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-endpaint BOOL EndPaint( HWND hWnd, const PAINTSTRUCT
|
|
// *lpPaint );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "b07cfed9-21c4-4459-855a-eaf4d1d34ab8")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool EndPaint(HWND hWnd, in PAINTSTRUCT lpPaint);
|
|
|
|
/// <summary>
|
|
/// The <c>ExcludeUpdateRgn</c> function prevents drawing within invalid areas of a window by excluding an updated region in the
|
|
/// window from a clipping region.
|
|
/// </summary>
|
|
/// <param name="hDC">Handle to the device context associated with the clipping region.</param>
|
|
/// <param name="hWnd">Handle to the window to update.</param>
|
|
/// <returns>
|
|
/// <para>The return value specifies the complexity of the excluded region; it can be any one of the following values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>COMPLEXREGION</term>
|
|
/// <term>Region consists of more than one rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR</term>
|
|
/// <term>An error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>NULLREGION</term>
|
|
/// <term>Region is empty.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>SIMPLEREGION</term>
|
|
/// <term>Region is a single rectangle.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-excludeupdatergn int ExcludeUpdateRgn( HDC hDC, HWND hWnd );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "408fda82-30c3-4eb4-be42-3085c71ba99e")]
|
|
public static extern Gdi32.RegionFlags ExcludeUpdateRgn(HDC hDC, HWND hWnd);
|
|
|
|
/// <summary>
|
|
/// The <c>FillRect</c> function fills a rectangle by using the specified brush. This function includes the left and top borders, but
|
|
/// excludes the right and bottom borders of the rectangle.
|
|
/// </summary>
|
|
/// <param name="hDC">A handle to the device context.</param>
|
|
/// <param name="lprc">A pointer to a RECT structure that contains the logical coordinates of the rectangle to be filled.</param>
|
|
/// <param name="hbr">A handle to the brush used to fill the rectangle.</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 brush identified by the hbr parameter may be either a handle to a logical brush or a color value. If specifying a handle to a
|
|
/// logical brush, call one of the following functions to obtain the handle: CreateHatchBrush, CreatePatternBrush, or
|
|
/// CreateSolidBrush. Additionally, you may retrieve a handle to one of the stock brushes by using the GetStockObject function. If
|
|
/// specifying a color value for the hbr parameter, it must be one of the standard system colors (the value 1 must be added to the
|
|
/// chosen color). For example:
|
|
/// </para>
|
|
/// <para>For a list of all the standard system colors, see GetSysColor.</para>
|
|
/// <para>
|
|
/// When filling the specified rectangle, <c>FillRect</c> does not include the rectangle's right and bottom sides. GDI fills a
|
|
/// rectangle up to, but not including, the right column and bottom row, regardless of the current mapping mode.
|
|
/// </para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see Using Rectangles.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-fillrect int FillRect( HDC hDC, const RECT *lprc, HBRUSH
|
|
// hbr );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "98ab34da-ea07-4446-a62e-509c849d95f9")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool FillRect(HDC hDC, in RECT lprc, HBRUSH hbr);
|
|
|
|
/// <summary>
|
|
/// The <c>FrameRect</c> function draws a border around the specified rectangle by using the specified brush. The width and height of
|
|
/// the border are always one logical unit.
|
|
/// </summary>
|
|
/// <param name="hDC">A handle to the device context in which the border is drawn.</param>
|
|
/// <param name="lprc">
|
|
/// A pointer to a RECT structure that contains the logical coordinates of the upper-left and lower-right corners of the rectangle.
|
|
/// </param>
|
|
/// <param name="hbr">A handle to the brush used to draw the border.</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 brush identified by the hbr parameter must have been created by using the CreateHatchBrush, CreatePatternBrush, or
|
|
/// CreateSolidBrush function, or retrieved by using the GetStockObject function.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the <c>bottom</c> member of the RECT structure is less than the <c>top</c> member, or if the <c>right</c> member is less than
|
|
/// the <c>left</c> member, the function does not draw the rectangle.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-framerect int FrameRect( HDC hDC, const RECT *lprc, HBRUSH
|
|
// hbr );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "a1083cb5-5e6c-4134-badf-9fc5142d1453")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool FrameRect(HDC hDC, in RECT lprc, HBRUSH hbr);
|
|
|
|
/// <summary>
|
|
/// The <c>GetUpdateRect</c> function retrieves the coordinates of the smallest rectangle that completely encloses the update region
|
|
/// of the specified window. <c>GetUpdateRect</c> retrieves the rectangle in logical coordinates. If there is no update region,
|
|
/// <c>GetUpdateRect</c> retrieves an empty rectangle (sets all coordinates to zero).
|
|
/// </summary>
|
|
/// <param name="hWnd">Handle to the window whose update region is to be retrieved.</param>
|
|
/// <param name="lpRect">
|
|
/// <para>Pointer to the RECT structure that receives the coordinates, in device units, of the enclosing rectangle.</para>
|
|
/// <para>
|
|
/// An application can set this parameter to <c>NULL</c> to determine whether an update region exists for the window. If this
|
|
/// parameter is <c>NULL</c>, <c>GetUpdateRect</c> returns nonzero if an update region exists, and zero if one does not. This
|
|
/// provides a simple and efficient means of determining whether a <c>WM_PAINT</c> message resulted from an invalid area.
|
|
/// </para>
|
|
/// </param>
|
|
/// <param name="bErase">
|
|
/// Specifies whether the background in the update region is to be erased. If this parameter is <c>TRUE</c> and the update region is
|
|
/// not empty, <c>GetUpdateRect</c> sends a <c>WM_ERASEBKGND</c> message to the specified window to erase the background.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the update region is not empty, the return value is nonzero.</para>
|
|
/// <para>If there is no update region, the return value is zero.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>The update rectangle retrieved by the BeginPaint function is identical to that retrieved by <c>GetUpdateRect</c>.</para>
|
|
/// <para>
|
|
/// BeginPaint automatically validates the update region, so any call to <c>GetUpdateRect</c> made immediately after the call to
|
|
/// <c>BeginPaint</c> retrieves an empty update region.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getupdaterect BOOL GetUpdateRect( HWND hWnd, LPRECT
|
|
// lpRect, BOOL bErase );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "e54483a1-8738-4b22-a24e-c0b31f6ca9d6")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool GetUpdateRect(HWND hWnd, PRECT lpRect, [MarshalAs(UnmanagedType.Bool)] bool bErase);
|
|
|
|
/// <summary>
|
|
/// The <c>GetUpdateRgn</c> function retrieves the update region of a window by copying it into the specified region. The coordinates
|
|
/// of the update region are relative to the upper-left corner of the window (that is, they are client coordinates).
|
|
/// </summary>
|
|
/// <param name="hWnd">Handle to the window with an update region that is to be retrieved.</param>
|
|
/// <param name="hRgn">Handle to the region to receive the update region.</param>
|
|
/// <param name="bErase">
|
|
/// Specifies whether the window background should be erased and whether nonclient areas of child windows should be drawn. If this
|
|
/// parameter is <c>FALSE</c>, no drawing is done.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>The return value indicates the complexity of the resulting region; it can be one of the following values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>COMPLEXREGION</term>
|
|
/// <term>Region consists of more than one rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR</term>
|
|
/// <term>An error occurred.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>NULLREGION</term>
|
|
/// <term>Region is empty.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>SIMPLEREGION</term>
|
|
/// <term>Region is a single rectangle.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// The BeginPaint function automatically validates the update region, so any call to <c>GetUpdateRgn</c> made immediately after the
|
|
/// call to <c>BeginPaint</c> retrieves an empty update region.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getupdatergn int GetUpdateRgn( HWND hWnd, HRGN hRgn, BOOL
|
|
// bErase );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "d80c4b44-3f50-46f9-bf5a-fff7868d91ba")]
|
|
public static extern Gdi32.RegionFlags GetUpdateRgn(HWND hWnd, HRGN hRgn, [MarshalAs(UnmanagedType.Bool)] bool bErase);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>GetWindowDC</c> function retrieves the device context (DC) for the entire window, including title bar, menus, and scroll
|
|
/// bars. A window device context permits painting anywhere in a window, because the origin of the device context is the upper-left
|
|
/// corner of the window instead of the client area.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>GetWindowDC</c> assigns default attributes to the window device context each time it retrieves the device context. Previous
|
|
/// attributes are lost.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hWnd">
|
|
/// <para>
|
|
/// A handle to the window with a device context that is to be retrieved. If this value is <c>NULL</c>, <c>GetWindowDC</c> retrieves
|
|
/// the device context for the entire screen.
|
|
/// </para>
|
|
/// <para>
|
|
/// If this parameter is <c>NULL</c>, <c>GetWindowDC</c> retrieves the device context for the primary display monitor. To get the
|
|
/// device context for other display monitors, use the EnumDisplayMonitors and CreateDC functions.
|
|
/// </para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is a handle to a device context for the specified window.</para>
|
|
/// <para>If the function fails, the return value is <c>NULL</c>, indicating an error or an invalid hWnd parameter.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// <c>GetWindowDC</c> is intended for special painting effects within a window's nonclient area. Painting in nonclient areas of any
|
|
/// window is not recommended.
|
|
/// </para>
|
|
/// <para>
|
|
/// The GetSystemMetrics function can be used to retrieve the dimensions of various parts of the nonclient area, such as the title
|
|
/// bar, menu, and scroll bars.
|
|
/// </para>
|
|
/// <para>The GetDC function can be used to retrieve a device context for the entire screen.</para>
|
|
/// <para>
|
|
/// After painting is complete, the ReleaseDC function must be called to release the device context. Not releasing the window device
|
|
/// context has serious effects on painting requested by applications.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getwindowdc HDC GetWindowDC( HWND hWnd );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "9e6a135e-e337-4129-a3ad-faf9a8ac9b2d")]
|
|
public static extern HDC GetWindowDC(HWND hWnd);
|
|
|
|
/// <summary>
|
|
/// The <c>GetWindowRgn</c> function obtains a copy of the window region of a window. The window region of a window is set by calling
|
|
/// the SetWindowRgn function. The window region determines the area within the window where the system permits drawing. The system
|
|
/// does not display any portion of a window that lies outside of the window region
|
|
/// </summary>
|
|
/// <param name="hWnd">Handle to the window whose window region is to be obtained.</param>
|
|
/// <param name="hRgn">Handle to the region which will be modified to represent the window region.</param>
|
|
/// <returns>
|
|
/// <para>The return value specifies the type of the region that the function obtains. It can be one of the following values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>NULLREGION</term>
|
|
/// <term>The region is empty.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>SIMPLEREGION</term>
|
|
/// <term>The region is a single rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>COMPLEXREGION</term>
|
|
/// <term>The region is more than one rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR</term>
|
|
/// <term>The specified window does not have a region, or an error occurred while attempting to return the region.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The coordinates of a window's window region are relative to the upper-left corner of the window, not the client area of the window.
|
|
/// </para>
|
|
/// <para>To set the window region of a window, call the SetWindowRgn function.</para>
|
|
/// <para>Examples</para>
|
|
/// <para>The following code shows how you pass in the handle of an existing region.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getwindowrgn int GetWindowRgn( HWND hWnd, HRGN hRgn );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "c8a8fa46-354b-489e-b016-fd2e728958ce")]
|
|
public static extern Gdi32.RegionFlags GetWindowRgn(HWND hWnd, HRGN hRgn);
|
|
|
|
/// <summary>
|
|
/// The <c>GetWindowRgnBox</c> function retrieves the dimensions of the tightest bounding rectangle for the window region of a window.
|
|
/// </summary>
|
|
/// <param name="hWnd">Handle to the window.</param>
|
|
/// <param name="lprc">
|
|
/// Pointer to a RECT structure that receives the rectangle dimensions, in device units relative to the upper-left corner of the window.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>The return value specifies the type of the region that the function obtains. It can be one of the following values.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>COMPLEXREGION</term>
|
|
/// <term>The region is more than one rectangle.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR</term>
|
|
/// <term>The specified window does not have a region, or an error occurred while attempting to return the region.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>NULLREGION</term>
|
|
/// <term>The region is empty.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>SIMPLEREGION</term>
|
|
/// <term>The region is a single rectangle.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The window region determines the area within the window where the system permits drawing. The system does not display any portion
|
|
/// of a window that lies outside of the window region. The coordinates of a window's window region are relative to the upper-left
|
|
/// corner of the window, not the client area of the window.
|
|
/// </para>
|
|
/// <para>To set the window region of a window, call the SetWindowRgn function.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getwindowrgnbox int GetWindowRgnBox( HWND hWnd, LPRECT
|
|
// lprc );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "20e23474-a1c5-4afe-976e-a7e5790fb91b")]
|
|
public static extern Gdi32.RegionFlags GetWindowRgnBox(HWND hWnd, out RECT lprc);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>GrayString</c> function draws gray text at the specified location. The function draws the text by copying it into a memory
|
|
/// bitmap, graying the bitmap, and then copying the bitmap to the screen. The function grays the text regardless of the selected
|
|
/// brush and background. <c>GrayString</c> uses the font currently selected for the specified device context.
|
|
/// </para>
|
|
/// <para>
|
|
/// If thelpOutputFuncparameter is <c>NULL</c>, GDI uses the TextOut function, and thelpDataparameter is assumed to be a pointer to
|
|
/// the character string to be output. If the characters to be output cannot be handled by <c>TextOut</c> (for example, the string is
|
|
/// stored as a bitmap), the application must supply its own output function.
|
|
/// </para>
|
|
/// </summary>
|
|
/// <param name="hDC">A handle to the device context.</param>
|
|
/// <param name="hBrush">
|
|
/// A handle to the brush to be used for graying. If this parameter is <c>NULL</c>, the text is grayed with the same brush that was
|
|
/// used to draw window text.
|
|
/// </param>
|
|
/// <param name="lpOutputFunc">
|
|
/// A pointer to the application-defined function that will draw the string, or, if TextOut is to be used to draw the string, it is a
|
|
/// <c>NULL</c> pointer. For details, see the OutputProc callback function.
|
|
/// </param>
|
|
/// <param name="lpData">
|
|
/// A pointer to data to be passed to the output function. If the lpOutputFunc parameter is <c>NULL</c>, lpData must be a pointer to
|
|
/// the string to be output.
|
|
/// </param>
|
|
/// <param name="nCount">
|
|
/// The number of characters to be output. If the nCount parameter is zero, <c>GrayString</c> calculates the length of the string
|
|
/// (assuming lpData is a pointer to the string). If nCount is 1 and the function pointed to by lpOutputFunc returns <c>FALSE</c>,
|
|
/// the image is shown but not grayed.
|
|
/// </param>
|
|
/// <param name="X">The device x-coordinate of the starting position of the rectangle that encloses the string.</param>
|
|
/// <param name="Y">The device y-coordinate of the starting position of the rectangle that encloses the string.</param>
|
|
/// <param name="nWidth">
|
|
/// The width, in device units, of the rectangle that encloses the string. If this parameter is zero, <c>GrayString</c> calculates
|
|
/// the width of the area, assuming lpData is a pointer to the string.
|
|
/// </param>
|
|
/// <param name="nHeight">
|
|
/// The height, in device units, of the rectangle that encloses the string. If this parameter is zero, <c>GrayString</c> calculates
|
|
/// the height of the area, assuming lpData is a pointer to the string.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the string is drawn, the return value is nonzero.</para>
|
|
/// <para>
|
|
/// If either the TextOut function or the application-defined output function returned zero, or there was insufficient memory to
|
|
/// create a memory bitmap for graying, the return value is zero.
|
|
/// </para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// Without calling <c>GrayString</c>, an application can draw grayed strings on devices that support a solid gray color. The system
|
|
/// color COLOR_GRAYTEXT is the solid-gray system color used to draw disabled text. The application can call the GetSysColor function
|
|
/// to retrieve the color value of COLOR_GRAYTEXT. If the color is other than zero (black), the application can call the SetTextColor
|
|
/// function to set the text color to the color value and then draw the string directly. If the retrieved color is black, the
|
|
/// application must call <c>GrayString</c> to gray the text.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-graystringa BOOL GrayStringA( HDC hDC, HBRUSH hBrush,
|
|
// GRAYSTRINGPROC lpOutputFunc, LPARAM lpData, int nCount, int X, int Y, int nWidth, int nHeight );
|
|
[DllImport(Lib.User32, SetLastError = false, CharSet = CharSet.Auto)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "b14b8c40-f97f-4e41-8d8d-687692acfda9")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool GrayString(HDC hDC, HBRUSH hBrush, OutputProc lpOutputFunc, string lpData, int nCount, int X, int Y, int nWidth, int nHeight);
|
|
|
|
/// <summary>
|
|
/// The <c>InvalidateRect</c> function adds a rectangle to the specified window's update region. The update region represents the
|
|
/// portion of the window's client area that must be redrawn.
|
|
/// </summary>
|
|
/// <param name="hWnd">
|
|
/// A handle to the window whose update region has changed. If this parameter is <c>NULL</c>, the system invalidates and redraws all
|
|
/// windows, not just the windows for this application, and sends the WM_ERASEBKGND and WM_NCPAINT messages before the function
|
|
/// returns. Setting this parameter to <c>NULL</c> is not recommended.
|
|
/// </param>
|
|
/// <param name="lpRect">
|
|
/// A pointer to a RECT structure that contains the client coordinates of the rectangle to be added to the update region. If this
|
|
/// parameter is <c>NULL</c>, the entire client area is added to the update region.
|
|
/// </param>
|
|
/// <param name="bErase">
|
|
/// Specifies whether the background within the update region is to be erased when the update region is processed. If this parameter
|
|
/// is <c>TRUE</c>, the background is erased when the BeginPaint function is called. If this parameter is <c>FALSE</c>, the
|
|
/// background remains unchanged.
|
|
/// </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 invalidated areas accumulate in the update region until the region is processed when the next WM_PAINT message occurs or
|
|
/// until the region is validated by using the ValidateRect or ValidateRgn function.
|
|
/// </para>
|
|
/// <para>
|
|
/// The system sends a WM_PAINT message to a window whenever its update region is not empty and there are no other messages in the
|
|
/// application queue for that window.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the bErase parameter is <c>TRUE</c> for any part of the update region, the background is erased in the entire region, not just
|
|
/// in the specified part.
|
|
/// </para>
|
|
/// <para>Examples</para>
|
|
/// <para>For an example, see Invalidating the Client Area.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-invalidaterect BOOL InvalidateRect( HWND hWnd, const RECT
|
|
// *lpRect, BOOL bErase );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "5a823d36-d08b-41c9-8857-540576f54b55")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool InvalidateRect(HWND hWnd, [In] PRECT lpRect, [MarshalAs(UnmanagedType.Bool)] bool bErase);
|
|
|
|
/// <summary>
|
|
/// The <c>InvalidateRgn</c> function invalidates the client area within the specified region by adding it to the current update
|
|
/// region of a window. The invalidated region, along with all other areas in the update region, is marked for painting when the next
|
|
/// WM_PAINT message occurs.
|
|
/// </summary>
|
|
/// <param name="hWnd">A handle to the window with an update region that is to be modified.</param>
|
|
/// <param name="hRgn">
|
|
/// A handle to the region to be added to the update region. The region is assumed to have client coordinates. If this parameter is
|
|
/// <c>NULL</c>, the entire client area is added to the update region.
|
|
/// </param>
|
|
/// <param name="bErase">
|
|
/// Specifies whether the background within the update region should be erased when the update region is processed. If this parameter
|
|
/// is <c>TRUE</c>, the background is erased when the BeginPaint function is called. If the parameter is <c>FALSE</c>, the background
|
|
/// remains unchanged.
|
|
/// </param>
|
|
/// <returns>The return value is always nonzero.</returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Invalidated areas accumulate in the update region until the next WM_PAINT message is processed or until the region is validated
|
|
/// by using the ValidateRect or ValidateRgn function.
|
|
/// </para>
|
|
/// <para>
|
|
/// The system sends a WM_PAINT message to a window whenever its update region is not empty and there are no other messages in the
|
|
/// application queue for that window.
|
|
/// </para>
|
|
/// <para>The specified region must have been created by using one of the region functions.</para>
|
|
/// <para>
|
|
/// If the bErase parameter is <c>TRUE</c> for any part of the update region, the background in the entire region is erased, not just
|
|
/// in the specified part.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-invalidatergn BOOL InvalidateRgn( HWND hWnd, HRGN hRgn,
|
|
// BOOL bErase );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "b5b44efe-8045-4e54-89f9-1766689a053d")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool InvalidateRgn(HWND hWnd, HRGN hRgn, [MarshalAs(UnmanagedType.Bool)] bool bErase);
|
|
|
|
/// <summary>
|
|
/// The <c>LockWindowUpdate</c> function disables or enables drawing in the specified window. Only one window can be locked at a time.
|
|
/// </summary>
|
|
/// <param name="hWndLock">
|
|
/// The window in which drawing will be disabled. If this parameter is <c>NULL</c>, drawing in the locked window is enabled.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is nonzero.</para>
|
|
/// <para>If the function fails, the return value is zero, indicating that an error occurred or another window was already locked.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The purpose of the <c>LockWindowUpdate</c> function is to permit drag/drop feedback to be drawn over a window without
|
|
/// interference from the window itself. The intent is that the window is locked when feedback is drawn and unlocked when feedback is
|
|
/// complete. <c>LockWindowUpdate</c> is not intended for general-purpose suppression of window redraw. Use the WM_SETREDRAW message
|
|
/// to disable redrawing of a particular window.
|
|
/// </para>
|
|
/// <para>
|
|
/// If an application with a locked window (or any locked child windows) calls the GetDC, GetDCEx, or BeginPaint function, the called
|
|
/// function returns a device context with a visible region that is empty. This will occur until the application unlocks the window
|
|
/// by calling <c>LockWindowUpdate</c>, specifying a value of <c>NULL</c> for hWndLock.
|
|
/// </para>
|
|
/// <para>
|
|
/// If an application attempts to draw within a locked window, the system records the extent of the attempted operation in a bounding
|
|
/// rectangle. When the window is unlocked, the system invalidates the area within this bounding rectangle, forcing an eventual
|
|
/// WM_PAINT message to be sent to the previously locked window and its child windows. If no drawing has occurred while the window
|
|
/// updates were locked, no area is invalidated.
|
|
/// </para>
|
|
/// <para><c>LockWindowUpdate</c> does not make the specified window invisible and does not clear the WS_VISIBLE style bit.</para>
|
|
/// <para>A locked window cannot be moved.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-lockwindowupdate BOOL LockWindowUpdate( HWND hWndLock );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "00ec40c7-8ab2-40db-a9bb-48e18d66bf1a")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool LockWindowUpdate(HWND hWndLock);
|
|
|
|
/// <summary>
|
|
/// The <c>PaintDesktop</c> function fills the clipping region in the specified device context with the desktop pattern or wallpaper.
|
|
/// The function is provided primarily for shell desktops.
|
|
/// </summary>
|
|
/// <param name="hdc">Handle to the device context.</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>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-paintdesktop BOOL PaintDesktop( HDC hdc );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "738500d4-32f5-43cf-8d40-9ad201ca6d4b")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool PaintDesktop(HDC hdc);
|
|
|
|
/// <summary>The <c>RedrawWindow</c> function updates the specified rectangle or region in a window's client area.</summary>
|
|
/// <param name="hWnd">A handle to the window to be redrawn. If this parameter is <c>NULL</c>, the desktop window is updated.</param>
|
|
/// <param name="lprcUpdate">
|
|
/// A pointer to a RECT structure containing the coordinates, in device units, of the update rectangle. This parameter is ignored if
|
|
/// the hrgnUpdate parameter identifies a region.
|
|
/// </param>
|
|
/// <param name="hrgnUpdate">
|
|
/// A handle to the update region. If both the hrgnUpdate and lprcUpdate parameters are <c>NULL</c>, the entire client area is added
|
|
/// to the update region.
|
|
/// </param>
|
|
/// <param name="flags">
|
|
/// <para>
|
|
/// One or more redraw flags. This parameter can be used to invalidate or validate a window, control repainting, and control which
|
|
/// windows are affected by <c>RedrawWindow</c>.
|
|
/// </para>
|
|
/// <para>The following flags are used to invalidate the window.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Flag (invalidation)</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>RDW_ERASE</term>
|
|
/// <term>
|
|
/// Causes the window to receive a WM_ERASEBKGND message when the window is repainted. The RDW_INVALIDATE flag must also be
|
|
/// specified; otherwise, RDW_ERASE has no effect.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RDW_FRAME</term>
|
|
/// <term>
|
|
/// Causes any part of the nonclient area of the window that intersects the update region to receive a WM_NCPAINT message. The
|
|
/// RDW_INVALIDATE flag must also be specified; otherwise, RDW_FRAME has no effect. The WM_NCPAINT message is typically not sent
|
|
/// during the execution of RedrawWindow unless either RDW_UPDATENOW or RDW_ERASENOW is specified.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RDW_INTERNALPAINT</term>
|
|
/// <term>Causes a WM_PAINT message to be posted to the window regardless of whether any portion of the window is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RDW_INVALIDATE</term>
|
|
/// <term>Invalidates lprcUpdate or hrgnUpdate (only one may be non-NULL). If both are NULL, the entire window is invalidated.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>The following flags are used to validate the window.</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Flag (validation)</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>RDW_NOERASE</term>
|
|
/// <term>Suppresses any pending WM_ERASEBKGND messages.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RDW_NOFRAME</term>
|
|
/// <term>
|
|
/// Suppresses any pending WM_NCPAINT messages. This flag must be used with RDW_VALIDATE and is typically used with RDW_NOCHILDREN.
|
|
/// RDW_NOFRAME should be used with care, as it could cause parts of a window to be painted improperly.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RDW_NOINTERNALPAINT</term>
|
|
/// <term>
|
|
/// Suppresses any pending internal WM_PAINT messages. This flag does not affect WM_PAINT messages resulting from a non-NULL update area.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RDW_VALIDATE</term>
|
|
/// <term>
|
|
/// Validates lprcUpdate or hrgnUpdate (only one may be non-NULL). If both are NULL, the entire window is validated. This flag does
|
|
/// not affect internal WM_PAINT messages.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>
|
|
/// The following flags control when repainting occurs. <c>RedrawWindow</c> will not repaint unless one of these flags is specified.
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Flag</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>RDW_ERASENOW</term>
|
|
/// <term>
|
|
/// Causes the affected windows (as specified by the RDW_ALLCHILDREN and RDW_NOCHILDREN flags) to receive WM_NCPAINT and
|
|
/// WM_ERASEBKGND messages, if necessary, before the function returns. WM_PAINT messages are received at the ordinary time.
|
|
/// </term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RDW_UPDATENOW</term>
|
|
/// <term>
|
|
/// Causes the affected windows (as specified by the RDW_ALLCHILDREN and RDW_NOCHILDREN flags) to receive WM_NCPAINT, WM_ERASEBKGND,
|
|
/// and WM_PAINT messages, if necessary, before the function returns.
|
|
/// </term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>
|
|
/// By default, the windows affected by <c>RedrawWindow</c> depend on whether the specified window has the WS_CLIPCHILDREN style.
|
|
/// Child windows that are not the WS_CLIPCHILDREN style are unaffected; non-WS_CLIPCHILDREN windows are recursively validated or
|
|
/// invalidated until a WS_CLIPCHILDREN window is encountered. The following flags control which windows are affected by the
|
|
/// <c>RedrawWindow</c> function.
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Flag</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>RDW_ALLCHILDREN</term>
|
|
/// <term>Includes child windows, if any, in the repainting operation.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>RDW_NOCHILDREN</term>
|
|
/// <term>Excludes child windows, if any, from the repainting operation.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </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>
|
|
/// When <c>RedrawWindow</c> is used to invalidate part of the desktop window, the desktop window does not receive a WM_PAINT
|
|
/// message. To repaint the desktop, an application uses the RDW_ERASE flag to generate a WM_ERASEBKGND message.
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-redrawwindow BOOL RedrawWindow( HWND hWnd, const RECT
|
|
// *lprcUpdate, HRGN hrgnUpdate, UINT flags );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "c6cb7f74-237e-4d3e-a852-894da36e990c")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool RedrawWindow(HWND hWnd, [In] PRECT lprcUpdate, HRGN hrgnUpdate, RedrawWindowFlags flags);
|
|
|
|
/// <summary>
|
|
/// The <c>SetWindowRgn</c> function sets the window region of a window. The window region determines the area within the window
|
|
/// where the system permits drawing. The system does not display any portion of a window that lies outside of the window region
|
|
/// </summary>
|
|
/// <param name="hWnd">A handle to the window whose window region is to be set.</param>
|
|
/// <param name="hRgn">
|
|
/// <para>A handle to a region. The function sets the window region of the window to this region.</para>
|
|
/// <para>If hRgn is <c>NULL</c>, the function sets the window region to <c>NULL</c>.</para>
|
|
/// </param>
|
|
/// <param name="bRedraw">
|
|
/// <para>
|
|
/// Specifies whether the system redraws the window after setting the window region. If bRedraw is <c>TRUE</c>, the system does so;
|
|
/// otherwise, it does not.
|
|
/// </para>
|
|
/// <para>Typically, you set bRedraw to <c>TRUE</c> if the window is visible.</para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>If the function succeeds, the return value is nonzero.</para>
|
|
/// <para>If the function fails, the return value is zero.</para>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// When this function is called, the system sends the WM_WINDOWPOSCHANGING and <c>WM_WINDOWPOSCHANGING</c> messages to the window.
|
|
/// </para>
|
|
/// <para>
|
|
/// The coordinates of a window's window region are relative to the upper-left corner of the window, not the client area of the window.
|
|
/// </para>
|
|
/// <para>
|
|
/// <c>Note</c> If the window layout is right-to-left (RTL), the coordinates are relative to the upper-right corner of the window.
|
|
/// See Window Layout and Mirroring.
|
|
/// </para>
|
|
/// <para>
|
|
/// After a successful call to <c>SetWindowRgn</c>, the system owns the region specified by the region handle hRgn. The system does
|
|
/// not make a copy of the region. Thus, you should not make any further function calls with this region handle. In particular, do
|
|
/// not delete this region handle. The system deletes the region handle when it no longer needed.
|
|
/// </para>
|
|
/// <para>To obtain the window region of a window, call the GetWindowRgn function.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-setwindowrgn int SetWindowRgn( HWND hWnd, HRGN hRgn, BOOL
|
|
// bRedraw );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "06209d0c-14f9-45ec-ae2c-9cc596b5bbaa")]
|
|
public static extern int SetWindowRgn(HWND hWnd, HRGN hRgn, [MarshalAs(UnmanagedType.Bool)] bool bRedraw);
|
|
|
|
/// <summary>
|
|
/// The <c>UpdateWindow</c> function updates the client area of the specified window by sending a WM_PAINT message to the window if
|
|
/// the window's update region is not empty. The function sends a <c>WM_PAINT</c> message directly to the window procedure of the
|
|
/// specified window, bypassing the application queue. If the update region is empty, no message is sent.
|
|
/// </summary>
|
|
/// <param name="hWnd">Handle to the window to be updated.</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>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-updatewindow BOOL UpdateWindow( HWND hWnd );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "51a50f1f-7b4d-4acd-83a0-1877f5181766")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool UpdateWindow(HWND hWnd);
|
|
|
|
/// <summary>
|
|
/// The <c>ValidateRect</c> function validates the client area within a rectangle by removing the rectangle from the update region of
|
|
/// the specified window.
|
|
/// </summary>
|
|
/// <param name="hWnd">
|
|
/// Handle to the window whose update region is to be modified. If this parameter is <c>NULL</c>, the system invalidates and redraws
|
|
/// all windows and sends the <c>WM_ERASEBKGND</c> and <c>WM_NCPAINT</c> messages to the window procedure before the function returns.
|
|
/// </param>
|
|
/// <param name="lpRect">
|
|
/// Pointer to a RECT structure that contains the client coordinates of the rectangle to be removed from the update region. If this
|
|
/// parameter is <c>NULL</c>, the entire client area is removed.
|
|
/// </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 BeginPaint function automatically validates the entire client area. Neither the <c>ValidateRect</c> nor ValidateRgn function
|
|
/// should be called if a portion of the update region must be validated before the next WM_PAINT message is generated.
|
|
/// </para>
|
|
/// <para>The system continues to generate WM_PAINT messages until the current update region is validated.</para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-validaterect BOOL ValidateRect( HWND hWnd, const RECT
|
|
// *lpRect );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "961dd768-1849-44df-bc7f-480881ed6477")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool ValidateRect(HWND hWnd, [In] PRECT lpRect);
|
|
|
|
/// <summary>
|
|
/// The <c>ValidateRgn</c> function validates the client area within a region by removing the region from the current update region
|
|
/// of the specified window.
|
|
/// </summary>
|
|
/// <param name="hWnd">Handle to the window whose update region is to be modified.</param>
|
|
/// <param name="hRgn">
|
|
/// Handle to a region that defines the area to be removed from the update region. If this parameter is <c>NULL</c>, the entire
|
|
/// client area is removed.
|
|
/// </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 specified region must have been created by a region function. The region coordinates are assumed to be client coordinates.</para>
|
|
/// <para>
|
|
/// The BeginPaint function automatically validates the entire client area. Neither the ValidateRect nor <c>ValidateRgn</c> function
|
|
/// should be called if a portion of the update region must be validated before the next WM_PAINT message is generated.
|
|
/// </para>
|
|
/// </remarks>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-validatergn BOOL ValidateRgn( HWND hWnd, HRGN hRgn );
|
|
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
|
|
[PInvokeData("winuser.h", MSDNShortId = "80fb1d4a-d9b1-4e67-b585-eee81893ed34")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool ValidateRgn(HWND hWnd, HRGN hRgn);
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// The <c>PAINTSTRUCT</c> structure contains information for an application. This information can be used to paint the client area
|
|
/// of a window owned by that application.
|
|
/// </para>
|
|
/// </summary>
|
|
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/ns-winuser-tagpaintstruct typedef struct tagPAINTSTRUCT { HDC hdc;
|
|
// BOOL fErase; RECT rcPaint; BOOL fRestore; BOOL fIncUpdate; BYTE rgbReserved[32]; } PAINTSTRUCT, *PPAINTSTRUCT, *NPPAINTSTRUCT, *LPPAINTSTRUCT;
|
|
[PInvokeData("winuser.h", MSDNShortId = "1f8c6dd2-e511-48f2-8ab0-d2fadb1ce433")]
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct PAINTSTRUCT
|
|
{
|
|
/// <summary>
|
|
/// <para>A handle to the display DC to be used for painting.</para>
|
|
/// </summary>
|
|
public HDC hdc;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// Indicates whether the background must be erased. This value is nonzero if the application should erase the background. The
|
|
/// application is responsible for erasing the background if a window class is created without a background brush. For more
|
|
/// information, see the description of the <c>hbrBackground</c> member of the WNDCLASS structure.
|
|
/// </para>
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.Bool)]
|
|
public bool fErase;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// A RECT structure that specifies the upper left and lower right corners of the rectangle in which the painting is requested,
|
|
/// in device units relative to the upper-left corner of the client area.
|
|
/// </para>
|
|
/// </summary>
|
|
public RECT rcPaint;
|
|
|
|
/// <summary>
|
|
/// <para>Reserved; used internally by the system.</para>
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.Bool)]
|
|
public bool fRestore;
|
|
|
|
/// <summary>
|
|
/// <para>Reserved; used internally by the system.</para>
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.Bool)]
|
|
public bool fIncUpdate;
|
|
|
|
/// <summary>
|
|
/// <para>Reserved; used internally by the system.</para>
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
|
|
public byte[] rgbReserved;
|
|
}
|
|
}
|
|
} |