using System;
using System.Runtime.InteropServices;
using System.Text;
namespace Vanara.PInvoke
{
public static partial class User32
{
///
/// Application-defined callback function used with the CreateDialog and DialogBox families of functions. It processes
/// messages sent to a modal or modeless dialog box. The DLGPROC type defines a pointer to this callback function. DialogProc
/// is a placeholder for the application-defined function name.
///
///
/// Type: HWND
/// A handle to the dialog box.
///
///
/// Type: UINT
/// The message.
///
///
/// Type: WPARAM
/// Additional message-specific information.
///
///
/// Type: LPARAM
/// Additional message-specific information.
///
///
/// Type: INT_PTR
///
/// Typically, the dialog box procedure should return TRUE if it processed the message, and FALSE if it did not. If the
/// dialog box procedure returns FALSE, the dialog manager performs the default dialog operation in response to the message.
///
///
/// If the dialog box procedure processes a message that requires a specific return value, the dialog box procedure should set the
/// desired return value by calling SetWindowLong(hwndDlg, DWL_MSGRESULT, lResult) immediately before returning
/// TRUE. Note that you must call SetWindowLong immediately before returning TRUE; doing so earlier may result
/// in the DWL_MSGRESULT value being overwritten by a nested dialog box message.
///
///
/// The following messages are exceptions to the general rules stated above. Consult the documentation for the specific message for
/// details on the semantics of the return value.
///
///
// INT_PTR CALLBACK DialogProc( _In_ HWND hwndDlg, _In_ UINT uMsg, _In_ WPARAM wParam, _In_ LPARAM lParam); https://msdn.microsoft.com/en-us/library/windows/desktop/ms645469(v=vs.85).aspx
[UnmanagedFunctionPointer(CallingConvention.Winapi)]
[PInvokeData("Winuser.h", MSDNShortId = "ms645469")]
public delegate IntPtr DialogProc([In] HWND hwndDlg, [In] uint uMsg, [In] IntPtr wParam, [In] IntPtr lParam);
///
/// The following table lists the dialog box styles that you can specify when you create a dialog box. You can use these styles in
/// calls to the CreateWindow and CreateWindowEx functions, in the style member of the DLGTEMPLATE and DLGTEMPLATEEX structures, and
/// in the statement of a dialog box definition in a resource file.
///
[Flags]
public enum DialogBoxStyles : uint
{
///
/// Indicates that the coordinates of the dialog box are screen coordinates. If this style is not specified, the coordinates are
/// client coordinates.
///
DS_ABSALIGN = 0x01,
///
/// This style is obsolete and is included for compatibility with 16-bit versions of Windows. If you specify this style, the
/// system creates the dialog box with the WS_EX_TOPMOST style. This style does not prevent the user from accessing other windows
/// on the desktop. Do not combine this style with the DS_CONTROL style.
///
DS_SYSMODAL = 0x02,
///
/// Applies to 16-bit applications only. This style directs edit controls in the dialog box to allocate memory from the
/// application's data segment. Otherwise, edit controls allocate storage from a global memory object.
///
DS_LOCALEDIT = 0x20,
///
/// Indicates that the header of the dialog box template (either standard or extended) contains additional data specifying the
/// font to use for text in the client area and controls of the dialog box. If possible, the system selects a font according to
/// the specified font data. The system passes a handle to the font to the dialog box and to each control by sending them the
/// WM_SETFONT message. For descriptions of the format of this font data, see DLGTEMPLATE and DLGTEMPLATEEX. If neither
/// DS_SETFONT nor DS_SHELLFONT is specified, the dialog box template does not include the font data.
///
DS_SETFONT = 0x40,
///
/// Creates a dialog box with a modal dialog-box frame that can be combined with a title bar and window menu by specifying the
/// WS_CAPTION and WS_SYSMENU styles.
///
DS_MODALFRAME = 0x80,
///
/// Suppresses WM_ENTERIDLE messages that the system would otherwise send to the owner of the dialog box while the dialog box is displayed.
///
DS_NOIDLEMSG = 0x100,
///
/// Causes the system to use the SetForegroundWindow function to bring the dialog box to the foreground. This style is useful for
/// modal dialog boxes that require immediate attention from the user regardless of whether the owner window is the foreground
/// window. The system restricts which processes can set the foreground window. For more information, see Foreground and
/// Background Windows.
///
DS_SETFOREGROUND = 0x200,
/// Obsolete. The system automatically applies the three-dimensional look to dialog boxes created by applications.
DS_3DLOOK = 0x0004,
///
/// Causes the dialog box to use the SYSTEM_FIXED_FONT instead of the default SYSTEM_FONT. This is a monospace font compatible
/// with the System font in 16-bit versions of Windows earlier than 3.0.
///
DS_FIXEDSYS = 0x0008,
///
/// Creates the dialog box even if errors occur for example, if a child window cannot be created or if the system cannot create a
/// special data segment for an edit control.
///
DS_NOFAILCREATE = 0x0010,
///
/// Creates a dialog box that works well as a child window of another dialog box, much like a page in a property sheet. This
/// style allows the user to tab among the control windows of a child dialog box, use its accelerator keys, and so on.
///
DS_CONTROL = 0x0400,
///
/// Centers the dialog box in the working area of the monitor that contains the owner window. If no owner window is specified,
/// the dialog box is centered in the working area of a monitor determined by the system. The working area is the area not
/// obscured by the taskbar or any appbars.
///
DS_CENTER = 0x0800,
/// Centers the dialog box on the mouse cursor.
DS_CENTERMOUSE = 0x1000,
///
/// Includes a question mark in the title bar of the dialog box. When the user clicks the question mark, the cursor changes to a
/// question mark with a pointer. If the user then clicks a control in the dialog box, the control receives a WM_HELP message.
/// The control should pass the message to the dialog box procedure, which should call the function using the HELP_WM_HELP
/// command. The help application displays a pop-up window that typically contains help for the control. Note that DS_CONTEXTHELP
/// is only a placeholder. When the dialog box is created, the system checks for DS_CONTEXTHELP and, if it is there, adds
/// WS_EX_CONTEXTHELP to the extended style of the dialog box. WS_EX_CONTEXTHELP cannot be used with the WS_MAXIMIZEBOX or
/// WS_MINIMIZEBOX styles.
///
DS_CONTEXTHELP = 0x2000,
///
/// Indicates that the dialog box should use the system font. The typeface member of the extended dialog box template must be set
/// to MS Shell Dlg. Otherwise, this style has no effect. It is also recommended that you use the DIALOGEX Resource, rather than
/// the DIALOG Resource. For more information, see Dialog Box Fonts. The system selects a font using the font data specified in
/// the pointsize, weight, and italic members. The system passes a handle to the font to the dialog box and to each control by
/// sending them the WM_SETFONT message. For descriptions of the format of this font data, see DLGTEMPLATEEX. If neither
/// DS_SHELLFONT nor DS_SETFONT is specified, the extended dialog box template does not include the font data.
///
DS_SHELLFONT = DS_SETFONT | DS_FIXEDSYS,
///
DS_USEPIXELS = 0x8000,
}
///
///
/// Creates a modeless dialog box from a dialog box template resource. The CreateDialog macro uses the CreateDialogParam function.
///
///
///
/// Type: HINSTANCE
///
/// A handle to the module which contains the dialog box template. If this parameter is NULL, then the current executable is used.
///
///
///
/// Type: LPCTSTR
///
/// The dialog box template. This parameter is either the pointer to a null-terminated character string that specifies the name of
/// the dialog box template or an integer value that specifies the resource identifier of the dialog box template. If the parameter
/// specifies a resource identifier, its high-order word must be zero and its low-order word must contain the identifier. You can use
/// the MAKEINTRESOURCE macro to create this value.
///
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// None
///
///
///
/// The CreateDialog function uses the CreateWindowEx function to create the dialog box. CreateDialog then sends a
/// WM_INITDIALOG message (and a WM_SETFONT message if the template specifies the DS_SETFONT or DS_SHELLFONT style) to the
/// dialog box procedure. The function displays the dialog box if the template specifies the WS_VISIBLE style. Finally,
/// CreateDialog returns the window handle to the dialog box.
///
///
/// After CreateDialog returns, the application displays the dialog box (if it is not already displayed) by using the
/// ShowWindow function. The application destroys the dialog box by using the DestroyWindow function. To support keyboard navigation
/// and other dialog box functionality, the message loop for the dialog box must call the IsDialogMessage function.
///
/// Examples
/// For an example, see Creating a Modeless Dialog Box.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-createdialoga void CreateDialogA( hInstance, lpName,
// hWndParent, lpDialogFunc );
[PInvokeData("winuser.h", MSDNShortId = "createdialog")]
public static SafeHWND CreateDialog(HINSTANCE hInstance, string lpName, HWND hWndParent, DialogProc lpDialogFunc) => CreateDialogParam(hInstance, lpName, hWndParent, lpDialogFunc);
///
///
/// Creates a modeless dialog box from a dialog box template in memory. The CreateDialogIndirect macro uses the
/// CreateDialogIndirectParam function.
///
///
///
/// Type: HINSTANCE
/// A handle to the module that creates the dialog box.
///
///
/// Type: LPCDLGTEMPLATE
///
/// A template that CreateDialogIndirect uses to create the dialog box. A dialog box template consists of a header that
/// describes the dialog box, followed by one or more additional blocks of data that describe each of the controls in the dialog box.
/// The template can use either the standard format or the extended format.
///
///
/// In a standard template, the header is a DLGTEMPLATE structure followed by additional variable-length arrays. The data for each
/// control consists of a DLGITEMTEMPLATE structure followed by additional variable-length arrays.
///
///
/// In an extended dialog box template, the header uses the DLGTEMPLATEEX format and the control definitions use the
/// DLGITEMTEMPLATEEX format.
///
/// After CreateDialogIndirect returns, you can free the template, which is only used to get the dialog box started.
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// None
///
///
///
/// The CreateDialogIndirect macro uses the CreateWindowEx function to create the dialog box. CreateDialogIndirect then
/// sends a WM_INITDIALOG message to the dialog box procedure. If the template specifies the DS_SETFONT or DS_SHELLFONT style, the
/// function also sends a WM_SETFONT message to the dialog box procedure. The function displays the dialog box if the template
/// specifies the WS_VISIBLE style. Finally, CreateDialogIndirect returns the window handle to the dialog box.
///
///
/// After CreateDialogIndirect returns, you can use the ShowWindow function to display the dialog box (if it is not already
/// visible). To destroy the dialog box, use the DestroyWindow function. To support keyboard navigation and other dialog box
/// functionality, the message loop for the dialog box must call the IsDialogMessage function.
///
///
/// In a standard dialog box template, the DLGTEMPLATE structure and each of the DLGITEMTEMPLATE structures must be aligned on
/// DWORD boundaries. The creation data array that follows a DLGITEMTEMPLATE structure must also be aligned on a
/// DWORD boundary. All of the other variable-length arrays in the template must be aligned on WORD boundaries.
///
///
/// In an extended dialog box template, the DLGTEMPLATEEX header and each of the DLGITEMTEMPLATEEX control definitions must be
/// aligned on DWORD boundaries. The creation data array, if any, that follows a DLGITEMTEMPLATEEX structure must also
/// be aligned on a DWORD boundary. All of the other variable-length arrays in the template must be aligned on WORD boundaries.
///
///
/// All character strings in the dialog box template, such as titles for the dialog box and buttons, must be Unicode strings. Use the
/// MultiByteToWideChar function to generate Unicode strings from ANSI strings.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-createdialogindirecta void CreateDialogIndirectA(
// hInstance, lpTemplate, hWndParent, lpDialogFunc );
[PInvokeData("winuser.h", MSDNShortId = "createdialogindirect")]
public static SafeHWND CreateDialogIndirect(HINSTANCE hInstance, IntPtr lpTemplate, HWND hWndParent, DialogProc lpDialogFunc) => CreateDialogIndirectParam(hInstance, lpTemplate, hWndParent, lpDialogFunc);
///
///
/// Creates a modeless dialog box from a dialog box template in memory. Before displaying the dialog box, the function passes an
/// application-defined value to the dialog box procedure as the lParam parameter of the WM_INITDIALOG message. An application can
/// use this value to initialize dialog box controls.
///
///
///
/// Type: HINSTANCE
///
/// A handle to the module which contains the dialog box template. If this parameter is NULL, then the current executable is used.
///
///
///
/// Type: LPCDLGTEMPLATE
///
/// The template CreateDialogIndirectParam uses to create the dialog box. A dialog box template consists of a header that
/// describes the dialog box, followed by one or more additional blocks of data that describe each of the controls in the dialog box.
/// The template can use either the standard format or the extended format.
///
///
/// In a standard template, the header is a DLGTEMPLATE structure followed by additional variable-length arrays. The data for each
/// control consists of a DLGITEMTEMPLATE structure followed by additional variable-length arrays.
///
///
/// In an extended dialog box template, the header uses the DLGTEMPLATEEX format and the control definitions use the
/// DLGITEMTEMPLATEEX format.
///
/// After CreateDialogIndirectParam returns, you can free the template, which is only used to get the dialog box started.
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// Type: LPARAM
/// The value to pass to the dialog box in the lParam parameter of the WM_INITDIALOG message.
///
///
/// Type: HWND
/// If the function succeeds, the return value is the window handle to the dialog box.
/// If the function fails, the return value is NULL. To get extended error information, call GetLastError.
///
///
///
/// The CreateDialogIndirectParam function uses the CreateWindowEx function to create the dialog box.
/// CreateDialogIndirectParam then sends a WM_INITDIALOG message to the dialog box procedure. If the template specifies the
/// DS_SETFONT or DS_SHELLFONT style, the function also sends a WM_SETFONT message to the dialog box procedure. The function displays
/// the dialog box if the template specifies the WS_VISIBLE style. Finally, CreateDialogIndirectParam returns the
/// window handle to the dialog box.
///
///
/// After CreateDialogIndirectParam returns, you can use the ShowWindow function to display the dialog box (if it is not
/// already visible). To destroy the dialog box, use the DestroyWindow function. To support keyboard navigation and other dialog box
/// functionality, the message loop for the dialog box must call the IsDialogMessage function.
///
///
/// In a standard dialog box template, the DLGTEMPLATE structure and each of the DLGITEMTEMPLATE structures must be aligned on
/// DWORD boundaries. The creation data array that follows a DLGITEMTEMPLATE structure must also be aligned on a
/// DWORD boundary. All of the other variable-length arrays in the template must be aligned on WORD boundaries.
///
///
/// In an extended dialog box template, the DLGTEMPLATEEX header and each of the DLGITEMTEMPLATEEX control definitions must be
/// aligned on DWORD boundaries. The creation data array, if any, that follows a DLGITEMTEMPLATEEX structure must also
/// be aligned on a DWORD boundary. All of the other variable-length arrays in the template must be aligned on WORD boundaries.
///
/// All character strings in the dialog box template, such as titles for the dialog box and buttons, must be Unicode strings.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-createdialogindirectparama HWND
// CreateDialogIndirectParamA( HINSTANCE hInstance, LPCDLGTEMPLATEA lpTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM
// dwInitParam );
[DllImport(Lib.User32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "createdialogindirectparam")]
public static extern SafeHWND CreateDialogIndirectParam(HINSTANCE hInstance, IntPtr lpTemplate, HWND hWndParent, DialogProc lpDialogFunc, [Optional] IntPtr dwInitParam);
///
///
/// Creates a modeless dialog box from a dialog box template resource. Before displaying the dialog box, the function passes an
/// application-defined value to the dialog box procedure as the lParam parameter of the WM_INITDIALOG message. An application can
/// use this value to initialize dialog box controls.
///
///
///
/// Type: HINSTANCE
///
/// A handle to the module which contains the dialog box template. If this parameter is NULL, then the current executable is used.
///
///
///
/// Type: LPCTSTR
///
/// The dialog box template. This parameter is either the pointer to a null-terminated character string that specifies the name of
/// the dialog box template or an integer value that specifies the resource identifier of the dialog box template. If the parameter
/// specifies a resource identifier, its high-order word must be zero and low-order word must contain the identifier. You can use the
/// MAKEINTRESOURCE macro to create this value.
///
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// Type: LPARAM
/// The value to be passed to the dialog box procedure in the lParam parameter in the WM_INITDIALOG message.
///
///
/// Type: HWND
/// If the function succeeds, the return value is the window handle to the dialog box.
/// If the function fails, the return value is NULL. To get extended error information, call GetLastError.
///
///
///
/// The CreateDialogParam function uses the CreateWindowEx function to create the dialog box. CreateDialogParam then
/// sends a WM_INITDIALOG message (and a WM_SETFONT message if the template specifies the DS_SETFONT or DS_SHELLFONT style) to the
/// dialog box procedure. The function displays the dialog box if the template specifies the WS_VISIBLE style. Finally,
/// CreateDialogParam returns the window handle of the dialog box.
///
///
/// After CreateDialogParam returns, the application displays the dialog box (if it is not already displayed) using the
/// ShowWindow function. The application destroys the dialog box by using the DestroyWindow function. To support keyboard navigation
/// and other dialog box functionality, the message loop for the dialog box must call the IsDialogMessage function.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-createdialogparama HWND CreateDialogParamA( HINSTANCE
// hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam );
[DllImport(Lib.User32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "createdialogparam")]
public static extern SafeHWND CreateDialogParam(HINSTANCE hInstance, string lpTemplateName, HWND hWndParent, DialogProc lpDialogFunc, [Optional] IntPtr dwInitParam);
///
///
/// Calls the default dialog box window procedure to provide default processing for any window messages that a dialog box with a
/// private window class does not process.
///
///
///
/// Type: HWND
/// A handle to the dialog box.
///
///
/// Type: UINT
/// The message.
///
///
/// Type: WPARAM
/// Additional message-specific information.
///
///
/// Type: LPARAM
/// Additional message-specific information.
///
///
/// Type: LRESULT
/// The return value specifies the result of the message processing and depends on the message sent.
///
///
///
/// The DefDlgProc function is the window procedure for the predefined class of dialog box. This procedure provides internal
/// processing for the dialog box by forwarding messages to the dialog box procedure and carrying out default processing for any
/// messages that the dialog box procedure returns as FALSE. Applications that create custom window procedures for their
/// custom dialog boxes often use DefDlgProc instead of the DefWindowProc function to carry out default message processing.
///
///
/// Applications create custom dialog box classes by filling a WNDCLASS structure with appropriate information and registering the
/// class with the RegisterClass function. Some applications fill the structure by using the GetClassInfo function, specifying the
/// name of the predefined dialog box. In such cases, the applications modify at least the lpszClassName member before
/// registering. In all cases, the cbWndExtra member of WNDCLASS for a custom dialog box class must be set to at least DLGWINDOWEXTRA.
///
/// The DefDlgProc function must not be called by a dialog box procedure; doing so results in recursive execution.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-defdlgprocw LRESULT LRESULT DefDlgProcW( HWND hDlg, UINT
// Msg, WPARAM wParam, LPARAM lParam );
[DllImport(Lib.User32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "defdlgproc")]
public static extern IntPtr DefDlgProc(HWND hDlg, uint Msg, IntPtr wParam, IntPtr lParam);
///
///
/// Creates a modal dialog box from a dialog box template resource. DialogBox does not return control until the specified
/// callback function terminates the modal dialog box by calling the EndDialog function.
///
/// DialogBox is implemented as a call to the DialogBoxParam function.
///
///
/// Type: HINSTANCE
///
/// A handle to the module which contains the dialog box template. If this parameter is NULL, then the current executable is used.
///
///
///
/// Type: LPCTSTR
///
/// The dialog box template. This parameter is either the pointer to a null-terminated character string that specifies the name of
/// the dialog box template or an integer value that specifies the resource identifier of the dialog box template. If the parameter
/// specifies a resource identifier, its high-order word must be zero and its low-order word must contain the identifier. You can use
/// the MAKEINTRESOURCE macro to create this value.
///
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// None
///
///
///
/// The DialogBox macro uses the CreateWindowEx function to create the dialog box. DialogBox then sends a WM_INITDIALOG
/// message (and a WM_SETFONT message if the template specifies the DS_SETFONT or DS_SHELLFONT style) to the dialog box procedure.
/// The function displays the dialog box (regardless of whether the template specifies the WS_VISIBLE style), disables the
/// owner window, and starts its own message loop to retrieve and dispatch messages for the dialog box.
///
///
/// When the dialog box procedure calls the EndDialog function, DialogBox destroys the dialog box, ends the message loop,
/// enables the owner window (if previously enabled), and returns the nResult parameter specified by the dialog box procedure when it
/// called EndDialog.
///
/// Examples
/// For an example, see Creating a Modal Dialog Box.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-dialogboxa void DialogBoxA( hInstance, lpTemplate,
// hWndParent, lpDialogFunc );
[PInvokeData("winuser.h", MSDNShortId = "dialogbox")]
public static IntPtr DialogBox(HINSTANCE hInstance, string lpTemplate, HWND hWndParent, DialogProc lpDialogFunc) => DialogBoxParam(hInstance, lpTemplate, hWndParent, lpDialogFunc);
///
///
/// Creates a modal dialog box from a dialog box template resource. DialogBox does not return control until the specified
/// callback function terminates the modal dialog box by calling the EndDialog function.
///
/// DialogBox is implemented as a call to the DialogBoxParam function.
///
///
/// Type: HINSTANCE
///
/// A handle to the module which contains the dialog box template. If this parameter is NULL, then the current executable is used.
///
///
///
/// Type: LPCTSTR
///
/// The dialog box template. This parameter is either the pointer to a null-terminated character string that specifies the name of
/// the dialog box template or an integer value that specifies the resource identifier of the dialog box template. If the parameter
/// specifies a resource identifier, its high-order word must be zero and its low-order word must contain the identifier. You can
/// use the MAKEINTRESOURCE macro to create this value.
///
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// None
///
///
///
/// The DialogBox macro uses the CreateWindowEx function to create the dialog box. DialogBox then sends a
/// WM_INITDIALOG message (and a WM_SETFONT message if the template specifies the DS_SETFONT or DS_SHELLFONT style) to the dialog
/// box procedure. The function displays the dialog box (regardless of whether the template specifies the WS_VISIBLE style),
/// disables the owner window, and starts its own message loop to retrieve and dispatch messages for the dialog box.
///
///
/// When the dialog box procedure calls the EndDialog function, DialogBox destroys the dialog box, ends the message loop,
/// enables the owner window (if previously enabled), and returns the nResult parameter specified by the dialog box procedure when
/// it called EndDialog.
///
/// Examples
/// For an example, see Creating a Modal Dialog Box.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-dialogboxa void DialogBoxA( hInstance, lpTemplate,
// hWndParent, lpDialogFunc );
[PInvokeData("winuser.h", MSDNShortId = "dialogbox")]
public static IntPtr DialogBox(HINSTANCE hInstance, ResourceId lpTemplate, HWND hWndParent, DialogProc lpDialogFunc) => DialogBoxParam(hInstance, lpTemplate, hWndParent, lpDialogFunc);
///
///
/// Creates a modal dialog box from a dialog box template in memory. DialogBoxIndirect does not return control until the
/// specified callback function terminates the modal dialog box by calling the EndDialog function.
///
/// DialogBoxIndirect is implemented as a call to the DialogBoxIndirectParam function.
///
///
/// Type: HINSTANCE
/// A handle to the module that creates the dialog box.
///
///
/// Type: LPCDLGTEMPLATE
///
/// The template that DialogBoxIndirect uses to create the dialog box. A dialog box template consists of a header that
/// describes the dialog box, followed by one or more additional blocks of data that describe each of the controls in the dialog box.
/// The template can use either the standard format or the extended format.
///
///
/// In a standard template for a dialog box, the header is a DLGTEMPLATE structure followed by additional variable-length arrays. The
/// data for each control consists of a DLGITEMTEMPLATE structure followed by additional variable-length arrays.
///
///
/// In an extended template for a dialog box, the header uses the DLGTEMPLATEEX format and the control definitions use the
/// DLGITEMTEMPLATEEX format.
///
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// None
///
///
///
/// The DialogBoxIndirect macro uses the CreateWindowEx function to create the dialog box. DialogBoxIndirect then sends
/// a WM_INITDIALOG message to the dialog box procedure. If the template specifies the DS_SETFONT or DS_SHELLFONT style, the function
/// also sends a WM_SETFONT message to the dialog box procedure. The function displays the dialog box (regardless of whether the
/// template specifies the WS_VISIBLE style), disables the owner window, and starts its own message loop to retrieve and
/// dispatch messages for the dialog box.
///
///
/// When the dialog box procedure calls the EndDialog function, DialogBoxIndirect destroys the dialog box, ends the message
/// loop, enables the owner window (if previously enabled), and returns the nResult parameter specified by the dialog box procedure
/// when it called EndDialog.
///
///
/// In a standard dialog box template, the DLGTEMPLATE structure and each of the DLGITEMTEMPLATE structures must be aligned on
/// DWORD boundaries. The creation data array that follows a DLGITEMTEMPLATE structure must also be aligned on a
/// DWORD boundary. All of the other variable-length arrays in the template must be aligned on WORD boundaries.
///
///
/// In an extended dialog box template, the DLGTEMPLATEEX header and each of the DLGITEMTEMPLATEEX control definitions must be
/// aligned on DWORD boundaries. The creation data array, if any, that follows a DLGITEMTEMPLATEEX structure must also
/// be aligned on a DWORD boundary. All of the other variable-length arrays in the template must be aligned on WORD boundaries.
///
///
/// All character strings in the dialog box template, such as titles for the dialog box and buttons, must be Unicode strings. Use the
/// MultiByteToWideChar function to generate Unicode strings from ANSI strings.
///
/// Examples
/// For an example, see Creating a Template in Memory.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-dialogboxindirecta void DialogBoxIndirectA( hInstance,
// lpTemplate, hWndParent, lpDialogFunc );
[PInvokeData("winuser.h", MSDNShortId = "dialogboxindirect")]
public static IntPtr DialogBoxIndirect(HINSTANCE hInstance, IntPtr lpTemplate, HWND hWndParent, DialogProc lpDialogFunc) => DialogBoxIndirectParam(hInstance, lpTemplate, hWndParent, lpDialogFunc);
///
///
/// Creates a modal dialog box from a dialog box template in memory. Before displaying the dialog box, the function passes an
/// application-defined value to the dialog box procedure as the lParam parameter of the WM_INITDIALOG message. An application can
/// use this value to initialize dialog box controls.
///
///
///
/// Type: HINSTANCE
/// A handle to the module that creates the dialog box.
///
///
/// Type: LPCDLGTEMPLATE
///
/// The template that DialogBoxIndirectParam uses to create the dialog box. A dialog box template consists of a header that
/// describes the dialog box, followed by one or more additional blocks of data that describe each of the controls in the dialog box.
/// The template can use either the standard format or the extended format.
///
///
/// In a standard template for a dialog box, the header is a DLGTEMPLATE structure followed by additional variable-length arrays. The
/// data for each control consists of a DLGITEMTEMPLATE structure followed by additional variable-length arrays.
///
///
/// In an extended template for a dialog box, the header uses the DLGTEMPLATEEX format and the control definitions use the
/// DLGITEMTEMPLATEEX format.
///
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// Type: LPARAM
/// The value to pass to the dialog box in the lParam parameter of the WM_INITDIALOG message.
///
///
/// Type: INT_PTR
///
/// If the function succeeds, the return value is the nResult parameter specified in the call to the EndDialog function that was used
/// to terminate the dialog box.
///
///
/// If the function fails because the hWndParent parameter is invalid, the return value is zero. The function returns zero in this
/// case for compatibility with previous versions of Windows. If the function fails for any other reason, the return value is –1. To
/// get extended error information, call GetLastError.
///
///
///
///
/// The DialogBoxIndirectParam function uses the CreateWindowEx function to create the dialog box.
/// DialogBoxIndirectParam then sends a WM_INITDIALOG message to the dialog box procedure. If the template specifies the
/// DS_SETFONT or DS_SHELLFONT style, the function also sends a WM_SETFONT message to the dialog box procedure. The function displays
/// the dialog box (regardless of whether the template specifies the WS_VISIBLE style), disables the owner window, and starts
/// its own message loop to retrieve and dispatch messages for the dialog box.
///
///
/// When the dialog box procedure calls the EndDialog function, DialogBoxIndirectParam destroys the dialog box, ends the
/// message loop, enables the owner window (if previously enabled), and returns the nResult parameter specified by the dialog box
/// procedure when it called EndDialog.
///
///
/// In a standard dialog box template, the DLGTEMPLATE structure and each of the DLGITEMTEMPLATE structures must be aligned on
/// DWORD boundaries. The creation data array that follows a DLGITEMTEMPLATE structure must also be aligned on a
/// DWORD boundary. All of the other variable-length arrays in the template must be aligned on WORD boundaries.
///
///
/// In an extended dialog box template, the DLGTEMPLATEEX header and each of the DLGITEMTEMPLATEEX control definitions must be
/// aligned on DWORD boundaries. The creation data array, if any, that follows a DLGITEMTEMPLATEEX structure must also
/// be aligned on a DWORD boundary. All of the other variable-length arrays in the template must be aligned on WORD boundaries.
///
/// All character strings in the dialog box template, such as titles for the dialog box and buttons, must be Unicode strings.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-dialogboxindirectparama INT_PTR DialogBoxIndirectParamA(
// HINSTANCE hInstance, LPCDLGTEMPLATEA hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam );
[DllImport(Lib.User32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "dialogboxindirectparam")]
public static extern IntPtr DialogBoxIndirectParam(HINSTANCE hInstance, IntPtr hDialogTemplate, HWND hWndParent, DialogProc lpDialogFunc, [Optional] IntPtr dwInitParam);
///
///
/// Creates a modal dialog box from a dialog box template resource. Before displaying the dialog box, the function passes an
/// application-defined value to the dialog box procedure as the lParam parameter of the WM_INITDIALOG message. An application can
/// use this value to initialize dialog box controls.
///
///
///
/// Type: HINSTANCE
///
/// A handle to the module which contains the dialog box template. If this parameter is NULL, then the current executable is used.
///
///
///
/// Type: LPCTSTR
///
/// The dialog box template. This parameter is either the pointer to a null-terminated character string that specifies the name of
/// the dialog box template or an integer value that specifies the resource identifier of the dialog box template. If the parameter
/// specifies a resource identifier, its high-order word must be zero and its low-order word must contain the identifier. You can use
/// the MAKEINTRESOURCE macro to create this value.
///
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// Type: LPARAM
/// The value to pass to the dialog box in the lParam parameter of the WM_INITDIALOG message.
///
///
/// Type: INT_PTR
///
/// If the function succeeds, the return value is the value of the nResult parameter specified in the call to the EndDialog function
/// used to terminate the dialog box.
///
///
/// If the function fails because the hWndParent parameter is invalid, the return value is zero. The function returns zero in this
/// case for compatibility with previous versions of Windows. If the function fails for any other reason, the return value is –1. To
/// get extended error information, call GetLastError.
///
///
///
///
/// The DialogBoxParam function uses the CreateWindowEx function to create the dialog box. DialogBoxParam then sends a
/// WM_INITDIALOG message (and a WM_SETFONT message if the template specifies the DS_SETFONT or DS_SHELLFONT style) to the dialog box
/// procedure. The function displays the dialog box (regardless of whether the template specifies the WS_VISIBLE style),
/// disables the owner window, and starts its own message loop to retrieve and dispatch messages for the dialog box.
///
///
/// When the dialog box procedure calls the EndDialog function, DialogBoxParam destroys the dialog box, ends the message loop,
/// enables the owner window (if previously enabled), and returns the nResult parameter specified by the dialog box procedure when it
/// called EndDialog.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-dialogboxparama INT_PTR DialogBoxParamA( HINSTANCE
// hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam );
[DllImport(Lib.User32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "dialogboxparam")]
public static extern IntPtr DialogBoxParam(HINSTANCE hInstance, string lpTemplateName, HWND hWndParent, DialogProc lpDialogFunc, [Optional] IntPtr dwInitParam);
///
///
/// Creates a modal dialog box from a dialog box template resource. Before displaying the dialog box, the function passes an
/// application-defined value to the dialog box procedure as the lParam parameter of the WM_INITDIALOG message. An application can
/// use this value to initialize dialog box controls.
///
///
///
/// Type: HINSTANCE
///
/// A handle to the module which contains the dialog box template. If this parameter is NULL, then the current executable is used.
///
///
///
/// Type: LPCTSTR
///
/// The dialog box template. This parameter is either the pointer to a null-terminated character string that specifies the name of
/// the dialog box template or an integer value that specifies the resource identifier of the dialog box template. If the parameter
/// specifies a resource identifier, its high-order word must be zero and its low-order word must contain the identifier. You can use
/// the MAKEINTRESOURCE macro to create this value.
///
///
///
/// Type: HWND
/// A handle to the window that owns the dialog box.
///
///
/// Type: DLGPROC
/// A pointer to the dialog box procedure. For more information about the dialog box procedure, see DialogProc.
///
///
/// Type: LPARAM
/// The value to pass to the dialog box in the lParam parameter of the WM_INITDIALOG message.
///
///
/// Type: INT_PTR
///
/// If the function succeeds, the return value is the value of the nResult parameter specified in the call to the EndDialog function
/// used to terminate the dialog box.
///
///
/// If the function fails because the hWndParent parameter is invalid, the return value is zero. The function returns zero in this
/// case for compatibility with previous versions of Windows. If the function fails for any other reason, the return value is –1. To
/// get extended error information, call GetLastError.
///
///
///
///
/// The DialogBoxParam function uses the CreateWindowEx function to create the dialog box. DialogBoxParam then sends a
/// WM_INITDIALOG message (and a WM_SETFONT message if the template specifies the DS_SETFONT or DS_SHELLFONT style) to the dialog box
/// procedure. The function displays the dialog box (regardless of whether the template specifies the WS_VISIBLE style),
/// disables the owner window, and starts its own message loop to retrieve and dispatch messages for the dialog box.
///
///
/// When the dialog box procedure calls the EndDialog function, DialogBoxParam destroys the dialog box, ends the message loop,
/// enables the owner window (if previously enabled), and returns the nResult parameter specified by the dialog box procedure when it
/// called EndDialog.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-dialogboxparama INT_PTR DialogBoxParamA( HINSTANCE
// hInstance, LPCSTR lpTemplateName, HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam );
[DllImport(Lib.User32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "dialogboxparam")]
public static extern IntPtr DialogBoxParam(HINSTANCE hInstance, ResourceId lpTemplateName, HWND hWndParent, DialogProc lpDialogFunc, [Optional] IntPtr dwInitParam);
///
/// Retrieves the current selection from a combo box filled by using the DlgDirListComboBox function. The selection is interpreted as
/// a drive letter, a file, or a directory name.
///
///
/// Type: HWND
/// A handle to the dialog box that contains the combo box.
///
///
/// Type: LPTSTR
/// A pointer to the buffer that receives the selected path.
///
///
/// Type: int
/// The length, in characters, of the buffer pointed to by the lpString parameter.
///
///
/// Type: int
/// The integer identifier of the combo box control in the dialog box.
///
///
/// Type: BOOL
/// If the current selection is a directory name, the return value is nonzero.
/// If the current selection is not a directory name, the return value is zero. To get extended error information, call GetLastError.
///
///
///
/// If the current selection specifies a directory name or drive letter, the DlgDirSelectComboBoxEx function removes the
/// enclosing square brackets (and hyphens for drive letters) so the name or letter is ready to be inserted into a new path or file
/// name. If there is no selection, the contents of the buffer pointed to by lpString do not change.
///
/// The DlgDirSelectComboBoxEx function does not allow more than one file name to be returned from a combo box.
/// If the string is as long or longer than the buffer, the buffer contains the truncated string with a terminating null character.
/// DlgDirSelectComboBoxEx sends CB_GETCURSEL and CB_GETLBTEXT messages to the combo box.
/// You can use this function with all three types of combo boxes (CBS_SIMPLE, CBS_DROPDOWN, and CBS_DROPDOWNLIST).
///
/// Security Warning: Improper use of this function can cause problems for your application. For instance, the nCount
/// parameter should be set properly for both ANSI and Unicode versions. Failure to do so could lead to a buffer overflow. You should
/// review Security Considerations: Microsoft Windows Controls before continuing.
///
///
/// Windows 95 or later: DlgDirSelectComboBoxExW is supported by the Microsoft Layer for Unicode (MSLU). To use this,
/// you must add certain files to your application, as outlined in Microsoft Layer for Unicode on Windows Me/98/95 Systems.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-dlgdirselectcomboboxexa BOOL DlgDirSelectComboBoxExA( HWND
// hwndDlg, LPSTR lpString, int cchOut, int idComboBox );
[DllImport(Lib.User32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool DlgDirSelectComboBoxEx(HWND hwndDlg, StringBuilder lpString, int cchOut, int idComboBox);
///
/// Destroys a modal dialog box, causing the system to end any processing for the dialog box.
///
///
/// Type: HWND
/// A handle to the dialog box to be destroyed.
///
///
/// Type: INT_PTR
/// The value to be returned to the application from the function that created the dialog box.
///
///
/// Type: BOOL
/// If the function succeeds, the return value is nonzero.
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
///
///
///
/// Dialog boxes created by the DialogBox, DialogBoxParam, DialogBoxIndirect, and DialogBoxIndirectParam functions must be destroyed
/// using the EndDialog function. An application calls EndDialog from within the dialog box procedure; the function
/// must not be used for any other purpose.
///
///
/// A dialog box procedure can call EndDialog at any time, even during the processing of the WM_INITDIALOG message. If your
/// application calls the function while WM_INITDIALOG is being processed, the dialog box is destroyed before it is shown and
/// before the input focus is set.
///
///
/// EndDialog does not destroy the dialog box immediately. Instead, it sets a flag and allows the dialog box procedure to
/// return control to the system. The system checks the flag before attempting to retrieve the next message from the application
/// queue. If the flag is set, the system ends the message loop, destroys the dialog box, and uses the value in nResult as the return
/// value from the function that created the dialog box.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-enddialog BOOL EndDialog( HWND hDlg, INT_PTR nResult );
[DllImport(Lib.User32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "enddialog")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool EndDialog(HWND hDlg, IntPtr nResult);
///
///
/// Retrieves the system's dialog base units, which are the average width and height of characters in the system font. For dialog
/// boxes that use the system font, you can use these values to convert between dialog template units, as specified in dialog box
/// templates, and pixels. For dialog boxes that do not use the system font, the conversion from dialog template units to pixels
/// depends on the font used by the dialog box.
///
///
/// For either type of dialog box, it is easier to use the MapDialogRect function to perform the conversion. MapDialogRect
/// takes the font into account and correctly converts a rectangle from dialog template units into pixels.
///
///
///
/// Type: LONG
///
/// The function returns the dialog base units. The low-order word of the return value contains the horizontal dialog box base unit,
/// and the high-order word contains the vertical dialog box base unit.
///
///
///
///
/// The horizontal base unit returned by GetDialogBaseUnits is equal to the average width, in pixels, of the characters in the
/// system font; the vertical base unit is equal to the height, in pixels, of the font.
///
///
/// The system font is used only if the dialog box template fails to specify a font. Most dialog box templates specify a font; as a
/// result, this function is not useful for most dialog boxes.
///
///
/// For a dialog box that does not use the system font, the base units are the average width and height, in pixels, of the characters
/// in the dialog's font. You can use the GetTextMetrics and GetTextExtentPoint32 functions to calculate these values for a selected
/// font. However, by using the MapDialogRect function, you can avoid errors that might result if your calculations differ from those
/// performed by the system.
///
///
/// Each horizontal base unit is equal to 4 horizontal dialog template units; each vertical base unit is equal to 8 vertical dialog
/// template units. Therefore, to convert dialog template units to pixels, use the following formulas:
///
/// Similarly, to convert from pixels to dialog template units, use the following formulas:
/// Examples
/// For an example, see "Creating a Combo Box Toolbar" in Using Combo Boxes.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getdialogbaseunits long GetDialogBaseUnits( );
[DllImport(Lib.User32, SetLastError = false, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "getdialogbaseunits")]
public static extern long GetDialogBaseUnits();
///
/// Retrieves the identifier of the specified control.
///
///
/// Type: HWND
/// A handle to the control.
///
///
/// Type: int
/// If the function succeeds, the return value is the identifier of the control.
///
/// If the function fails, the return value is zero. An invalid value for the hwndCtl parameter, for example, will cause the function
/// to fail. To get extended error information, call GetLastError.
///
///
///
///
/// GetDlgCtrlID accepts child window handles as well as handles of controls in dialog boxes. An application sets the
/// identifier for a child window when it creates the window by assigning the identifier value to the hmenu parameter when calling
/// the CreateWindow or CreateWindowEx function.
///
///
/// Although GetDlgCtrlID may return a value if hwndCtl is a handle to a top-level window, top-level windows cannot have
/// identifiers and such a return value is never valid.
///
/// Examples
/// For an example, see Initializing a Dialog Box.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getdlgctrlid int GetDlgCtrlID( HWND hWnd );
[DllImport(Lib.User32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "getdlgctrlid")]
public static extern int GetDlgCtrlID(HWND hWnd);
///
/// Retrieves a handle to a control in the specified dialog box.
///
///
/// Type: HWND
/// A handle to the dialog box that contains the control.
///
///
/// Type: int
/// The identifier of the control to be retrieved.
///
///
/// Type: HWND
/// If the function succeeds, the return value is the window handle of the specified control.
///
/// If the function fails, the return value is NULL, indicating an invalid dialog box handle or a nonexistent control. To get
/// extended error information, call GetLastError.
///
///
///
///
/// You can use the GetDlgItem function with any parent-child window pair, not just with dialog boxes. As long as the hDlg
/// parameter specifies a parent window and the child window has a unique identifier (as specified by the hMenu parameter in the
/// CreateWindow or CreateWindowEx function that created the child window), GetDlgItem returns a valid handle to the child window.
///
/// Examples
/// For an example, see Initializing a Dialog Box.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getdlgitem HWND GetDlgItem( HWND hDlg, int nIDDlgItem );
[DllImport(Lib.User32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "getdlgitem")]
public static extern HWND GetDlgItem(HWND hDlg, int nIDDlgItem);
///
/// Translates the text of a specified control in a dialog box into an integer value.
///
///
/// Type: HWND
/// A handle to the dialog box that contains the control of interest.
///
///
/// Type: int
/// The identifier of the control whose text is to be translated.
///
///
/// Type: BOOL*
/// Indicates success or failure ( TRUE indicates success, FALSE indicates failure).
/// If this parameter is NULL, the function returns no information about success or failure.
///
///
/// Type: BOOL
///
/// Indicates whether the function should examine the text for a minus sign at the beginning and return a signed integer value if it
/// finds one ( TRUE specifies this should be done, FALSE that it should not).
///
///
///
/// Type: UINT
///
/// If the function succeeds, the variable pointed to by lpTranslated is set to TRUE, and the return value is the translated
/// value of the control text.
///
///
/// If the function fails, the variable pointed to by lpTranslated is set to FALSE, and the return value is zero. Note that,
/// because zero is a possible translated value, a return value of zero does not by itself indicate failure.
///
/// If lpTranslated is NULL, the function returns no information about success or failure.
///
/// Note that, if the bSigned parameter is TRUE and there is a minus sign (–) at the beginning of the text,
/// GetDlgItemInt translates the text into a signed integer value. Otherwise, the function creates an unsigned integer value.
/// To obtain the proper value in this case, cast the return value to an int type.
///
/// To get extended error information, call GetLastError.
///
///
///
/// The GetDlgItemInt function retrieves the text of the specified control by sending the control a WM_GETTEXT message. The
/// function translates the retrieved text by stripping any extra spaces at the beginning of the text and then converting the decimal
/// digits. The function stops translating when it reaches the end of the text or encounters a nonnumeric character.
///
///
/// The GetDlgItemInt function returns zero if the translated value is greater than INT_MAX (for signed numbers) or
/// UINT_MAX (for unsigned numbers).
///
/// Examples
/// For an example, see Creating a Modeless Dialog Box.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getdlgitemint UINT GetDlgItemInt( HWND hDlg, int
// nIDDlgItem, BOOL *lpTranslated, BOOL bSigned );
[DllImport(Lib.User32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "getdlgitemint")]
public static extern uint GetDlgItemInt(HWND hDlg, int nIDDlgItem, [MarshalAs(UnmanagedType.Bool)] out bool lpTranslated, [MarshalAs(UnmanagedType.Bool)] bool bSigned);
///
/// Retrieves the title or text associated with a control in a dialog box.
///
///
/// Type: HWND
/// A handle to the dialog box that contains the control.
///
///
/// Type: int
/// The identifier of the control whose title or text is to be retrieved.
///
///
/// Type: LPTSTR
/// The buffer to receive the title or text.
///
///
/// Type: int
///
/// The maximum length, in characters, of the string to be copied to the buffer pointed to by lpString. If the length of the string,
/// including the null character, exceeds the limit, the string is truncated.
///
///
///
/// Type: UINT
///
/// If the function succeeds, the return value specifies the number of characters copied to the buffer, not including the terminating
/// null character.
///
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
///
///
///
/// If the string is as long or longer than the buffer, the buffer will contain the truncated string with a terminating null character.
///
/// The GetDlgItemText function sends a WM_GETTEXT message to the control.
/// Examples
/// For an example, see Creating a Modal Dialog Box.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getdlgitemtexta UINT GetDlgItemTextA( HWND hDlg, int
// nIDDlgItem, LPSTR lpString, int cchMax );
[DllImport(Lib.User32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "getdlgitemtext")]
public static extern uint GetDlgItemText(HWND hDlg, int nIDDlgItem, StringBuilder lpString, int cchMax);
///
///
/// Retrieves a handle to the first control in a group of controls that precedes (or follows) the specified control in a dialog box.
///
///
///
/// Type: HWND
/// A handle to the dialog box to be searched.
///
///
/// Type: HWND
///
/// A handle to the control to be used as the starting point for the search. If this parameter is NULL, the function uses the
/// last (or first) control in the dialog box as the starting point for the search.
///
///
///
/// Type: BOOL
///
/// Indicates how the function is to search the group of controls in the dialog box. If this parameter is TRUE, the function
/// searches for the previous control in the group. If it is FALSE, the function searches for the next control in the group.
///
///
///
/// Type: HWND
/// If the function succeeds, the return value is a handle to the previous (or next) control in the group of controls.
/// If the function fails, the return value is NULL. To get extended error information, call GetLastError.
///
///
///
/// The GetNextDlgGroupItem function searches controls in the order (or reverse order) they were created in the dialog box
/// template. The first control in the group must have the WS_GROUP style; all other controls in the group must have been
/// consecutively created and must not have the WS_GROUP style.
///
///
/// When searching for the previous control, the function returns the first control it locates that is visible and not disabled. If
/// the control specified by hCtl has the WS_GROUP style, the function temporarily reverses the search to locate the first
/// control having the WS_GROUP style, then resumes the search in the original direction, returning the first control it
/// locates that is visible and not disabled, or returning hCtl if no such control is found.
///
///
/// When searching for the next control, the function returns the first control it locates that is visible, not disabled, and does
/// not have the WS_GROUP style. If it encounters a control having the WS_GROUP style, the function reverses the
/// search, locates the first control having the WS_GROUP style, and returns this control if it is visible and not disabled.
/// Otherwise, the function resumes the search in the original direction and returns the first control it locates that is visible and
/// not disabled, or returns hCtl if no such control is found.
///
///
/// If the search for the next control in the group encounters a window with the WS_EX_CONTROLPARENT style, the system
/// recursively searches the window's children.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getnextdlggroupitem HWND GetNextDlgGroupItem( HWND hDlg,
// HWND hCtl, BOOL bPrevious );
[DllImport(Lib.User32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "getnextdlggroupitem")]
public static extern HWND GetNextDlgGroupItem(HWND hDlg, HWND hCtl, [MarshalAs(UnmanagedType.Bool)] bool bPrevious);
///
/// Retrieves a handle to the first control that has the WS_TABSTOP style that precedes (or follows) the specified control.
///
///
/// Type: HWND
/// A handle to the dialog box to be searched.
///
///
/// Type: HWND
///
/// A handle to the control to be used as the starting point for the search. If this parameter is NULL, the function fails.
///
///
///
/// Type: BOOL
///
/// Indicates how the function is to search the dialog box. If this parameter is TRUE, the function searches for the previous
/// control in the dialog box. If this parameter is FALSE, the function searches for the next control in the dialog box.
///
///
///
/// Type: HWND
///
/// If the function succeeds, the return value is the window handle of the previous (or next) control that has the WS_TABSTOP style set.
///
/// If the function fails, the return value is NULL. To get extended error information, call GetLastError.
///
///
///
/// The GetNextDlgTabItem function searches controls in the order (or reverse order) they were created in the dialog box
/// template. The function returns the first control it locates that is visible, not disabled, and has the WS_TABSTOP style. If no
/// such control exists, the function returns hCtl.
///
///
/// If the search for the next control with the WS_TABSTOP style encounters a window with the WS_EX_CONTROLPARENT
/// style, the system recursively searches the window's children.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-getnextdlgtabitem HWND GetNextDlgTabItem( HWND hDlg, HWND
// hCtl, BOOL bPrevious );
[DllImport(Lib.User32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "getnextdlgtabitem")]
public static extern HWND GetNextDlgTabItem(HWND hDlg, HWND hCtl, [MarshalAs(UnmanagedType.Bool)] bool bPrevious);
///
/// Determines whether a message is intended for the specified dialog box and, if it is, processes the message.
///
///
/// Type: HWND
/// A handle to the dialog box.
///
///
/// Type: LPMSG
/// A pointer to an MSG structure that contains the message to be checked.
///
///
/// Type: BOOL
/// If the message has been processed, the return value is nonzero.
/// If the message has not been processed, the return value is zero.
///
///
///
/// Although the IsDialogMessage function is intended for modeless dialog boxes, you can use it with any window that contains
/// controls, enabling the windows to provide the same keyboard selection as is used in a dialog box.
///
///
/// When IsDialogMessage processes a message, it checks for keyboard messages and converts them into selections for the
/// corresponding dialog box. For example, the TAB key, when pressed, selects the next control or group of controls, and the DOWN
/// ARROW key, when pressed, selects the next control in a group.
///
///
/// Because the IsDialogMessage function performs all necessary translating and dispatching of messages, a message processed
/// by IsDialogMessage must not be passed to the TranslateMessage or DispatchMessage function.
///
/// IsDialogMessage sends WM_GETDLGCODE messages to the dialog box procedure to determine which keys should be processed.
///
/// IsDialogMessage can send DM_GETDEFID and DM_SETDEFID messages to the window. These messages are defined in the Winuser.h
/// header file as WM_USER and WM_USER + 1, so conflicts are possible with application-defined messages having the same values.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-isdialogmessagea BOOL IsDialogMessageA( HWND hDlg, LPMSG
// lpMsg );
[DllImport(Lib.User32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "isdialogmessage")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool IsDialogMessage(HWND hDlg, in MSG lpMsg);
///
///
/// Converts the specified dialog box units to screen units (pixels). The function replaces the coordinates in the specified RECT
/// structure with the converted coordinates, which allows the structure to be used to create a dialog box or position a control
/// within a dialog box.
///
///
///
/// Type: HWND
///
/// A handle to a dialog box. This function accepts only handles returned by one of the dialog box creation functions; handles for
/// other windows are not valid.
///
///
///
/// Type: LPRECT
/// A pointer to a RECT structure that contains the dialog box coordinates to be converted.
///
///
/// Type: BOOL
/// If the function succeeds, the return value is nonzero.
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
///
///
///
/// The MapDialogRect function assumes that the initial coordinates in the RECT structure represent dialog box units. To
/// convert these coordinates from dialog box units to pixels, the function retrieves the current horizontal and vertical base units
/// for the dialog box, then applies the following formulas:
///
///
/// If the dialog box template has the DS_SETFONT or DS_SHELLFONT style, the base units are the average width and height, in
/// pixels, of the characters in the font specified by the template.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-mapdialogrect BOOL MapDialogRect( HWND hDlg, LPRECT lpRect );
[DllImport(Lib.User32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "mapdialogrect")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool MapDialogRect(HWND hDlg, in RECT lpRect);
///
/// Sends a message to the specified control in a dialog box.
///
///
/// Type: HWND
/// A handle to the dialog box that contains the control.
///
///
/// Type: int
/// The identifier of the control that receives the message.
///
///
/// Type: UINT
/// The message to be sent.
/// For lists of the system-provided messages, see System-Defined Messages.
///
///
/// Type: WPARAM
/// Additional message-specific information.
///
///
/// Type: LPARAM
/// Additional message-specific information.
///
///
/// Type: LRESULT
/// The return value specifies the result of the message processing and depends on the message sent.
///
///
/// The SendDlgItemMessage function does not return until the message has been processed.
///
/// Using SendDlgItemMessage is identical to retrieving a handle to the specified control and calling the SendMessage function.
///
/// Examples
/// For an example, see Creating a Modeless Dialog Box.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-senddlgitemmessagea LRESULT SendDlgItemMessageA( HWND
// hDlg, int nIDDlgItem, UINT Msg, WPARAM wParam, LPARAM lParam );
[DllImport(Lib.User32, SetLastError = false, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "senddlgitemmessage")]
public static extern IntPtr SendDlgItemMessage(HWND hDlg, int nIDDlgItem, uint Msg, IntPtr wParam, IntPtr lParam);
///
/// Sets the text of a control in a dialog box to the string representation of a specified integer value.
///
///
/// Type: HWND
/// A handle to the dialog box that contains the control.
///
///
/// Type: int
/// The control to be changed.
///
///
/// Type: UINT
/// The integer value used to generate the item text.
///
///
/// Type: BOOL
///
/// Indicates whether the uValue parameter is signed or unsigned. If this parameter is TRUE, uValue is signed. If this
/// parameter is TRUE and uValue is less than zero, a minus sign is placed before the first digit in the string. If this
/// parameter is FALSE, uValue is unsigned.
///
///
///
/// Type: BOOL
/// If the function succeeds, the return value is nonzero.
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
///
///
/// To set the new text, this function sends a WM_SETTEXT message to the specified control.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-setdlgitemint BOOL SetDlgItemInt( HWND hDlg, int
// nIDDlgItem, UINT uValue, BOOL bSigned );
[DllImport(Lib.User32, SetLastError = true, ExactSpelling = true)]
[PInvokeData("winuser.h", MSDNShortId = "setdlgitemint")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDlgItemInt(HWND hDlg, int nIDDlgItem, uint uValue, [MarshalAs(UnmanagedType.Bool)] bool bSigned);
///
/// Sets the title or text of a control in a dialog box.
///
///
/// Type: HWND
/// A handle to the dialog box that contains the control.
///
///
/// Type: int
/// The control with a title or text to be set.
///
///
/// Type: LPCTSTR
/// The text to be copied to the control.
///
///
/// Type: BOOL
/// If the function succeeds, the return value is nonzero.
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
///
///
/// The SetDlgItemText function sends a WM_SETTEXT message to the specified control.
/// Examples
/// For an example, see Using List Boxes.
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-setdlgitemtexta BOOL SetDlgItemTextA( HWND hDlg, int
// nIDDlgItem, LPCSTR lpString );
[DllImport(Lib.User32, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("winuser.h", MSDNShortId = "setdlgitemtext")]
[return: MarshalAs(UnmanagedType.Bool)]
public static extern bool SetDlgItemText(HWND hDlg, int nIDDlgItem, string lpString);
///
///
/// Defines the dimensions and style of a control in a dialog box. One or more of these structures are combined with a DLGTEMPLATE
/// structure to form a standard template for a dialog box.
///
///
///
///
/// In a standard template for a dialog box, the DLGITEMTEMPLATE structure is always immediately followed by three
/// variable-length arrays specifying the class, title, and creation data for the control. Each array consists of one or more 16-bit elements.
///
///
/// Each DLGITEMTEMPLATE structure in the template must be aligned on a DWORD boundary. The class and title arrays must
/// be aligned on WORD boundaries. The creation data array must be aligned on a WORD boundary.
///
///
/// Immediately following each DLGITEMTEMPLATE structure is a class array that specifies the window class of the control. If
/// the first element of this array is any value other than 0xFFFF, the system treats the array as a null-terminated Unicode string
/// that specifies the name of a registered window class. If the first element is 0xFFFF, the array has one additional element that
/// specifies the ordinal value of a predefined system class. The ordinal can be one of the following atom values.
///
///
///
/// Value
/// Meaning
///
/// -
/// 0x0080
/// Button
///
/// -
/// 0x0081
/// Edit
///
/// -
/// 0x0082
/// Static
///
/// -
/// 0x0083
/// List box
///
/// -
/// 0x0084
/// Scroll bar
///
/// -
/// 0x0085
/// Combo box
///
///
///
/// Following the class array is a title array that contains the initial text or resource identifier of the control. If the first
/// element of this array is 0xFFFF, the array has one additional element that specifies an ordinal value of a resource, such as an
/// icon, in an executable file. You can use a resource identifier for controls, such as static icon controls, that load and display
/// an icon or other resource rather than text. If the first element is any value other than 0xFFFF, the system treats the array as a
/// null-terminated Unicode string that specifies the initial text.
///
///
/// The creation data array begins at the next WORD boundary after the title array. This creation data can be of any size and
/// format. If the first word of the creation data array is nonzero, it indicates the size, in bytes, of the creation data (including
/// the size word). The control's window procedure must be able to interpret the data. When the system creates the control, it passes
/// a pointer to this data in the lParam parameter of the WM_CREATE message that it sends to the control.
///
///
/// If you specify character strings in the class and title arrays, you must use Unicode strings. Use the MultiByteToWideChar
/// function to generate Unicode strings from ANSI strings.
///
///
/// The x, y, cx, and cy members specify values in dialog box units. You can convert these values to
/// screen units (pixels) by using the MapDialogRect function.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/ns-winuser-dlgitemtemplate typedef struct DLGITEMTEMPLATE { DWORD
// style; DWORD dwExtendedStyle; short x; short y; short cx; short cy; WORD id; };
[PInvokeData("winuser.h", MSDNShortId = "dlgitemtemplate")]
[StructLayout(LayoutKind.Sequential, Pack = 4)]
public struct DLGITEMTEMPLATE
{
///
/// Type: DWORD
///
/// The style of the control. This member can be a combination of window style values (such as WS_BORDER) and one or more
/// of the control style values (such as BS_PUSHBUTTON and ES_LEFT).
///
///
public uint style;
///
/// Type: DWORD
///
/// The extended styles for a window. This member is not used to create controls in dialog boxes, but applications that use
/// dialog box templates can use it to create other types of windows. For a list of values, see Extended Window Styles.
///
///
public uint dwExtendedStyle;
///
/// Type: short
///
/// The x-coordinate, in dialog box units, of the upper-left corner of the control. This coordinate is always relative to the
/// upper-left corner of the dialog box's client area.
///
///
public short x;
///
/// Type: short
///
/// The y-coordinate, in dialog box units, of the upper-left corner of the control. This coordinate is always relative to the
/// upper-left corner of the dialog box's client area.
///
///
public short y;
///
/// Type: short
/// The width, in dialog box units, of the control.
///
public short cx;
///
/// Type: short
/// The height, in dialog box units, of the control.
///
public short cy;
///
/// Type: WORD
/// The control identifier.
///
public ushort id;
}
///
///
/// Defines the dimensions and style of a dialog box. This structure, always the first in a standard template for a dialog box, also
/// specifies the number of controls in the dialog box and therefore specifies the number of subsequent DLGITEMTEMPLATE structures in
/// the template.
///
///
///
///
/// In a standard template for a dialog box, the DLGTEMPLATE structure is always immediately followed by three variable-length
/// arrays that specify the menu, class, and title for the dialog box. When the DS_SETFONT style is specified, these arrays are also
/// followed by a 16-bit value specifying point size and another variable-length array specifying a typeface name. Each array
/// consists of one or more 16-bit elements. The menu, class, title, and font arrays must be aligned on WORD boundaries.
///
///
/// Immediately following the DLGTEMPLATE structure is a menu array that identifies a menu resource for the dialog box. If the
/// first element of this array is 0x0000, the dialog box has no menu and the array has no other elements. If the first element is
/// 0xFFFF, the array has one additional element that specifies the ordinal value of a menu resource in an executable file. If the
/// first element has any other value, the system treats the array as a null-terminated Unicode string that specifies the name of a
/// menu resource in an executable file.
///
///
/// Following the menu array is a class array that identifies the window class of the control. If the first element of the array is
/// 0x0000, the system uses the predefined dialog box class for the dialog box and the array has no other elements. If the first
/// element is 0xFFFF, the array has one additional element that specifies the ordinal value of a predefined system window class. If
/// the first element has any other value, the system treats the array as a null-terminated Unicode string that specifies the name of
/// a registered window class.
///
///
/// Following the class array is a title array that specifies a null-terminated Unicode string that contains the title of the dialog
/// box. If the first element of this array is 0x0000, the dialog box has no title and the array has no other elements.
///
///
/// The 16-bit point size value and the typeface array follow the title array, but only if the style member specifies the
/// DS_SETFONT style. The point size value specifies the point size of the font to use for the text in the dialog box and its
/// controls. The typeface array is a null-terminated Unicode string specifying the name of the typeface for the font. When these
/// values are specified, the system creates a font having the specified size and typeface (if possible) and sends a WM_SETFONT
/// message to the dialog box procedure and the control window procedures as it creates the dialog box and controls.
///
///
/// Following the DLGTEMPLATE header in a standard dialog box template are one or more DLGITEMTEMPLATE structures that define
/// the dimensions and style of the controls in the dialog box. The cdit member specifies the number of DLGITEMTEMPLATE
/// structures in the template. These DLGITEMTEMPLATE structures must be aligned on DWORD boundaries.
///
/// If you specify character strings in the menu, class, title, or typeface arrays, you must use Unicode strings.
///
/// The x, y, cx, and cy members specify values in dialog box units. You can convert these values to
/// screen units (pixels) by using the MapDialogRect function.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/api/winuser/ns-winuser-dlgtemplate typedef struct DLGTEMPLATE { DWORD style;
// DWORD dwExtendedStyle; WORD cdit; short x; short y; short cx; short cy; };
[PInvokeData("winuser.h", MSDNShortId = "dlgtemplate")]
[StructLayout(LayoutKind.Sequential, Pack = 4)]
public struct DLGTEMPLATE
{
///
/// Type: DWORD
///
/// The style of the dialog box. This member can be a combination of window style values (such as WS_CAPTION and
/// WS_SYSMENU) and dialog box style values (such as DS_CENTER).
///
///
/// If the style member includes the DS_SETFONT style, the header of the dialog box template contains additional data
/// specifying the font to use for text in the client area and controls of the dialog box. The font data begins on the
/// WORD boundary that follows the title array. The font data specifies a 16-bit point size value and a Unicode font name
/// string. If possible, the system creates a font according to the specified values. Then the system sends a WM_SETFONT message
/// to the dialog box and to each control to provide a handle to the font. If DS_SETFONT is not specified, the dialog box
/// template does not include the font data.
///
/// The DS_SHELLFONT style is not supported in the DLGTEMPLATE header.
///
public uint style;
///
/// Type: DWORD
///
/// The extended styles for a window. This member is not used to create dialog boxes, but applications that use dialog box
/// templates can use it to create other types of windows. For a list of values, see Extended Window Styles.
///
///
public uint dwExtendedStyle;
///
/// Type: WORD
/// The number of items in the dialog box.
///
public ushort cdit;
///
/// Type: short
/// The x-coordinate, in dialog box units, of the upper-left corner of the dialog box.
///
public short x;
///
/// Type: short
/// The y-coordinate, in dialog box units, of the upper-left corner of the dialog box.
///
public short y;
///
/// Type: short
/// The width, in dialog box units, of the dialog box.
///
public short cx;
///
/// Type: short
/// The height, in dialog box units, of the dialog box.
///
public short cy;
}
/*
///
///
/// An extended dialog box template begins with a DLGTEMPLATEEX header that describes the dialog box and specifies the number
/// of controls in the dialog box. For each control in a dialog box, an extended dialog box template has a block of data that uses
/// the DLGITEMTEMPLATEEX format to describe the control.
///
///
/// The DLGTEMPLATEEX structure is not defined in any standard header file. The structure definition is provided here to
/// explain the format of an extended template for a dialog box.
///
///
///
///
/// You can use an extended dialog box template instead of a standard dialog box template in the CreateDialogIndirectParam,
/// DialogBoxIndirectParam, CreateDialogIndirect, and DialogBoxIndirect functions.
///
///
/// Following the DLGTEMPLATEEX header in an extended dialog box template is one or more DLGITEMTEMPLATEEX structures
/// that describe the controls of the dialog box. The cDlgItems member of the DLGITEMTEMPLATEEX structure specifies the
/// number of DLGITEMTEMPLATEEX structures that follow in the template.
///
///
/// Each DLGITEMTEMPLATEEX structure in the template must be aligned on a DWORD boundary. If the style member
/// specifies the DS_SETFONT or DS_SHELLFONT style, the first DLGITEMTEMPLATEEX structure begins on the first
/// DWORD boundary after the typeface string. If these styles are not specified, the first structure begins on the
/// first DWORD boundary after the title string.
///
/// The menu, windowClass, title, and typeface arrays must be aligned on WORD boundaries.
///
/// If you specify character strings in the menu, windowClass, title, and typeface arrays, you must use
/// Unicode strings. Use the MultiByteToWideChar function to generate these Unicode strings from ANSI strings.
///
///
/// The x, y, cx, and cy members specify values in dialog box units. You can convert these values to
/// screen units (pixels) by using the MapDialogRect function.
///
///
// https://docs.microsoft.com/en-us/windows/desktop/dlgbox/dlgtemplateex typedef struct { WORD dlgVer; WORD signature; DWORD helpID;
// DWORD exStyle; DWORD style; WORD cDlgItems; short x; short y; short cx; short cy; sz_Or_Ord menu; sz_Or_Ord windowClass; WCHAR
// title[titleLen]; WORD pointsize; WORD weight; BYTE italic; BYTE charset; WCHAR typeface[stringLen]; } DLGTEMPLATEEX;
[PInvokeData("", MSDNShortId = "9f016cc6-56e2-45d3-8773-1b405fc10d29")]
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public struct DLGTEMPLATEEX
{
/// The version number of the extended dialog box template. This member must be set to 1.
public ushort dlgVer;
///
/// Indicates whether a template is an extended dialog box template. If signature is 0xFFFF, this is an extended dialog box
/// template. In this case, the dlgVer member specifies the template version number. If signature is any value other than 0xFFFF,
/// this is a standard dialog box template that uses the DLGTEMPLATE and DLGITEMTEMPLATE structures.
///
public ushort signature;
///
/// The help context identifier for the dialog box window. When the system sends a WM_HELP message, it passes this value in the
/// wContextId member of the HELPINFO structure.
///
public uint helpID;
///
/// The extended windows styles. This member is not used when creating dialog boxes, but applications that use dialog box
/// templates can use it to create other types of windows. For a list of values, see Extended Window Styles.
///
public WindowStylesEx exStyle;
///
/// The style of the dialog box. This member can be a combination of window style values and dialog box style values.
///
/// If style includes the DS_SETFONT or DS_SHELLFONT dialog box style, the DLGTEMPLATEEX header of the extended dialog box
/// template contains four additional members(pointsize, weight, italic, and typeface) that describe the font to use for the text
/// in the client area and controls of the dialog box.If possible, the system creates a font according to the values specified in
/// these members.Then the system sends a WM_SETFONT message to the dialog box and to each control to provide a handle to the font.
///
/// For more information, see Dialog Box Fonts.
///
public WindowStyles style;
/// The number of controls in the dialog box.
public ushort cDlgItems;
/// The x-coordinate, in dialog box units, of the upper-left corner of the dialog box.
public short x;
/// The y-coordinate, in dialog box units, of the upper-left corner of the dialog box.
public short y;
/// The width, in dialog box units, of the dialog box.
public short cx;
/// The height, in dialog box units, of the dialog box.
public short cy;
///
/// A variable-length array of 16-bit elements that identifies a menu resource for the dialog box. If the first element of this
/// array is 0x0000, the dialog box has no menu and the array has no other elements. If the first element is 0xFFFF, the array
/// has one additional element that specifies the ordinal value of a menu resource in an executable file. If the first element
/// has any other value, the system treats the array as a null-terminated Unicode string that specifies the name of a menu
/// resource in an executable file.
///
public IntPtr menu;
///
/// A variable-length array of 16-bit elements that identifies the window class of the dialog box. If the first element of the
/// array is 0x0000, the system uses the predefined dialog box class for the dialog box and the array has no other elements. If
/// the first element is 0xFFFF, the array has one additional element that specifies the ordinal value of a predefined system
/// window class. If the first element has any other value, the system treats the array as a null-terminated Unicode string that
/// specifies the name of a registered window class.
///
public IntPtr windowClass;
///
/// The title of the dialog box. If the first element of this array is 0x0000, the dialog box has no title and the array has no
/// other elements.
///
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = titleLen)]
public string title;
///
/// The point size of the font to use for the text in the dialog box and its controls.
/// This member is present only if the style member specifies DS_SETFONT or DS_SHELLFONT.
///
public ushort pointsize;
///
/// The weight of the font. Note that, although this can be any of the values listed for the lfWeight member of the LOGFONT
/// structure, any value that is used will be automatically changed to FW_NORMAL.
/// This member is present only if the style member specifies DS_SETFONT or DS_SHELLFONT.
///
public ushort weight;
///
/// Indicates whether the font is italic. If this value is TRUE, the font is italic.
/// This member is present only if the style member specifies DS_SETFONT or DS_SHELLFONT.
///
public byte italic;
///
/// The character set to be used. For more information, see the lfcharset member of LOGFONT.
/// This member is present only if the style member specifies DS_SETFONT or DS_SHELLFONT.
///
public byte charset;
///
/// The name of the typeface for the font.
/// This member is present only if the style member specifies DS_SETFONT or DS_SHELLFONT.
///
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = stringLen)]
public string typeface;
}
*/
}
}