YourPhoneAppProxy App Used to shutdown app and call Current.Shutdown at the end to avoid any time limits when closing the app Exit reason If should call Application.Shutdown after cleanup. Default value is true. Task Called by the UI Thread and takes precedence over CurrentDomain_UnhandledException For background threads unhandled exceptions InitializeComponent Application Entry Point. Adding an image preview image to drag drop, depending on isMultiple and file extension Adding an image preview when dealing with multiple images dataObject telemetryFactory Add an image preview form extension (when dealing with a single file) dataObject extension including dot ex: ".jpg" telemetryFactory Set the actual shadow into the dataObject bitmap dataObject telemetryFactory Sets the drop description for the drag image manager. The DataObject to set. The type of the drop image. The format string for the description. The parameter for the drop description. When setting the drop description, the text can be set in two part, which will be rendered slightly differently to distinguish the description from the subject. For example, the format can be set as "Move to %1" and the insert as "Temp". When rendered, the "%1" in format will be replaced with "Temp", but "Temp" will be rendered slightly different from "Move to ". Sets the drop description for the drag image manager. The DataObject to set. The drop description. Gets the DropDescription format data. The DataObject. The DropDescription, if set. Fills a FORMATETC structure. The format name. The accepted TYMED. The structure to fill. Get icon index from extension name extension with dot ex: ".jpg" telemetryFactory Icon index Get an icon formIImage IImage telemetryFactory 256*256 icon Showing the drop description or not, (not yet supported) bool Boolean from a stream stream in case bool value If the image is showing layered When invalidating the drag image dataObject formatec showingLayered Invalidate the image medium dataObject Creates a copy of the STGMEDIUM structure. The data to copy. The copied data. Get the pointer from medium medium IntPtr Gets the extension name from a path list of file names ".multiple" if dealing with multiple files, else the extension Returns true iff the HRESULT is a success code. HRESULT to check. True if a success code. Drag-drop operation canceled Class implementing drag/drop and clipboard support for virtual files. Also offers an alternate interface to the IDataObject interface. Error Ole Advise Not Supported Invalid tymed Invalid FORMATETC structure Invalid aspect(s) Drag Use the default cursor Drag-drop operation canceled Successful drop took place Gets or sets a value indicating whether the data object can be used asynchronously. Identifier for CFSTR_FILECONTENTS. Identifier for CFSTR_FILEDESCRIPTORW. Identifier for CFSTR_PASTESUCCEEDED. Identifier for CFSTR_PERFORMEDDROPEFFECT. Identifier for CFSTR_PREFERREDDROPEFFECT. In-order list of registered data objects. Tracks whether an asynchronous operation is ongoing. Stores the user-specified start action. Stores the user-specified end action. Console debug print helper Initializes a new instance of the class. Initializes a new instance of the class. Optional action to run at the start of the data transfer. Optional action to run at the end of the data transfer. Helper. Creates a connection between a data object and an advisory sink. A FORMATETC structure that defines the format, target device, aspect, and medium that will be used for future notifications. One of the ADVF values that specifies a group of flags for controlling the advisory connection. A pointer to the IAdviseSink interface on the advisory sink that will receive the change notification. When this method returns, contains a pointer to a DWORD token that identifies this connection. HRESULT success code. Destroys a notification connection that had been previously established. A DWORD token that specifies the connection to remove. Creates an object that can be used to enumerate the current advisory connections. When this method returns, contains an IEnumSTATDATA that receives the interface pointer to the new enumerator object. HRESULT success code. Creates an object for enumerating the FORMATETC structures for a data object. One of the DATADIR values that specifies the direction of the data. IEnumFORMATETC interface. Provides a standard FORMATETC structure that is logically equivalent to a more complex structure. A pointer to a FORMATETC structure that defines the format, medium, and target device that the caller would like to use to retrieve data in a subsequent call such as GetData. When this method returns, contains a pointer to a FORMATETC structure that contains the most general information possible for a specific rendering, making it canonically equivalent to formatetIn. HRESULT success code. Obtains data from a source data object. A pointer to a FORMATETC structure that defines the format, medium, and target device to use when passing the data. When this method returns, contains a pointer to the STGMEDIUM structure that indicates the storage medium containing the returned data through its tymed member, and the responsibility for releasing the medium through the value of its pUnkForRelease member. Obtains data from a source data object. A pointer to a FORMATETC structure that defines the format, medium, and target device to use when passing the data. A STGMEDIUM that defines the storage medium containing the data being transferred. Determines whether the data object is capable of rendering the data described in the FORMATETC structure. A pointer to a FORMATETC structure that defines the format, medium, and target device to use for the query. HRESULT success code. Transfers data to the object that implements this method. A FORMATETC structure that defines the format used by the data object when interpreting the data contained in the storage medium. A STGMEDIUM structure that defines the storage medium in which the data is being passed. true to specify that the data object called, which implements SetData, owns the storage medium after the call returns. Provides data for the specified data format (HGLOBAL). Data format. Sequence of data. Provides data for the specified data format and index (ISTREAM). Data format. Index of data. Action generating the data. Uses Stream instead of IEnumerable(T) because Stream is more likely to be natural for the expected scenarios. SetData for objects that don't require delayed rendering data format should we release medium The pair. Provides data for the specified data format (FILEGROUPDESCRIPTOR/FILEDESCRIPTOR) Collection of virtual files. Gets or sets the CFSTR_PASTESUCCEEDED value for the object. Gets or sets the CFSTR_PERFORMEDDROPEFFECT value for the object. Gets or sets the CFSTR_PREFERREDDROPEFFECT value for the object. Gets the DragDropEffects value (if any) previously set on the object. Clipboard format. DragDropEffects value or null. Called by a drop source to specify whether the data object supports asynchronous data extraction. A Boolean value that is set to VARIANT_TRUE to indicate that an asynchronous operation is supported, or VARIANT_FALSE otherwise. Called by a drop target to determine whether the data object supports asynchronous data extraction. A Boolean value that is set to VARIANT_TRUE to indicate that an asynchronous operation is supported, or VARIANT_FALSE otherwise. Called by a drop target to indicate that asynchronous data extraction is starting. Reserved. Set this value to NULL. Called by the drop source to determine whether the target is extracting data asynchronously. Set to VARIANT_TRUE if data extraction is being handled asynchronously, or VARIANT_FALSE otherwise. Notifies the data object that that asynchronous data extraction has ended. An HRESULT value that indicates the outcome of the data extraction. Set to S_OK if successful, or a COM error code otherwise. Reserved. Set to NULL. A DROPEFFECT value that indicates the result of an optimized move. This should be the same value that would be passed to the data object as a CFSTR_PERFORMEDDROPEFFECT format with a normal data extraction operation. Returns true iff the HRESULT is a success code. HRESULT to check. True iff a success code. Returns the in-memory representation of an interop structure. Structure to return. In-memory representation of structure. Class representing a virtual file for use by drag/drop or the clipboard. Gets or sets the name of the file. Gets or sets the (optional) length of the file. Gets or sets the (optional) change time of the file. Gets or sets an Action that returns the contents of the file. Class representing the result of writting the Stream Class representing the result of a SetData call. FORMATETC structure for the data. Func returning the data as an IntPtr and an HRESULT success code. Explecit Medium, when ignoring delayed rendering Should we release medium Represents a 2-tuple, or pair. Minimal implementation of the .NET 4 Tuple class; remove if running on .NET 4. The type of the tuple's first component. The type of the tuple's second component. Gets the value of the current Tuple(T1, T2) object's first component. Gets the value of the current Tuple(T1, T2) object's second component. Initializes a new instance of the class. Initializes a new instance of the Tuple(T1, T2) class. The value of the tuple's first component. The value of the tuple's second component. Simple class that exposes a write-only IStream as a Stream. IStream instance being wrapped. Initializes a new instance of the class. IStream instance to wrap. Gets a value indicating whether the current stream supports reading. Gets a value indicating whether the current stream supports seeking. Gets a value indicating whether the current stream supports writing. Clears all buffers for this stream and causes any buffered data to be written to the underlying device. Gets the length in bytes of the stream. Gets or sets the position within the current stream. Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. An array of bytes. When this method returns, the buffer contains the specified byte array with the values between offset and (offset + count - 1) replaced by the bytes read from the current source. The zero-based byte offset in buffer at which to begin storing the data read from the current stream. The maximum number of bytes to be read from the current stream. The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached. Sets the position within the current stream. A byte offset relative to the origin parameter. A value of type SeekOrigin indicating the reference point used to obtain the new position. The new position within the current stream. Sets the length of the current stream. The desired length of the current stream in bytes. Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. An array of bytes. This method copies count bytes from buffer to the current stream. The zero-based byte offset in buffer at which to begin copying bytes to the current stream. The number of bytes to be written to the current stream. Initiates a drag-and-drop operation. A reference to the dependency object that is the source of the data being dragged. A data object that contains the data being dragged. One of the DragDropEffects values that specifies permitted effects of the drag-and-drop operation. telemetryFactory debugPrinterHelper One of the DragDropEffects values that specifies the final effect that was performed during the drag-and-drop operation. Call this method instead of System.Windows.DragDrop.DoDragDrop because this method handles IDataObject better. Contains the methods for generating visual feedback to the end user and for canceling or completing the drag-and-drop operation. Determines whether a drag-and-drop operation should continue. Indicates whether the Esc key has been pressed since the previous call to QueryContinueDrag or to DoDragDrop if this is the first call to QueryContinueDrag. A TRUE value indicates the end user has pressed the escape key; a FALSE value indicates it has not been pressed. The current state of the keyboard modifier keys on the keyboard. Possible values can be a combination of any of the flags MK_CONTROL, MK_SHIFT, MK_ALT, MK_BUTTON, MK_LBUTTON, MK_MBUTTON, and MK_RBUTTON. This method returns S_OK/DRAGDROP_S_DROP/DRAGDROP_S_CANCEL on success. Gives visual feedback to an end user during a drag-and-drop operation. The DROPEFFECT value returned by the most recent call to IDropTarget::DragEnter, IDropTarget::DragOver, or IDropTarget::DragLeave. This method returns S_OK on success. Indicates if the mouse is being pressed during drag and drop. This is checked when dragging over some windows that request data on drag over. Gets a set of keys that trigger the isExtended flag Try to get a PointerEventArgs Current window properties wParam from WndProc WindowMessages out pointerEventArgs success/failure Known Keyboards that do not have the AltGr key Gets the first free index in the map int Tries to retrieve the fingerId associated with the Pointer Id Pointer Id out fingerId result success / failure Tries to remove the fingerId from the finger map PointerId out fingerId removed success / failure Definition of the IAsyncOperation COM interface. Pseudo-public because VirtualFileDataObject implements it. get icon get display name get type name get attributes get icon location return exe type get system icon index put a link overlay on icon show icon in selected state get only specified attributes get large icon get small icon get open icon get shell size icon pszPath is a pidl use passed dwFileAttribute apply the appropriate overlays Get the index of the overlay in the upper 8 bits of the iIcon Specifies whether this structure defines an icon or a cursor. A value of TRUE specifies an icon; FALSE specifies a cursor The x-coordinate of a cursor's hot spot The y-coordinate of a cursor's hot spot The icon bitmask bitmap A handle to the icon color bitmap. Window arrangement reduces the number of mouse, pen, or touch interactions needed to move and size top-level windows by simplifying the default behavior of a window when it is dragged or sized Allow a window to be vertically maximized when it is sized to the top or bottom of the monitor Allow a window to be docked when it is moved to the top, left, or right docking targets on a monitor or monitor array Allow a maximized window to be restored when its caption bar is dragged Initializes a new instance of the class. Creates an AutomationPeer with the option of having the parent of the bounding rectangle be different than the AutomationPeer owner. Creates a bounding rect on the parent given to this AutomationPeer, given the bounding Rect and measurements of the previous parent of the Rect. Converts a Rect representing the bounding focus rectangle on the old parent, to the equivalent representation relative to the boundingRectParent of this AutomationPeer Converts a Rect that represents the bounding focus rectangle relative to boundingRectParent, to the equivalent Rect relative to the whole screen. Raises a notification event to trigger Windows Narrator. Throws Win32Exception if the win32 event fails with an HResult. InitializeComponent InitializeComponent NavigationbarButtonsView.xaml NavigationbarButtonsView InitializeComponent ProgressRingView InitializeComponent TimedProgressRingWithButtonView TimerSeconds represents second interval before the spinner gets swapped with an action button. If set to zero (default value), spinner will not appear and the button will show immediately InitializeComponent Interaction logic for AppProxyTakeoverContainer.xaml InitializeComponent Interaction logic for TakeoverErrorView.xaml TakeoverErrorView InitializeComponent Interaction logic for TakeoverFeatureSetupView.xaml TakeoverFeatureSetupView InitializeComponent Interaction logic for TakeoverNoButtonView.xaml TakeoverNoButtonView InitializeComponent Interaction logic for TakeoverOneButtonView.xaml TakeoverOneButtonView InitializeComponent Interaction logic for TakeoverOneButtonWithCheckBoxView.xaml TakeoverOneButtonWithCheckBoxView InitializeComponent Interaction logic for TakeoverSpinnerView.xaml TakeoverSpinnerView InitializeComponent Interaction logic for TakeoverTwoButtonView.xaml TakeoverTwoButtonView InitializeComponent Interaction logic for TakeoverTwoButtonWithCheckBoxView.xaml TakeoverTwoButtonWithCheckBoxView InitializeComponent Interaction logic for TeachingTip.xaml TeachingTip InitializeComponent Interaction logic for TitlebarButtonsView.xaml TitlebarButtonsView InitializeComponent Interaction logic for VolumePopup.xaml VolumePopup InitializeComponent Contains extern methods from "COMCTL32.dll". Contains extern methods from "GDI32.dll". Contains extern methods from "KERNEL32.dll". Contains extern methods from "OLE32.dll". Contains extern methods from "OLEAUT32.dll". Contains extern methods from "UIAutomationCore.dll". Contains extern methods from "USER32.dll". Destroys an image list. Type: HIMAGELIST A handle to the image list to destroy. Read more on docs.microsoft.com. Type: BOOL Returns nonzero if successful, or zero otherwise. Learn more about this API from docs.microsoft.com. Posted when the user releases the left mouse button while the cursor is in the client area of a window. If an application processes this message, it should return zero. Use the following code to obtain the horizontal and vertical position: This doc was truncated. Read more on docs.microsoft.com. Sent to a window whose size, position, or place in the Z order is about to change as a result of a call to the SetWindowPos function or another window-management function. Type: **LRESULT** If an application processes this message, it should return zero. For a window with the [**WS\_OVERLAPPED**](window-styles.md) or **WS\_THICKFRAME** style, the [**DefWindowProc**](/windows/desktop/api/winuser/nf-winuser-defwindowproca) function sends the [**WM\_GETMINMAXINFO**](wm-getminmaxinfo.md) message to the window. This is done to validate the new size and position of the window and to enforce the [CS\_BYTEALIGNCLIENT](about-window-classes.md) and CS\_BYTEALIGNWINDOW client styles. By not passing the **WM\_WINDOWPOSCHANGING** message to the **DefWindowProc** function, an application can override these defaults. While this message is being processed, modifying any of the values in [**WINDOWPOS**](/windows/win32/api/winuser/ns-winuser-windowpos) affects the window's new size, position, or place in the Z order. An application can prevent changes to the window by setting or clearing the appropriate bits in the **flags** member of **WINDOWPOS**. Read more on docs.microsoft.com. Sent to a window when the size or position of the window is about to change. An application can use this message to override the window's default maximized size and position, or its default minimum or maximum tracking size. Type: **LRESULT** If an application processes this message, it should return zero. The maximum tracking size is the largest window size that can be produced by using the borders to size the window. The minimum tracking size is the smallest window size that can be produced by using the borders to size the window. Sent one time to a window, after it has exited the moving or sizing modal loop. Type: **LRESULT** An application should return zero if it processes this message. Learn more about this API from docs.microsoft.com. Posted to provide an update on a pointer that made contact over the client area of a window or on a hovering uncaptured pointer over the client area of a window. If an application processes this message, it should return zero. If the application does not process this message, it should call [**DefWindowProc**](/windows/win32/api/winuser/nf-winuser-defwindowproca). Each pointer has a unique pointer identifier during its lifetime. The lifetime of a pointer begins when it is first detected. A [**WM_POINTERENTER**](wm-pointerenter.md) message is generated if a hovering pointer is detected. A [**WM_POINTERDOWN**](wm-pointerdown.md) message followed by a **WM_POINTERENTER** message is generated if a non-hovering pointer is detected. During its lifetime, a pointer may generate a series of **WM_POINTERUPDATE** messages while it is hovering or in contact. The lifetime of a pointer ends when it is no longer detected. This generates a [**WM_POINTERLEAVE**](wm-pointerleave.md) message. When a pointer is aborted, [**POINTER_FLAG_CANCELED**](pointer-flags-contants.md) is set. A [**WM_POINTERLEAVE**](wm-pointerleave.md) message may also be generated when a non-captured pointer moves outside the bounds of a window. To obtain the horizontal and vertical position of a pointer, use the following: This doc was truncated. Read more on docs.microsoft.com. Sent to a window when a new pointer enters detection range over the window (hover) or when an existing pointer moves within the boundaries of the window. If an application processes this message, it should return zero. If the application does not process this message, it should call [**DefWindowProc**](/windows/win32/api/winuser/nf-winuser-defwindowproca). The **WM_POINTERENTER** notification can be used by a window to provide feedback to the user while the pointer is over its surface or to otherwise react to the presence of a pointer over its surface. This notification is only sent to the window that is receiving input for the pointer. The following table lists some of the situations in which this notification is sent. | Action | Flags Set | Notifications Sent To | |----------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------| | A new pointer enters detection range (hover). | [**IS_POINTER_NEW_WPARAM**](/windows/win32/api/winuser/nf-winuser-is_pointer_new_wparam)
[**IS_POINTER_INRANGE_WPARAM**](/windows/win32/api/winuser/nf-winuser-is_pointer_new_wparam)
| Window over which the pointer enters detection range. | | A hovering pointer crosses within the window boundaries. | [**IS_POINTER_INRANGE_WPARAM**](/windows/win32/api/winuser/nf-winuser-is_pointer_inrange_wparam)
| Window within which the pointer has crossed. | > ![Important] > When a window loses capture of a pointer and it receives the [**WM_POINTERCAPTURECHANGED**](wm-pointercapturechanged.md) notification, it typically will not receive any further notifications. For this reason, it is important that you not make any assumptions based on evenly paired [**WM_POINTERDOWN**](wm-pointerdown.md)/[**WM_POINTERUP**](wm-pointerup.md) or **WM_POINTERENTER**/[**WM_POINTERLEAVE**](wm-pointerleave.md) notifications. When inputs come from the mouse, as a result of mouse and pointer message integration, **WM_POINTERENTER** is not sent. Read more on docs.microsoft.com. Sent to a window when a pointer leaves detection range over the window (hover) or when a pointer moves outside the boundaries of the window. If an application processes this message, it should return zero. If the application does not process this message, it should call [**DefWindowProc**](/windows/win32/api/winuser/nf-winuser-defwindowproca). The **WM_POINTERLEAVE** notification can be used by a window to change mode or stop any feedback to the user while the pointer is over the window surface. This notification is only sent to the window that is receiving input for the pointer. The following table lists some of the situations in which this notification is sent. | Action | Flags Set | Notifications Sent To | |-----------------------------------------------|-------------------------------------------------------------------|------------------------------------------------------| | A hovering pointer crosses window boundaries. | [**IS_POINTER_INRANGE_WPARAM**](/windows/win32/api/winuser/nf-winuser-is_pointer_inrange_wparam) | Window outside of whose boundary the pointer moved. | | A pointer goes out of detection range. | N/A | Window for which the pointer leaves detection range. | > ![Important] > When a window loses capture of a pointer and it receives the [**WM_POINTERCAPTURECHANGED**](wm-pointercapturechanged.md) notification, it typically will not receive any further notifications. For this reason, it is important that you not make any assumptions based on evenly paired [**WM_POINTERDOWN**](wm-pointerdown.md)/[**WM_POINTERUP**](wm-pointerup.md) or [**WM_POINTERENTER**](wm-pointerenter.md)/**WM_POINTERLEAVE** notifications. If contact is maintained with the input digitizer and the pointer moves outside the window, **WM_POINTERLEAVE** is not generated. **WM_POINTERLEAVE** is generated only when a hovering pointer crosses window boundaries or contact is terminated. **WM_POINTERLEAVE** is posted to the posted message queue if the input is originated from a mouse device. Read more on docs.microsoft.com. Posted when a pointer makes contact over the client area of a window. If an application processes this message, it should return zero. If the application does not process this message, it should call [**DefWindowProc**](/windows/win32/api/winuser/nf-winuser-defwindowproca). > ![Important] > When a window loses capture of a pointer and it receives the [**WM_POINTERCAPTURECHANGED**](wm-pointercapturechanged.md) notification, it typically will not receive any further notifications. For this reason, it is important that you not make any assumptions based on evenly paired **WM_POINTERDOWN**/[**WM_POINTERUP**](wm-pointerup.md) or [**WM_POINTERENTER**](wm-pointerenter.md)/[**WM_POINTERLEAVE**](wm-pointerleave.md) notifications. Each pointer has a unique pointer identifier during its lifetime. The lifetime of a pointer begins when it is first detected. A [**WM_POINTERENTER**](wm-pointerenter.md) message is generated if a hovering pointer is detected. A **WM_POINTERDOWN** message followed by a **WM_POINTERENTER** message is generated if a non-hovering pointer is detected. During its lifetime, a pointer may generate a series of [**WM_POINTERUPDATE**](wm-pointerupdate.md) messages while it is hovering or in contact. The lifetime of a pointer ends when it is no longer detected. This generates a [**WM_POINTERLEAVE**](wm-pointerleave.md) message. When a pointer is aborted, [**POINTER_FLAG_CANCELED**](pointer-flags-contants.md) is set. A [**WM_POINTERLEAVE**](wm-pointerleave.md) message may also be generated when a non-captured pointer moves outside the bounds of a window. To obtain the horizontal and vertical position of a pointer, use the following: This doc was truncated. Read more on docs.microsoft.com. Posted when a pointer that made contact over the client area of a window breaks contact. If an application processes this message, it should return zero. If the application does not process this message, it should call [**DefWindowProc**](/windows/win32/api/winuser/nf-winuser-defwindowproca). > ![Important] > When a window loses capture of a pointer and it receives the [**WM_POINTERCAPTURECHANGED**](wm-pointercapturechanged.md) notification, it typically will not receive any further notifications. For this reason, it is important that you not make any assumptions based on evenly paired [**WM_POINTERDOWN**](wm-pointerdown.md)/**WM_POINTERUP** or [**WM_POINTERENTER**](wm-pointerenter.md)/[**WM_POINTERLEAVE**](wm-pointerleave.md) notifications. Each pointer has a unique pointer identifier during its lifetime. The lifetime of a pointer begins when it is first detected. A [**WM_POINTERENTER**](wm-pointerenter.md) message is generated if a hovering pointer is detected. A [**WM_POINTERDOWN**](wm-pointerdown.md) message followed by a **WM_POINTERENTER** message is generated if a non-hovering pointer is detected. During its lifetime, a pointer may generate a series of [**WM_POINTERUPDATE**](wm-pointerupdate.md) messages while it is hovering or in contact. The lifetime of a pointer ends when it is no longer detected. This generates a [**WM_POINTERLEAVE**](wm-pointerleave.md) message. When a pointer is aborted, [**POINTER_FLAG_CANCELED**](pointer-flags-contants.md) is set. A [**WM_POINTERLEAVE**](wm-pointerleave.md) message may also be generated when a non-captured pointer moves outside the bounds of a window. To obtain the horizontal and vertical position of a pointer, use the following: Use the following code to obtain the horizontal and vertical position: This doc was truncated. Read more on docs.microsoft.com. Posted to the window with foreground keyboard focus when a scroll wheel is rotated. If the application processes this message, it should return zero. If the application does not process this message, it should call [**DefWindowProc**](/windows/win32/api/winuser/nf-winuser-defwindowproca). To retrieve the wheel scroll units, use the **inputData** filed of the [**POINTER_INFO**](/windows/win32/api/winuser/ns-winuser-pointer_info) structure returned by calling [**GetPointerInfo**](/windows/win32/api/winuser/ns-winuser-pointer_info) function. This field contains a signed value and is expressed in a multiple of **WHEEL_DELTA**. A positive value indicates a rotation forward and a negative value indicates a rotation backward. Note that the wheel inputs may be delivered even if the mouse cursor is located outside of application s window. The wheel messages are delivered in a way very similar to the keyboard inputs. The focus window of the foregournd message queue receives the wheel messages. Read more on docs.microsoft.com. Posted to the window with foreground keyboard focus when a horizontal scroll wheel is rotated. If the application processes this message, it should return zero. If the application does not process this message, it should call [**DefWindowProc**](/windows/win32/api/winuser/nf-winuser-defwindowproca). To retrieve the wheel scroll units, use the **inputData** filed of the [**POINTER_INFO**](/windows/win32/api/winuser/ns-winuser-pointer_info) structure returned by calling [**GetPointerInfo**](/windows/win32/api/winuser/ns-winuser-pointer_info) function. This field contains a signed value and is expressed in a multiple of **WHEEL_DELTA**. A positive value indicates a rotation forward and a negative value indicates a rotation backward. Note that the wheel inputs may be delivered even if the mouse cursor is located outside of application s window. The wheel messages are delivered in a way very similar to the keyboard inputs. The focus window of the foregournd message queue receives the wheel messages. Read more on docs.microsoft.com. Sent to a window after it has gained the keyboard focus. An application should return zero if it processes this message. To display a caret, an application should call the appropriate caret functions when it receives the **WM\_SETFOCUS** message. Sent to a window immediately before it loses the keyboard focus. An application should return zero if it processes this message. If an application is displaying a caret, the caret should be destroyed at this point. While processing this message, do not make any function calls that display or activate a window. This causes the thread to yield control and can cause the application to stop responding to messages. For more information, see [Message Deadlocks](/windows/desktop/winmsg/about-messages-and-message-queues). Read more on docs.microsoft.com. Sent prior to the WM\_CREATE message when a window is first created. Type: **LRESULT** If an application processes this message, it should return **TRUE** to continue creation of the window. If the application returns **FALSE**, the [**CreateWindow**](/windows/win32/api/winuser/nf-winuser-createwindowa) or [**CreateWindowEx**](/windows/win32/api/winuser/nf-winuser-createwindowexa) function will return a **NULL** handle. Learn more about this API from docs.microsoft.com. Notifies a window that its nonclient area is being destroyed. The DestroyWindow function sends the WM\_NCDESTROY message to the window following the WM\_DESTROY message. Type: **LRESULT** If an application processes this message, it should return zero. This message frees any memory internally allocated for the window. Standard arrow cursor. Learn more about this API from docs.microsoft.com. The DeleteObject function deletes a logical pen, brush, font, bitmap, region, or palette, freeing all system resources associated with the object. After the object is deleted, the specified handle is no longer valid. A handle to a logical pen, brush, font, bitmap, region, or palette. If the function succeeds, the return value is nonzero. If the specified handle is not valid or is currently selected into a DC, the return value is zero. Do not delete a drawing object (pen or brush) while it is still selected into a DC. When a pattern brush is deleted, the bitmap associated with the brush is not deleted. The bitmap must be deleted independently. Read more on docs.microsoft.com. Closes an open object handle. A valid handle to an open object. 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. If the application is running under a debugger, the function will throw an exception if it receives either a handle value that is not valid or a pseudo-handle value. This can happen if you close a handle twice, or if you call CloseHandle on a handle returned by the FindFirstFile function instead of calling the FindClose function. The CloseHandle function closes handles to the following objects: This doc was truncated. Read more on docs.microsoft.com. Frees the loaded dynamic-link library (DLL) module and, if necessary, decrements its reference count. A handle to the loaded library module. The LoadLibrary, LoadLibraryEx, GetModuleHandle, or GetModuleHandleEx function returns this handle. Read more on docs.microsoft.com. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call the GetLastError function. The system maintains a per-process reference count for each loaded module. A module that was loaded at process initialization due to load-time dynamic linking has a reference count of one. The reference count for a module is incremented each time the module is loaded by a call to LoadLibrary. The reference count is also incremented by a call to LoadLibraryEx unless the module is being loaded for the first time and is being loaded as a data or image file. The reference count is decremented each time the FreeLibrary or FreeLibraryAndExitThread function is called for the module. When a module's reference count reaches zero or the process terminates, the system unloads the module from the address space of the process. Before unloading a library module, the system enables the module to detach from the process by calling the module's DllMain function, if it has one, with the DLL_PROCESS_DETACH value. Doing so gives the library module an opportunity to clean up resources allocated on behalf of the current process. After the entry-point function returns, the library module is removed from the address space of the current process. It is not safe to call FreeLibrary from DllMain. For more information, see the Remarks section in DllMain. Calling FreeLibrary does not affect other processes that are using the same module. Use caution when calling FreeLibrary with a handle returned by GetModuleHandle. The GetModuleHandle function does not increment a module's reference count, so passing this handle to FreeLibrary can cause a module to be unloaded prematurely. A thread that must unload the DLL in which it is executing and then terminate itself should call FreeLibraryAndExitThread instead of calling FreeLibrary and ExitThread separately. Otherwise, a race condition can occur. For details, see the Remarks section of FreeLibraryAndExitThread. Read more on docs.microsoft.com. Retrieves a module handle for the specified module. The module must have been loaded by the calling process. (Unicode) The name of the loaded module (either a .dll or .exe file). If the file name extension is omitted, the default library extension .dll is appended. The file name string can include a trailing point character (.) to indicate that the module name has no extension. The string does not have to specify a path. When specifying a path, be sure to use backslashes (\\), not forward slashes (/). The name is compared (case independently) to the names of modules currently mapped into the address space of the calling process. If this parameter is NULL, GetModuleHandle returns a handle to the file used to create the calling process (.exe file). The GetModuleHandle function does not retrieve handles for modules that were loaded using the LOAD_LIBRARY_AS_DATAFILE flag. For more information, see LoadLibraryEx. Read more on docs.microsoft.com. If the function succeeds, the return value is a handle to the specified module. If the function fails, the return value is NULL. To get extended error information, call GetLastError. The returned handle is not global or inheritable. It cannot be duplicated or used by another process. If lpModuleName does not include a path and there is more than one loaded module with the same base name and extension, you cannot predict which module handle will be returned. To work around this problem, you could specify a path, use side-by-side assemblies, or use GetModuleHandleEx to specify a memory location rather than a DLL name. The GetModuleHandle function returns a handle to a mapped module without incrementing its reference count. However, if this handle is passed to the FreeLibrary function, the reference count of the mapped module will be decremented. Therefore, do not pass a handle returned by GetModuleHandle to the FreeLibrary function. Doing so can cause a DLL module to be unmapped prematurely. This function must be used carefully in a multithreaded application. There is no guarantee that the module handle remains valid between the time this function returns the handle and the time it is used. For example, suppose that a thread retrieves a module handle, but before it uses the handle, a second thread frees the module. If the system loads another module, it could reuse the module handle that was recently freed. Therefore, the first thread would have a handle to a different module than the one intended. Read more on docs.microsoft.com. Creates a single uninitialized object of the class associated with a specified CLSID. The CLSID associated with the data and code that will be used to create the object. If NULL, indicates that the object is not being created as part of an aggregate. If non-NULL, pointer to the aggregate object's IUnknown interface (the controlling IUnknown). Context in which the code that manages the newly created object will run. The values are taken from the enumeration CLSCTX. A reference to the identifier of the interface to be used to communicate with the object. Address of pointer variable that receives the interface pointer requested in riid. Upon successful return, *ppv contains the requested interface pointer. Upon failure, *ppv contains NULL. This function can return the following values. This doc was truncated. The CoCreateInstance function provides a convenient shortcut by connecting to the class object associated with the specified CLSID, creating a default-initialized instance, and releasing the class object. As such, it encapsulates the following functionality: This doc was truncated. Read more on docs.microsoft.com. Deallocates a string allocated previously by SysAllocString, SysAllocStringByteLen, SysReAllocString, SysAllocStringLen, or SysReAllocStringLen. The previously allocated string. If this parameter is NULL, the function simply returns. Learn more about this API from docs.microsoft.com. Gets a value that indicates whether any client application is subscribed to Microsoft UI Automation events. Type: BOOL TRUE if a client has subscribed to events; otherwise FALSE. Learn more about this API from docs.microsoft.com. Called by providers to initiate a notification event. The provider node where the notification event occurred. The type of notification, as a [NotificationKind enumeration](../uiautomationcore/ne-uiautomationcore-notificationkind.md) value. The preferred way to process a notification, as a [NotificationProcessing enumeration](../uiautomationcore/ne-uiautomationcore-notificationprocessing.md) value. A string to display in the notification message. A unique non-localized string to identify an action or group of actions. Use this to pass additional information to the event handler. If this function succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. If your window uses the [`WS_POPUP`](/windows/win32/winmsg/window-styles) style, it must also implement the [Window Control Pattern](/windows/win32/winauto/uiauto-implementingwindow) and handle the [WM_GETOBJECT](/windows/win32/winauto/wm-getobject) message (see [How to Expose a Server-Side UI Automation Provider](/windows/win32/winauto/uiauto-howto-expose-serverside-uiautomation-provider) for more details). Retrieves the status of the specified virtual key. The status specifies whether the key is up, down, or toggled (on, off�alternating each time the key is pressed). Type: int A virtual key. If the desired virtual key is a letter or digit (A through Z, a through z, or 0 through 9), nVirtKey must be set to the ASCII value of that character. For other keys, it must be a virtual-key code. If a non-English keyboard layout is used, virtual keys with values in the range ASCII A through Z and 0 through 9 are used to specify most of the character keys. For example, for the German keyboard layout, the virtual key of value ASCII O (0x4F) refers to the "o" key, whereas VK_OEM_1 refers to the "o with umlaut" key. Read more on docs.microsoft.com. Type: SHORT The return value specifies the status of the specified virtual key, as follows: This doc was truncated. The key status returned from this function changes as a thread reads key messages from its message queue. The status does not reflect the interrupt-level state associated with the hardware. Use the GetAsyncKeyState function to retrieve that information. An application calls GetKeyState in response to a keyboard-input message. This function retrieves the state of the key when the input message was generated. To retrieve state information for all the virtual keys, use the GetKeyboardState function. An application can use the virtual key code constants VK_SHIFT, VK_CONTROL, and VK_MENU as values for the nVirtKey parameter. This gives the status of the SHIFT, CTRL, or ALT keys without distinguishing between left and right. An application can also use the following virtual-key code constants as values for nVirtKey to distinguish between the left and right instances of those keys: VK_LSHIFT VK_RSHIFT VK_LCONTROL VK_RCONTROL VK_LMENU VK_RMENU These left- and right-distinguishing constants are available to an application only through the GetKeyboardState, SetKeyboardState, GetAsyncKeyState, GetKeyState, and MapVirtualKey functions. Read more on docs.microsoft.com. Retrieves the pointer type for a specified pointer. An identifier of the pointer for which to retrieve pointer type. An address of a POINTER_INPUT_TYPE type to receive a pointer input type. If the function succeeds, the return value is non-zero. If the function fails, the return value is zero. To get extended error information, call GetLastError. An application can use the GetPointerType function to determine the pointer type if it wishes to react differently to pointers of different types.
Note  This function will never return with the generic PT_POINTER type.
 
 Read more on docs.microsoft.com. Gets the information for the specified pointer associated with the current message. The pointer identifier. Address of a POINTER_INFO structure that receives the pointer information. If the function succeeds, the return value is non-zero. If the function fails, the return value is zero. To get extended error information, call GetLastError. GetPointerInfo retrieves information for a single pointer associated with a pointer message. Use GetPointerFrameInfo to retrieve frame information associated with a message for a set of pointers. The information returned by GetPointerInfo is associated with the most recent pointer message retrieved by the calling thread. When the next message is retrieved by the calling thread, the information associated with the previous message may no longer be available. If the application does not process pointer input messages as fast as they are generated, some messages may be coalesced into a WM_POINTERUPDATE message. Use GetPointerInfoHistory to retrieve the message history from the most recent WM_POINTERUPDATE message. If the information associated with the message is no longer available, this function fails with the last error set to ERROR_NO_DATA. If the calling thread does not own the window to which the pointer message has been delivered, this function fails with the last error set to ERROR_ACCESS_DENIED. Note that this may be the window to which the input was originally delivered or it may be a window to which the message was forwarded. Read more on docs.microsoft.com. Gets the touch-based information for the specified pointer (of type PT_TOUCH) associated with the current message. An identifier of the pointer for which to retrieve information. Address of a POINTER_TOUCH_INFO structure to receive the touch-specific pointer information. If the function succeeds, the return value is non-zero. If the function fails, the return value is zero. To get extended error information, call GetLastError. GetPointerTouchInfo retrieves information for a single pointer (of type PT_TOUCH) associated with a pointer message. Use GetPointerFrameTouchInfo to retrieve frame information associated with a message for a set of pointers. The information returned by GetPointerTouchInfo is associated with the most recent pointer message retrieved by the calling thread. When the next message is retrieved by the calling thread, the information associated with the previous message may no longer be available. If the application does not process pointer input messages as fast as they are generated, some messages may be coalesced into a WM_POINTERUPDATE message. Use GetPointerTouchInfoHistory to retrieve the message history from the most recent WM_POINTERUPDATE message. If the information associated with the message is no longer available, this function fails with the last error set to ERROR_NO_DATA. If the calling thread does not own the window to which the pointer message has been delivered, this function fails with the last error set to ERROR_ACCESS_DENIED. Note that this may be the window to which the input was originally delivered or it may be a window to which the message was forwarded. If the specified pointer is not of type PT_TOUCH, this function fails with the last error set to ERROR_DATATYPE_MISMATCH. Read more on docs.microsoft.com. Gets the pen-based information for the specified pointer (of type PT_PEN) associated with the current message. An identifier of the pointer for which to retrieve information. Address of a POINTER_PEN_INFO structure to receive the pen-specific pointer information. If the function succeeds, the return value is non-zero. If the function fails, the return value is zero. To get extended error information, call GetLastError. GetPointerPenInfo retrieves information for a single pointer (of type PT_PEN) associated with a pointer message. Use GetPointerFramePenInfo to retrieve frame information associated with a message for a set of pointers. The information returned by GetPointerInfo is associated with the most recent pointer message retrieved by the calling thread. When the next message is retrieved by the calling thread, the information associated with the previous message may no longer be available. If the application does not process pointer input messages as fast as they are generated, some messages may be coalesced into a WM_POINTERUPDATE message. Use GetPointerPenInfoHistory to retrieve the message history from the most recent WM_POINTERUPDATE message. If the information associated with the message is no longer available, this function fails with the last error set to ERROR_NO_DATA. If the calling thread does not own the window to which the pointer message has been delivered, this function fails with the last error set to ERROR_ACCESS_DENIED. Note that this may be the window to which the input was originally delivered or it may be a window to which the message was forwarded. If the specified pointer is not of type PT_PEN, this function fails with the last error set to ERROR_DATATYPE_MISMATCH. Read more on docs.microsoft.com. Retrieves the position of the mouse cursor, in screen coordinates. Type: LPPOINT A pointer to a POINT structure that receives the screen coordinates of the cursor. Read more on docs.microsoft.com. Type: BOOL Returns nonzero if successful or zero otherwise. To get extended error information, call GetLastError. The cursor position is always specified in screen coordinates and is not affected by the mapping mode of the window that contains the cursor. The calling process must have WINSTA_READATTRIBUTES access to the window station. The input desktop must be the current desktop when you call GetCursorPos. Call OpenInputDesktop to determine whether the current desktop is the input desktop. If it is not, call SetThreadDesktop with the HDESK returned by OpenInputDesktop to switch to that desktop. Read more on docs.microsoft.com. Moves the cursor to the specified screen coordinates. Type: int The new x-coordinate of the cursor, in screen coordinates. Read more on docs.microsoft.com. Type: int The new y-coordinate of the cursor, in screen coordinates. Read more on docs.microsoft.com. Type: BOOL Returns nonzero if successful or zero otherwise. To get extended error information, call GetLastError. The cursor is a shared resource. A window should move the cursor only when the cursor is in the window's client area. The calling process must have WINSTA_WRITEATTRIBUTES access to the window station. The input desktop must be the current desktop when you call SetCursorPos. Call OpenInputDesktop to determine whether the current desktop is the input desktop. If it is not, call SetThreadDesktop with the HDESK returned by OpenInputDesktop to switch to that desktop. Read more on docs.microsoft.com. Enables the mouse to act as a pointer input device and send WM_POINTER messages. TRUE to turn on mouse input support in WM_POINTER. If the function succeeds, the return value is non-zero. If the function fails, the return value is zero. To get extended error information, call GetLastError. This function can be called only once in the context of a process lifetime. Prior to the first call, Windows Store apps run with mouse-in-pointer enabled, as do any desktop applications that consume mshtml.dll. All other desktop applications run with mouse-in-pointer disabled. On the first call in the process lifetime, the state is changed as specified and the call succeeds. On subsequent calls, the state will not change. If the current state is not equal to the specified state, the call fails. Call IsMouseInPointerEnabled to verify the mouse-in-pointer state. Read more on docs.microsoft.com. Sets the keyboard focus to the specified window. The window must be attached to the calling thread's message queue. Type: **HWND** A handle to the window that will receive the keyboard input. If this parameter is NULL, keystrokes are ignored. Read more on docs.microsoft.com. Type: **HWND** If the function succeeds, the return value is the handle to the window that previously had the keyboard focus. If the *hWnd* parameter is invalid or the window is not attached to the calling thread's message queue, the return value is NULL. To get extended error information, call [GetLastError function](../errhandlingapi/nf-errhandlingapi-getlasterror.md). Extended error ERROR_INVALID_PARAMETER (0x57) means that window is in disabled state. This function sends a [WM_KILLFOCUS](/windows/desktop/inputdev/wm-killfocus) message to the window that loses the keyboard focus and a [WM_SETFOCUS](/windows/desktop/inputdev/wm-setfocus) message to the window that receives the keyboard focus. It also activates either the window that receives the focus or the parent of the window that receives the focus. If a window is active but does not have the focus, any key pressed produces the [WM_SYSCHAR](/windows/desktop/menurc/wm-syschar), [WM_SYSKEYDOWN](/windows/desktop/inputdev/wm-syskeydown), or [WM_SYSKEYUP](/windows/desktop/inputdev/wm-syskeyup) message. If the VK_MENU key is also pressed, bit 30 of the *lParam* parameter of the message is set. Otherwise, the messages produced do not have this bit set. By using the [AttachThreadInput function](nf-winuser-attachthreadinput.md), a thread can attach its input processing to another thread. This allows a thread to call SetFocus to set the keyboard focus to a window attached to another thread's message queue. Read more on docs.microsoft.com. Destroys the specified menu and frees any memory that the menu occupies. Type: HMENU A handle to the menu to be destroyed. Read more on docs.microsoft.com. 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. Before closing, an application must use the DestroyMenu function to destroy a menu not assigned to a window. A menu that is assigned to a window is automatically destroyed when the application closes. DestroyMenu is recursive, that is, it will destroy the menu and all its submenus. Read more on docs.microsoft.com. Creates an overlapped, pop-up, or child window with an extended window style; otherwise, this function is identical to the CreateWindow function. (Unicode) Type: DWORD The extended window style of the window being created. For a list of possible values, see Extended Window Styles. Read more on docs.microsoft.com. Type: LPCTSTR A null-terminated string or a class atom created by a previous call to the RegisterClass or RegisterClassEx function. The atom must be in the low-order word of lpClassName; the high-order word must be zero. If lpClassName is a string, it specifies the window class name. The class name can be any name registered with RegisterClass or RegisterClassEx, provided that the module that registers the class is also the module that creates the window. The class name can also be any of the predefined system class names. Read more on docs.microsoft.com. Type: LPCTSTR The window name. If the window style specifies a title bar, the window title pointed to by lpWindowName is displayed in the title bar. When using CreateWindow to create controls, such as buttons, check boxes, and static controls, use lpWindowName to specify the text of the control. When creating a static control with the SS_ICON style, use lpWindowName to specify the icon name or identifier. To specify an identifier, use the syntax "#num". Read more on docs.microsoft.com. Type: DWORD The style of the window being created. This parameter can be a combination of the window style values, plus the control styles indicated in the Remarks section. Read more on docs.microsoft.com. Type: int The initial horizontal position of the window. For an overlapped or pop-up window, the x parameter is the initial x-coordinate of the window's upper-left corner, in screen coordinates. For a child window, x is the x-coordinate of the upper-left corner of the window relative to the upper-left corner of the parent window's client area. If x is set to CW_USEDEFAULT, the system selects the default position for the window's upper-left corner and ignores the y parameter. CW_USEDEFAULT is valid only for overlapped windows; if it is specified for a pop-up or child window, the x and y parameters are set to zero. Read more on docs.microsoft.com. Type: int The initial vertical position of the window. For an overlapped or pop-up window, the y parameter is the initial y-coordinate of the window's upper-left corner, in screen coordinates. For a child window, y is the initial y-coordinate of the upper-left corner of the child window relative to the upper-left corner of the parent window's client area. For a list box y is the initial y-coordinate of the upper-left corner of the list box's client area relative to the upper-left corner of the parent window's client area. If an overlapped window is created with the WS_VISIBLE style bit set and the x parameter is set to CW_USEDEFAULT, then the y parameter determines how the window is shown. If the y parameter is CW_USEDEFAULT, then the window manager calls ShowWindow with the SW_SHOW flag after the window has been created. If the y parameter is some other value, then the window manager calls ShowWindow with that value as the nCmdShow parameter. Read more on docs.microsoft.com. Type: int The width, in device units, of the window. For overlapped windows, nWidth is the window's width, in screen coordinates, or CW_USEDEFAULT. If nWidth is CW_USEDEFAULT, the system selects a default width and height for the window; the default width extends from the initial x-coordinates to the right edge of the screen; the default height extends from the initial y-coordinate to the top of the icon area. CW_USEDEFAULT is valid only for overlapped windows; if CW_USEDEFAULT is specified for a pop-up or child window, the nWidth and nHeight parameter are set to zero. Read more on docs.microsoft.com. Type: int The height, in device units, of the window. For overlapped windows, nHeight is the window's height, in screen coordinates. If the nWidth parameter is set to CW_USEDEFAULT, the system ignores nHeight. Read more on docs.microsoft.com. Type: HWND A handle to the parent or owner window of the window being created. To create a child window or an owned window, supply a valid window handle. This parameter is optional for pop-up windows. To create a message-only window, supply HWND_MESSAGE or a handle to an existing message-only window. Read more on docs.microsoft.com. Type: HMENU A handle to a menu, or specifies a child-window identifier, depending on the window style. For an overlapped or pop-up window, hMenu identifies the menu to be used with the window; it can be NULL if the class menu is to be used. For a child window, hMenu specifies the child-window identifier, an integer value used by a dialog box control to notify its parent about events. The application determines the child-window identifier; it must be unique for all child windows with the same parent window. Read more on docs.microsoft.com. Type: HINSTANCE A handle to the instance of the module to be associated with the window. Read more on docs.microsoft.com. Type: LPVOID Pointer to a value to be passed to the window through the CREATESTRUCT structure (lpCreateParams member) pointed to by the lParam param of the WM_CREATE message. This message is sent to the created window by this function before it returns. If an application calls CreateWindow to create a MDI client window, lpParam should point to a CLIENTCREATESTRUCT structure. If an MDI client window calls CreateWindow to create an MDI child window, lpParam should point to a MDICREATESTRUCT structure. lpParam may be NULL if no additional data is needed. Read more on docs.microsoft.com. Type: HWND If the function succeeds, the return value is a handle to the new window. If the function fails, the return value is NULL. To get extended error information, call GetLastError. This function typically fails for one of the following reasons: This doc was truncated. The CreateWindowEx function sends WM_NCCREATE, WM_NCCALCSIZE, and WM_CREATE messages to the window being created. If the created window is a child window, its default position is at the bottom of the Z-order. If the created window is a top-level window, its default position is at the top of the Z-order (but beneath all topmost windows unless the created window is itself topmost). For information on controlling whether the Taskbar displays a button for the created window, see Managing Taskbar Buttons. For information on removing a window, see the DestroyWindow function. The following predefined control classes can be specified in the lpClassName parameter. Note the corresponding control styles you can use in the dwStyle parameter. This doc was truncated. Read more on docs.microsoft.com. Calls the default window procedure to provide default processing for any window messages that an application does not process. (Unicode) Type: HWND A handle to the window procedure that received the message. Read more on docs.microsoft.com. Type: UINT The message. Read more on docs.microsoft.com. Type: WPARAM Additional message information. The content of this parameter depends on the value of the Msg parameter. Read more on docs.microsoft.com. Type: LPARAM Additional message information. The content of this parameter depends on the value of the Msg parameter. Read more on docs.microsoft.com. Type: LRESULT The return value is the result of the message processing and depends on the message. > [!NOTE] > The winuser.h header defines DefWindowProc as an alias which automatically selects the ANSI or Unicode version of this function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see [Conventions for Function Prototypes](/windows/win32/intl/conventions-for-function-prototypes). Read more on docs.microsoft.com. Destroys the specified window. Type: HWND A handle to the window to be destroyed. Read more on docs.microsoft.com. 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. A thread cannot use DestroyWindow to destroy a window created by a different thread. If the window being destroyed is a child window that does not have the WS_EX_NOPARENTNOTIFY style, a WM_PARENTNOTIFY message is sent to the parent. Read more on docs.microsoft.com. Removes a hook procedure installed in a hook chain by the SetWindowsHookEx function. Type: HHOOK A handle to the hook to be removed. This parameter is a hook handle obtained by a previous call to SetWindowsHookEx. Read more on docs.microsoft.com. 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 hook procedure can be in the state of being called by another thread even after UnhookWindowsHookEx returns. If the hook procedure is not being called concurrently, the hook procedure is removed immediately before UnhookWindowsHookEx returns. Installs an application-defined hook procedure into a hook chain. (Unicode) Type: int Type: HOOKPROC A pointer to the hook procedure. If the dwThreadId parameter is zero or specifies the identifier of a thread created by a different process, the lpfn parameter must point to a hook procedure in a DLL. Otherwise, lpfn can point to a hook procedure in the code associated with the current process. Read more on docs.microsoft.com. Type: HINSTANCE A handle to the DLL containing the hook procedure pointed to by the lpfn parameter. The hMod parameter must be set to NULL if the dwThreadId parameter specifies a thread created by the current process and if the hook procedure is within the code associated with the current process. Read more on docs.microsoft.com. Type: DWORD The identifier of the thread with which the hook procedure is to be associated. For desktop apps, if this parameter is zero, the hook procedure is associated with all existing threads running in the same desktop as the calling thread. For Windows Store apps, see the Remarks section. Read more on docs.microsoft.com. Type: HHOOK If the function succeeds, the return value is the handle to the hook procedure. If the function fails, the return value is NULL. To get extended error information, call GetLastError. SetWindowsHookEx can be used to inject a DLL into another process. A 32-bit DLL cannot be injected into a 64-bit process, and a 64-bit DLL cannot be injected into a 32-bit process. If an application requires the use of hooks in other processes, it is required that a 32-bit application call SetWindowsHookEx to inject a 32-bit DLL into 32-bit processes, and a 64-bit application call SetWindowsHookEx to inject a 64-bit DLL into 64-bit processes. The 32-bit and 64-bit DLLs must have different names. Because hooks run in the context of an application, they must match the "bitness" of the application. If a 32-bit application installs a global hook on 64-bit Windows, the 32-bit hook is injected into each 32-bit process (the usual security boundaries apply). In a 64-bit process, the threads are still marked as "hooked." However, because a 32-bit application must run the hook code, the system executes the hook in the hooking app's context; specifically, on the thread that called SetWindowsHookEx. This means that the hooking application must continue to pump messages or it might block the normal functioning of the 64-bit processes. If a 64-bit application installs a global hook on 64-bit Windows, the 64-bit hook is injected into each 64-bit process, while all 32-bit processes use a callback to the hooking application. To hook all applications on the desktop of a 64-bit Windows installation, install a 32-bit global hook and a 64-bit global hook, each from appropriate processes, and be sure to keep pumping messages in the hooking application to avoid blocking normal functioning. If you already have a 32-bit global hooking application and it doesn't need to run in each application's context, you may not need to create a 64-bit version. An error may occur if the hMod parameter is NULL and the dwThreadId parameter is zero or specifies the identifier of a thread created by another process. Calling the CallNextHookEx function to chain to the next hook procedure is optional, but it is highly recommended; otherwise, other applications that have installed hooks will not receive hook notifications and may behave incorrectly as a result. You should call CallNextHookEx unless you absolutely need to prevent the notification from being seen by other applications. Before terminating, an application must call the UnhookWindowsHookEx function to free system resources associated with the hook. The scope of a hook depends on the hook type. Some hooks can be set only with global scope; others can also be set for only a specific thread, as shown in the following table. This doc was truncated. Read more on docs.microsoft.com. Passes the hook information to the next hook procedure in the current hook chain. A hook procedure can call this function either before or after processing the hook information. Type: HHOOK This parameter is ignored. Read more on docs.microsoft.com. Type: int The hook code passed to the current hook procedure. The next hook procedure uses this code to determine how to process the hook information. Read more on docs.microsoft.com. Type: WPARAM The wParam value passed to the current hook procedure. The meaning of this parameter depends on the type of hook associated with the current hook chain. Read more on docs.microsoft.com. Type: LPARAM The lParam value passed to the current hook procedure. The meaning of this parameter depends on the type of hook associated with the current hook chain. Read more on docs.microsoft.com. Type: LRESULT This value is returned by the next hook procedure in the chain. The current hook procedure must also return this value. The meaning of the return value depends on the hook type. For more information, see the descriptions of the individual hook procedures. Hook procedures are installed in chains for particular hook types. CallNextHookEx calls the next hook in the chain. Calling CallNextHookEx is optional, but it is highly recommended; otherwise, other applications that have installed hooks will not receive hook notifications and may behave incorrectly as a result. You should call CallNextHookEx unless you absolutely need to prevent the notification from being seen by other applications. Read more on docs.microsoft.com. Retrieves the specified system metric or system configuration setting taking into account a provided DPI. The system metric or configuration setting to be retrieved. See GetSystemMetrics for the possible values. The DPI to use for scaling the metric. 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. This function returns the same result as GetSystemMetrics but scales it according to an arbitrary DPI you provide if appropriate. The RedrawWindow function updates the specified rectangle or region in a window's client area. A handle to the window to be redrawn. If this parameter is NULL, the desktop window is updated. 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. A handle to the update region. If both the hrgnUpdate and lprcUpdate parameters are NULL, the entire client area is added to the update region. 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 RedrawWindow. The following flags are used to invalidate the window. This doc was truncated. Read more on docs.microsoft.com. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. When RedrawWindow 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. The MonitorFromWindow function retrieves a handle to the display monitor that has the largest area of intersection with the bounding rectangle of a specified window. A handle to the window of interest. Determines the function's return value if the window does not intersect any display monitor. If the window intersects one or more display monitor rectangles, the return value is an HMONITOR handle to the display monitor that has the largest area of intersection with the window. If the window does not intersect a display monitor, the return value depends on the value of dwFlags. If the window is currently minimized, MonitorFromWindow uses the rectangle of the window before it was minimized. The EnumDisplayMonitors function enumerates display monitors (including invisible pseudo-monitors associated with the mirroring drivers) that intersect a region formed by the intersection of a specified clipping rectangle and the visible region of a device context. EnumDisplayMonitors calls an application-defined MonitorEnumProc callback function once for each monitor that is enumerated. Note that GetSystemMetrics (SM_CMONITORS) counts only the display monitors. A handle to a display device context that defines the visible region of interest. If this parameter is NULL, the hdcMonitor parameter passed to the callback function will be NULL, and the visible region of interest is the virtual screen that encompasses all the displays on the desktop. Read more on docs.microsoft.com. A pointer to a RECT structure that specifies a clipping rectangle. The region of interest is the intersection of the clipping rectangle with the visible region specified by hdc. If hdc is non-NULL, the coordinates of the clipping rectangle are relative to the origin of the hdc. If hdc is NULL, the coordinates are virtual-screen coordinates. This parameter can be NULL if you don't want to clip the region specified by hdc. Read more on docs.microsoft.com. A pointer to a MonitorEnumProc application-defined callback function. Application-defined data that EnumDisplayMonitors passes directly to the MonitorEnumProc function. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. There are two reasons to call the EnumDisplayMonitors function: This doc was truncated. Read more on docs.microsoft.com. The GetMonitorInfo function retrieves information about a display monitor. (Unicode) A handle to the display monitor of interest. A pointer to a MONITORINFO or MONITORINFOEX structure that receives information about the specified display monitor. You must set the cbSize member of the structure to sizeof(MONITORINFO) or sizeof(MONITORINFOEX) before calling the GetMonitorInfo function. Doing so lets the function determine the type of structure you are passing to it. The MONITORINFOEX structure is a superset of the MONITORINFO structure. It has one additional member: a string that contains a name for the display monitor. Most applications have no use for a display monitor name, and so can save some bytes by using a MONITORINFO structure. Read more on docs.microsoft.com. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. > [!NOTE] > The winuser.h header defines GetMonitorInfo as an alias which automatically selects the ANSI or Unicode version of this function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see [Conventions for Function Prototypes](/windows/win32/intl/conventions-for-function-prototypes). Read more on docs.microsoft.com. Retrieves or sets the value of one of the system-wide parameters. (Unicode) Type: UINT The system-wide parameter to be retrieved or set. The possible values are organized in the following tables of related parameters: This doc was truncated. Read more on docs.microsoft.com. Type: UINT A parameter whose usage and format depends on the system parameter being queried or set. For more information about system-wide parameters, see the uiAction parameter. If not otherwise indicated, you must specify zero for this parameter. Read more on docs.microsoft.com. Type: PVOID A parameter whose usage and format depends on the system parameter being queried or set. For more information about system-wide parameters, see the uiAction parameter. If not otherwise indicated, you must specify NULL for this parameter. For information on the PVOID datatype, see Windows Data Types. Read more on docs.microsoft.com. Type: UINT If a system parameter is being set, specifies whether the user profile is to be updated, and if so, whether the WM_SETTINGCHANGE message is to be broadcast to all top-level windows to notify them of the change. Read more on docs.microsoft.com. Type: BOOL If the function succeeds, the return value is a nonzero value. If the function fails, the return value is zero. To get extended error information, call GetLastError. This function is intended for use with applications that allow the user to customize the environment. A keyboard layout name should be derived from the hexadecimal value of the language identifier corresponding to the layout. For example, U.S. English has a language identifier of 0x0409, so the primary U.S. English layout is named "00000409". Variants of U.S. English layout, such as the Dvorak layout, are named "00010409", "00020409" and so on. For a list of the primary language identifiers and sublanguage identifiers that make up a language identifier, see the MAKELANGID macro. There is a difference between the High Contrast color scheme and the High Contrast Mode. The High Contrast color scheme changes the system colors to colors that have obvious contrast; you switch to this color scheme by using the Display Options in the control panel. The High Contrast Mode, which uses SPI_GETHIGHCONTRAST and SPI_SETHIGHCONTRAST, advises applications to modify their appearance for visually-impaired users. It involves such things as audible warning to users and customized color scheme (using the Accessibility Options in the control panel). For more information, see HIGHCONTRAST. For more information on general accessibility features, see Accessibility. During the time that the primary button is held down to activate the Mouse ClickLock feature, the user can move the mouse. After the primary button is locked down, releasing the primary button does not result in a WM_LBUTTONUP message. Thus, it will appear to an application that the primary button is still down. Any subsequent button message releases the primary button, sending a WM_LBUTTONUP message to the application, thus the button can be unlocked programmatically or through the user clicking any button. This API is not DPI aware, and should not be used if the calling thread is per-monitor DPI aware. For the DPI-aware version of this API, see SystemParametersInfoForDPI. For more information on DPI awareness, see the Windows High DPI documentation. Read more on docs.microsoft.com. Destroys an icon and frees any memory the icon occupied. Type: HICON A handle to the icon to be destroyed. The icon must not be in use. Read more on docs.microsoft.com. 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. It is only necessary to call DestroyIcon for icons and cursors created with the following functions: CreateIconFromResourceEx (if called without the LR_SHARED flag), CreateIconIndirect, and CopyIcon. Do not use this function to destroy a shared icon. A shared icon is valid as long as the module from which it was loaded remains in memory. The following functions obtain a shared icon. This doc was truncated. Read more on docs.microsoft.com. Destroys a cursor and frees any memory the cursor occupied. Do not use this function to destroy a shared cursor. Type: HCURSOR A handle to the cursor to be destroyed. The cursor must not be in use. Read more on docs.microsoft.com. 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 DestroyCursor function destroys a nonshared cursor. Do not use this function to destroy a shared cursor. A shared cursor is valid as long as the module from which it was loaded remains in memory. The following functions obtain a shared cursor: This doc was truncated. Read more on docs.microsoft.com. Registers a window class for subsequent use in calls to the CreateWindow or CreateWindowEx function. (RegisterClassExW) Type: ATOM If the function succeeds, the return value is a class atom that uniquely identifies the class being registered. This atom can only be used by the CreateWindow, CreateWindowEx, GetClassInfo, GetClassInfoEx, FindWindow, FindWindowEx, and UnregisterClass functions and the IActiveIMMap::FilterClientWindows method. If the function fails, the return value is zero. To get extended error information, call GetLastError. If you register the window class by using RegisterClassExA, the application tells the system that the windows of the created class expect messages with text or character parameters to use the ANSI character set; if you register it by using RegisterClassExW, the application requests that the system pass text parameters of messages as Unicode. The IsWindowUnicode function enables applications to query the nature of each window. For more information on ANSI and Unicode functions, see Conventions for Function Prototypes. All window classes that an application registers are unregistered when it terminates. No window classes registered by a DLL are unregistered when the DLL is unloaded. A DLL must explicitly unregister its classes when it is unloaded. Read more on docs.microsoft.com. The MonitorFromRect function retrieves a handle to the display monitor that has the largest area of intersection with a specified rectangle. A pointer to a RECT structure that specifies the rectangle of interest in virtual-screen coordinates. Determines the function's return value if the rectangle does not intersect any display monitor. If the rectangle intersects one or more display monitor rectangles, the return value is an HMONITOR handle to the display monitor that has the largest area of intersection with the rectangle. If the rectangle does not intersect a display monitor, the return value depends on the value of dwFlags. Learn more about this API from docs.microsoft.com. Retrieves information about the specified window. (GetWindowLongW) Type: HWND A handle to the window and, indirectly, the class to which the window belongs. Read more on docs.microsoft.com. Type: int Type: LONG If the function succeeds, the return value is the requested value. If the function fails, the return value is zero. To get extended error information, call GetLastError. If SetWindowLong has not been called previously, GetWindowLong returns zero for values in the extra window or class memory. Reserve extra window memory by specifying a nonzero value in the cbWndExtra member of the WNDCLASSEX structure used with the RegisterClassEx function. Read more on docs.microsoft.com. Changes an attribute of the specified window. The function also sets the 32-bit (long) value at the specified offset into the extra window memory. (Unicode) Type: HWND A handle to the window and, indirectly, the class to which the window belongs. Read more on docs.microsoft.com. Type: int Type: LONG The replacement value. Read more on docs.microsoft.com. Type: LONG If the function succeeds, the return value is the previous value of the specified 32-bit integer. If the function fails, the return value is zero. To get extended error information, call GetLastError. If the previous value of the specified 32-bit integer is zero, and the function succeeds, the return value is zero, but the function does not clear the last error information. This makes it difficult to determine success or failure. To deal with this, you should clear the last error information by calling SetLastError with 0 before calling SetWindowLong. Then, function failure will be indicated by a return value of zero and a GetLastError result that is nonzero. Certain window data is cached, so changes you make using SetWindowLong will not take effect until you call the SetWindowPos function. Specifically, if you change any of the frame styles, you must call SetWindowPos with the SWP_FRAMECHANGED flag for the cache to be updated properly. If you use SetWindowLong with the GWL_WNDPROC index to replace the window procedure, the window procedure must conform to the guidelines specified in the description of the WindowProc callback function. If you use SetWindowLong with the DWL_MSGRESULT index to set the return value for a message processed by a dialog procedure, you should return TRUE directly afterward. Otherwise, if you call any function that results in your dialog procedure receiving a window message, the nested window message could overwrite the return value you set using DWL_MSGRESULT. Calling SetWindowLong with the GWL_WNDPROC index creates a subclass of the window class used to create the window. An application can subclass a system class, but should not subclass a window class created by another process. The SetWindowLong function creates the window subclass by changing the window procedure associated with a particular window class, causing the system to call the new window procedure instead of the previous one. An application must pass any messages not processed by the new window procedure to the previous window procedure by calling CallWindowProc. This allows the application to create a chain of window procedures. Reserve extra window memory by specifying a nonzero value in the cbWndExtra member of the WNDCLASSEX structure used with the RegisterClassEx function. You must not call SetWindowLong with the GWL_HWNDPARENT index to change the parent of a child window. Instead, use the SetParent function. If the window has a class style of CS_CLASSDC or CS_OWNDC, do not set the extended window styles WS_EX_COMPOSITED or WS_EX_LAYERED. Calling SetWindowLong to set the style on a progressbar will reset its position. Read more on docs.microsoft.com. Changes the size, position, and Z order of a child, pop-up, or top-level window. These windows are ordered according to their appearance on the screen. The topmost window receives the highest rank and is the first window in the Z order. Type: HWND A handle to the window. Read more on docs.microsoft.com. Type: HWND Type: int The new position of the left side of the window, in client coordinates. Read more on docs.microsoft.com. Type: int The new position of the top of the window, in client coordinates. Read more on docs.microsoft.com. Type: int The new width of the window, in pixels. Read more on docs.microsoft.com. Type: int The new height of the window, in pixels. Read more on docs.microsoft.com. Type: UINT 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. As part of the Vista re-architecture, all services were moved off the interactive desktop into Session 0. hwnd and window manager operations are only effective inside a session and cross-session attempts to manipulate the hwnd will fail. For more information, see The Windows Vista Developer Story: Application Compatibility Cookbook. If you have changed certain window data using SetWindowLong, you must call SetWindowPos for the changes to take effect. Use the following combination for uFlags: SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED. A window can be made a topmost window either by setting the hWndInsertAfter parameter to HWND_TOPMOST and ensuring that the SWP_NOZORDER flag is not set, or by setting a window's position in the Z order so that it is above any existing topmost windows. When a non-topmost window is made topmost, its owned windows are also made topmost. Its owners, however, are not changed. If neither the SWP_NOACTIVATE nor SWP_NOZORDER flag is specified (that is, when the application requests that a window be simultaneously activated and its position in the Z order changed), the value specified in hWndInsertAfter is used only in the following circumstances. This doc was truncated. Read more on docs.microsoft.com. Loads the specified cursor resource from the executable (.EXE) file associated with an application instance. (Unicode) Type: HINSTANCE A handle to an instance of the module whose executable file contains the cursor to be loaded. Read more on docs.microsoft.com. Type: LPCTSTR The name of the cursor resource to be loaded. Alternatively, this parameter can consist of the resource identifier in the low-order word and zero in the high-order word. The MAKEINTRESOURCE macro can also be used to create this value. To use one of the predefined cursors, the application must set the hInstance parameter to NULL and the lpCursorName parameter to one the following values. This doc was truncated. Read more on docs.microsoft.com. Type: HCURSOR If the function succeeds, the return value is the handle to the newly loaded cursor. If the function fails, the return value is NULL. To get extended error information, call GetLastError. The LoadCursor function loads the cursor resource only if it has not been loaded; otherwise, it retrieves the handle to the existing resource. This function returns a valid cursor handle only if the lpCursorName parameter is a pointer to a cursor resource. If lpCursorName is a pointer to any type of resource other than a cursor (such as an icon), the return value is not NULL, even though it is not a valid cursor handle. The LoadCursor function searches the cursor resource most appropriate for the cursor for the current display device. The cursor resource can be a color or monochrome bitmap.

DPI Virtualization

This API does not participate in DPI virtualization. The output returned is not affected by the DPI of the calling thread. Read more on docs.microsoft.com. Synthesizes a keystroke. Type: BYTE A virtual-key code. The code must be a value in the range 1 to 254. For a complete list, see Virtual Key Codes. Read more on docs.microsoft.com. Type: BYTE A hardware scan code for the key. Read more on docs.microsoft.com. Type: DWORD Type: ULONG_PTR An additional value associated with the key stroke. Read more on docs.microsoft.com. An application can simulate a press of the PRINTSCRN key in order to obtain a screen snapshot and save it to the clipboard. To do this, call keybd_event with the bVk parameter set to VK_SNAPSHOT. Read more on docs.microsoft.com. Retrieves the dimensions of the bounding rectangle of the specified window. The dimensions are given in screen coordinates that are relative to the upper-left corner of the screen. Type: HWND A handle to the window. Read more on docs.microsoft.com. Type: LPRECT A pointer to a RECT structure that receives the screen coordinates of the upper-left and lower-right corners of the window. Read more on docs.microsoft.com. 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. In conformance with conventions for the RECT structure, the bottom-right coordinates of the returned rectangle are exclusive. In other words, the pixel at (right, bottom) lies immediately outside the rectangle. GetWindowRect is virtualized for DPI. In Windows Vista and later, the Window Rect now includes the area occupied by the drop shadow. Calling GetWindowRect will have different behavior depending on whether the window has ever been shown or not. If the window has not been shown before, GetWindowRect will not include the area of the drop shadow. To get the window bounds excluding the drop shadow, use DwmGetWindowAttribute, specifying DWMWA_EXTENDED_FRAME_BOUNDS. Note that unlike the Window Rect, the DWM Extended Frame Bounds are not adjusted for DPI. Getting the extended frame bounds can only be done after the window has been shown at least once. Read more on docs.microsoft.com. Describes a pointer. Learn more about this API from docs.microsoft.com. Pointer to a function. Pointer to a variable, constant, or data member. The ITypeComp that binds the pointer. Identifies the calling convention used by a member function described in the METHODDATA structure. Learn more about this API from docs.microsoft.com. Values that are used in activation calls to indicate the execution contexts in which an object is to be run. Values from the CLSCTX enumeration are used in activation calls (CoCreateInstance, CoCreateInstanceEx, CoGetClassObject, and so on) to indicate the preferred execution contexts (in-process, local, or remote) in which an object is to be run. They are also used in calls to CoRegisterClassObject to indicate the set of execution contexts in which a class object is to be made available for requests to construct instances (IClassFactory::CreateInstance). To indicate that more than one context is acceptable, you can combine multiple values with Boolean ORs. The contexts are tried in the order in which they are listed. Given a set of CLSCTX flags, the execution context to be used depends on the availability of registered class codes and other parameters according to the following algorithm. This doc was truncated. Read more on docs.microsoft.com. The code that creates and manages objects of this class is a DLL that runs in the same process as the caller of the function specifying the class context. The code that manages objects of this class is an in-process handler. This is a DLL that runs in the client process and implements client-side structures of this class when instances of the class are accessed remotely. The EXE code that creates and manages objects of this class runs on same machine but is loaded in a separate process space. Obsolete. A remote context. The LocalServer32 or LocalService code that creates and manages objects of this class is run on a different computer. Obsolete. Reserved. Reserved. Reserved. Reserved. Disables the downloading of code from the directory service or the Internet. This flag cannot be set at the same time as CLSCTX_ENABLE_CODE_DOWNLOAD. Reserved. Specify if you want the activation to fail if it uses custom marshalling. Enables the downloading of code from the directory service or the Internet. This flag cannot be set at the same time as CLSCTX_NO_CODE_DOWNLOAD. The CLSCTX_NO_FAILURE_LOG can be used to override the logging of failures in CoCreateInstanceEx. If the ActivationFailureLoggingLevel is created, the following values can determine the status of event logging: This doc was truncated. Read more on docs.microsoft.com. Disables activate-as-activator (AAA) activations for this activation only. This flag overrides the setting of the EOAC_DISABLE_AAA flag from the EOLE_AUTHENTICATION_CAPABILITIES enumeration. This flag cannot be set at the same time as CLSCTX_ENABLE_AAA. Any activation where a server process would be launched under the caller's identity is known as an activate-as-activator (AAA) activation. Disabling AAA activations allows an application that runs under a privileged account (such as LocalSystem) to help prevent its identity from being used to launch untrusted components. Library applications that use activation calls should always set this flag during those calls. This helps prevent the library application from being used in an escalation-of-privilege security attack. This is the only way to disable AAA activations in a library application because the EOAC_DISABLE_AAA flag from the EOLE_AUTHENTICATION_CAPABILITIES enumeration is applied only to the server process and not to the library application. Windows 2000:  This flag is not supported. Read more on docs.microsoft.com. Enables activate-as-activator (AAA) activations for this activation only. This flag overrides the setting of the EOAC_DISABLE_AAA flag from the EOLE_AUTHENTICATION_CAPABILITIES enumeration. This flag cannot be set at the same time as CLSCTX_DISABLE_AAA. Any activation where a server process would be launched under the caller's identity is known as an activate-as-activator (AAA) activation. Enabling this flag allows an application to transfer its identity to an activated component. Windows 2000:  This flag is not supported. Read more on docs.microsoft.com. Begin this activation from the default context of the current apartment. Activate or connect to a 32-bit version of the server; fail if one is not registered. Activate or connect to a 64 bit version of the server; fail if one is not registered. When this flag is specified, COM uses the impersonation token of the thread, if one is present, for the activation request made by the thread. When this flag is not specified or if the thread does not have an impersonation token, COM uses the process token of the thread's process for the activation request made by the thread. Windows Vista or later:  This flag is supported. Read more on docs.microsoft.com. Indicates activation is for an app container.
Note  This flag is reserved for internal use and is not intended to be used directly from your code.
 
 Read more on docs.microsoft.com. Specify this flag for Interactive User activation behavior for As-Activator servers. A strongly named Medium IL Windows Store app can use this flag to launch an "As Activator" COM server without a strong name. Also, you can use this flag to bind to a running instance of the COM server that's launched by a desktop application. The client must be Medium IL, it must be strongly named, which means that it has a SysAppID in the client token, it can't be in session 0, and it must have the same user as the session ID's user in the client token. If the server is out-of-process and "As Activator", it launches the server with the token of the client token's session user. This token won't be strongly named. If the server is out-of-process and RunAs "Interactive User", this flag has no effect. If the server is out-of-process and is any other RunAs type, the activation fails. This flag has no effect for in-process servers. Off-machine activations fail when they use this flag. Read more on docs.microsoft.com. Used for loading Proxy/Stub DLLs.
Note  This flag is reserved for internal use and is not intended to be used directly from your code.
 
 Read more on docs.microsoft.com. The CY structure is useful for calculations involving money, or for any fixed-point calculation where accuracy is particularly important. Identifies the type description being bound to. Learn more about this API from docs.microsoft.com. No match was found. A FUNCDESC was returned. A VARDESC was returned. A TYPECOMP was returned. An IMPLICITAPPOBJ was returned. The end of the enum. Contains the arguments passed to a method or property. Learn more about this API from docs.microsoft.com. An array of arguments. **Note**: these arguments appear in reverse order Read more on docs.microsoft.com. The dispatch IDs of the named arguments. The number of arguments. The number of named arguments. The ELEMDESC structure contains the type description and process-transfer information for a variable, a function, or a function parameter. (ELEMDESC) The type of the element. Describes an exception that occurred during IDispatch::Invoke. Use the pfnDeferredFillIn field to enable an object to defer filling in the bstrDescription, bstrHelpFile, and dwHelpContext fields until they are needed. This field might be used, for example, if loading the string for the error is a time-consuming operation. To use deferred fill-in, the object puts a function pointer in this slot and does not fill any of the other fields except wCode, which is required. To get additional information, the caller passes the EXCEPINFO structure back to the pexcepinfo callback function, which fills in the additional information. When the ActiveX object and the ActiveX client are in different processes, the ActiveX object calls pfnDeferredFillIn before returning to the controller. Read more on docs.microsoft.com. The error code. Error codes should be greater than 1000. Either this field or the scode field must be filled in; the other must be set to 0. Reserved. Should be 0. The name of the exception source. Typically, this is an application name. This field should be filled in by the implementer of IDispatch. The exception description to display. If no description is available, use null. The fully qualified help file path. If no Help is available, use null. The help context ID. Reserved. Must be null. Provides deferred fill-in. If deferred fill-in is not desired, this field should be set to null. A return value that describes the error. Either this field or wCode (but not both) must be filled in; the other must be set to 0. (16-bit Windows versions only.) Describes a function. (FUNCDESC) The cParams field specifies the total number of required and optional parameters. The cParamsOpt field specifies the form of optional parameters accepted by the function, as follows: This doc was truncated. Read more on docs.microsoft.com. The function member ID. The status code. Description of the element. Indicates the type of function (virtual, static, or dispatch-only). The invocation type. Indicates whether this is a property function, and if so, which type. The calling convention. The total number of parameters. The number of optional parameters. For FUNC_VIRTUAL, specifies the offset in the VTBL. The number of possible return values. The function return type. The function flags. See FUNCFLAGS. Specifies function flags. FUNCFLAG_FHIDDEN means that the property should never be shown in object browsers, property browsers, and so on. This function is useful for removing items from an object model. Code can bind to the member, but the user will never know that the member exists. FUNCFLAG_FNONBROWSABLE means that the property should not be displayed in a properties browser. It is used in circumstances in which an error would occur if the property were shown in a properties browser. FUNCFLAG_FRESRICTED means that macro-oriented programmers should not be allowed to access this member. These members are usually treated as _FHIDDEN by tools such as Visual Basic, with the main difference being that code cannot bind to those members. Read more on docs.microsoft.com. The function should not be accessible from macro languages. This flag is intended for system-level functions or functions that type browsers should not display. The function returns an object that is a source of events. The function that supports data binding. When set, any call to a method that sets the property results first in a call to IPropertyNotifySink::OnRequestEdit. The implementation of OnRequestEdit determines if the call is allowed to set the property. The function that is displayed to the user as bindable. FUNC_FBINDABLE must also be set. The function that best represents the object. Only one function in a type information can have this attribute. The function should not be displayed to the user, although it exists and is bindable. The function supports GetLastError. If an error occurs during the function, the caller can call GetLastError to retrieve the error code. Permits an optimization in which the compiler looks for a member named xyz on the type of abc. If such a member is found and is flagged as an accessor function for an element of the default collection, then a call is generated to that member function. Permitted on members in dispinterfaces and interfaces; not permitted on modules. For more information, refer to defaultcollelem in Type Libraries and the Object Description Language. The type information member is the default member for display in the user interface. The property appears in an object browser, but not in a properties browser. Tags the interface as having default behaviors. Mapped as individual bindable properties. Specifies the function type. Learn more about this API from docs.microsoft.com. The function is accessed the same as PUREVIRTUAL, except the function has an implementation. The function is accessed through the virtual function table (VTBL), and takes an implicit this pointer. The function is accessed by static address and takes an implicit this pointer. The function is accessed by static address and does not take an implicit this pointer. The function can be accessed only through IDispatch. Retrieves the number of type information interfaces that an object provides (either 0 or 1). The number of type information interfaces provided by the object. If the object provides type information, this number is 1; otherwise the number is 0. This method can return one of these values. This doc was truncated. The method may return zero, which indicates that the object does not provide any type information. In this case, the object may still be programmable through IDispatch or a VTBL, but does not provide run-time type information for browsers, compilers, or other programming tools that access type information. This can be useful for hiding an object from browsers. Retrieves the type information for an object, which can then be used to get the type information for an interface. The type information to return. Pass 0 to retrieve type information for the IDispatch implementation. The locale identifier for the type information. An object may be able to return different type information for different languages. This is important for classes that support localized member names. For classes that do not support localized member names, this parameter can be ignored. The requested type information object. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Maps a single member and an optional set of argument names to a corresponding set of integer DISPIDs, which can be used on subsequent calls to Invoke. Reserved for future use. Must be IID_NULL. The array of names to be mapped. The count of the names to be mapped. The locale context in which to interpret the names. Caller-allocated array, each element of which contains an identifier (ID) corresponding to one of the names passed in the rgszNames array. The first element represents the member name. The subsequent elements represent each of the member's parameters. This method can return one of these values. This doc was truncated. An IDispatch implementation can associate any positive integer ID value with a given name. Zero is reserved for the default, or Value property; –1 is reserved to indicate an unknown name; and other negative values are defined for other purposes. For example, if GetIDsOfNames is called, and the implementation does not recognize one or more of the names, it returns DISP_E_UNKNOWNNAME, and the rgDispId array contains DISPID_UNKNOWN for the entries that correspond to the unknown names. The member and parameter DISPIDs must remain constant for the lifetime of the object. This allows a client to obtain the DISPIDs once, and cache them for later use. When GetIDsOfNames is called with more than one name, the first name (rgszNames[0]) corresponds to the member name, and subsequent names correspond to the names of the member's parameters. The same name may map to different DISPIDs, depending on context. For example, a name may have a DISPID when it is used as a member name with a particular interface, a different ID as a member of a different interface, and different mapping for each time it appears as a parameter. GetIDsOfNames is used when an IDispatch client binds to names at run time. To bind at compile time instead, an IDispatch client can map names to DISPIDs by using the type information interfaces described in Type Description Interfaces. This allows a client to bind to members at compile time and avoid calling GetIDsOfNames at run time. For a description of binding at compile time, see Type Description Interfaces. The implementation of GetIDsOfNames is case insensitive. Users that need case-sensitive name mapping should use type information interfaces to map names to DISPIDs, rather than call GetIDsOfNames.
Caution  You cannot use this method to access values that have been added dynamically, such as values added through JavaScript. Instead, use the GetDispID of the IDispatchEx interface. For more information, see the IDispatchEx interface.
 
 Read more on docs.microsoft.com. Provides access to properties and methods exposed by an object. Identifies the member. Use GetIDsOfNames or the object's documentation to obtain the dispatch identifier. Reserved for future use. Must be IID_NULL. The locale context in which to interpret arguments. The lcid is used by the GetIDsOfNames function, and is also passed to Invoke to allow the object to interpret its arguments specific to a locale. Applications that do not support multiple national languages can ignore this parameter. For more information, refer to Supporting Multiple National Languages and Exposing ActiveX Objects. Read more on docs.microsoft.com. Flags describing the context of the Invoke call. This doc was truncated. Read more on docs.microsoft.com. Pointer to a DISPPARAMS structure containing an array of arguments, an array of argument DISPIDs for named arguments, and counts for the number of elements in the arrays. Pointer to the location where the result is to be stored, or NULL if the caller expects no result. This argument is ignored if DISPATCH_PROPERTYPUT or DISPATCH_PROPERTYPUTREF is specified. Pointer to a structure that contains exception information. This structure should be filled in if DISP_E_EXCEPTION is returned. Can be NULL. The index within rgvarg of the first argument that has an error. Arguments are stored in pDispParams->rgvarg in reverse order, so the first argument is the one with the highest index in the array. This parameter is returned only when the resulting return value is DISP_E_TYPEMISMATCH or DISP_E_PARAMNOTFOUND. This argument can be set to null. For details, see Returning Errors. This method can return one of these values. This doc was truncated. Generally, you should not implement Invoke directly. Instead, use the dispatch interface to create functions CreateStdDispatch and DispInvoke. For details, refer to CreateStdDispatch, DispInvoke, Creating the IDispatch Interface and Exposing ActiveX Objects. If some application-specific processing needs to be performed before calling a member, the code should perform the necessary actions, and then call ITypeInfo::Invoke to invoke the member. ITypeInfo::Invoke acts exactly like Invoke. The standard implementations of Invoke created by CreateStdDispatch and DispInvoke defer to ITypeInfo::Invoke. In an ActiveX client, Invoke should be used to get and set the values of properties, or to call a method of an ActiveX object. The dispIdMember argument identifies the member to invoke. The DISPIDs that identify members are defined by the implementer of the object and can be determined by using the object's documentation, the IDispatch::GetIDsOfNames function, or the ITypeInfo interface. When you use IDispatch::Invoke() with DISPATCH_PROPERTYPUT or DISPATCH_PROPERTYPUTREF, you have to specially initialize the cNamedArgs and rgdispidNamedArgs elements of your DISPPARAMS structure with the following: This doc was truncated. Read more on docs.microsoft.com. The IID guid for this interface. {00020400-0000-0000-c000-000000000046} Specifies the way a function is invoked. In C, value assignment is written as *pobj1 = *pobj2, while reference assignment is written as pobj1 = pobj2. Other languages have other syntactic conventions. A property or data member can support only a value assignment, a reference assignment, or both. The INVOKEKIND enumeration constants are the same constants that are passed to IDispatch::Invoke to specify the way in which a function is invoked. The member is called using a normal function invocation syntax. The function is invoked using a normal property-access syntax. The function is invoked using a property value assignment syntax. Syntactically, a typical programming language might represent changing a property in the same way as assignment. For example: object.property : = value. The function is invoked using a property reference assignment syntax. Maps a name to a member of a type, or binds global variables and functions contained in a type library. The name to be bound. The hash value for the name computed by LHashValOfNameSys. One or more of the flags defined in the INVOKEKIND enumeration. Specifies whether the name was referenced as a method or a property. When binding to a variable, specify the flag INVOKE_PROPERTYGET. Specify zero to bind to any type of member. If a FUNCDESC or VARDESC was returned, then ppTInfo points to a pointer to the type description that contains the item to which it is bound. Indicates whether the name bound to is a VARDESC, FUNCDESC, or TYPECOMP. If there was no match, DESCKIND_NONE. The bound-to VARDESC, FUNCDESC, or ITypeComp interface. This method can return one of these values. This doc was truncated. Use Bind for binding to the variables and methods of a type, or for binding to the global variables and methods in a type library. The returned DESCKIND pointer pDescKind indicates whether the name was bound to a VARDESC, a FUNCDESC, or to an ITypeComp instance. The returned pBindPtr points to the VARDESC, FUNCDESC, or ITypeComp. If a data member or method is bound to, then ppTInfopoints to the type description that contains the method or data member. If Bind binds the name to a nested binding context, it returns a pointer to an ITypeComp instance in pBindPtr and a null type description pointer in ppTInfo. For example, if the name of a type description is passed for a module (TKIND_MODULE), enumeration (TKIND_ENUM), or coclass (TKIND_COCLASS), Bind returns the ITypeComp instance of the type description for the module, enumeration, or coclass. This feature supports languages such as Visual Basic that allow references to members of a type description to be qualified by the name of the type description. For example, a function in a module can be referenced by modulename.functionname. The members of TKIND_ENUM, TKIND_MODULE, and TKIND_COCLASS types marked as Application objects can be bound to directly from ITypeComp, without specifying the name of the module. The ITypeComp of a coclass defers to the ITypeComp of its default interface. As with other methods of ITypeComp, ITypeInfo, and ITypeInfo, the calling code is responsible for releasing the returned object instances or structures. If a VARDESC or FUNCDESC is returned, the caller is responsible for deleting it with the returned type description and releasing the type description instance itself. Otherwise, if an ITypeComp instance is returned, the caller must release it. Special rules apply if you call a type library's Bind method, passing it the name of a member of an Application object class (a class that has the TYPEFLAG_FAPPOBJECT flag set). In this case, Bind returns DESCKIND_IMPLICITAPPOBJ in pDescKind, a VARDESC that describes the Application object in pBindPtr, and the ITypeInfo of the Application object class in ppTInfo. To bind to the object, ITypeInfo::GetTypeComp must make a call to get the ITypeComp of the Application object class, and then reinvoke its Bind method with the name initially passed to the type library's ITypeComp. The caller should use the returned ITypeInfo pointer (ppTInfo) to get the address of the member.
Note  The wflags parameter is the same as the wflags parameter in IDispatch::Invoke.
 
 Read more on docs.microsoft.com. Binds to the type descriptions contained within a type library. The name to be bound. The hash value for the name computed by LHashValOfName. An ITypeInfo of the type to which the name was bound. Passes a valid pointer, such as the address of an ITypeComp variable. This method can return one of these values. This doc was truncated. Use the function BindType for binding a type name to the ITypeInfo that describes the type. This function is invoked on the ITypeComp that is returned by ITypeLib::GetTypeComp to bind to types defined within that library. It can also be used in the future for binding to nested types. The IID guid for this interface. {00020403-0000-0000-c000-000000000046} Retrieves a TYPEATTR structure that contains the attributes of the type description. The attributes of this type description. This method can return one of these values. This doc was truncated. To free the TYPEATTR structure, use ITypeInfo::ReleaseTypeAttr. Retrieves the ITypeComp interface for the type description, which enables a client compiler to bind to the type description's members. The ITypeComp of the containing type library. This method can return one of these values. This doc was truncated. A client compiler can use the ITypeComp interface to bind to members of the type. Retrieves the FUNCDESC structure that contains information about a specified function. The index of the function whose description is to be returned. The index should be in the range of 0 to 1 less than the number of functions in this type. A FUNCDESC structure that describes the specified function. This method can return one of these values. This doc was truncated. The function ITypeInfo::GetFuncDesc provides access to a FUNCDESC structure that describes the function with the specified index. The FUNCDESC structure should be freed with ITypeInfo::ReleaseFuncDesc. The number of functions in the type is one of the attributes contained in the TYPEATTR structure. Retrieves a VARDESC structure that describes the specified variable. The index of the variable whose description is to be returned. The index should be in the range of 0 to 1 less than the number of variables in this type. A VARDESC that describes the specified variable. This method can return one of these values. This doc was truncated. To free the VARDESC structure, use ReleaseVarDesc. Retrieves the variable with the specified member ID or the name of the property or method and the parameters that correspond to the specified function ID. The ID of the member whose name (or names) is to be returned. The caller-allocated array. On return, each of the elements contains the name (or names) associated with the member. The length of the passed-in rgBstrNames array. The number of names in the rgBstrNames array. This method can return one of these values. This doc was truncated. The caller must release the returned BSTR array. If the member ID identifies a property that is implemented with property functions, the property name is returned. For property get functions, the names of the function and its parameters are always returned. For property put and put reference functions, the right side of the assignment is unnamed. If cMaxNames is less than is required to return all of the names of the parameters of a function, then only the names of the first cMaxNames - 1 parameters are returned. The names of the parameters are returned in the array in the same order that they appear elsewhere in the interface (for example, the same order in the parameter array associated with the FUNCDESC enumeration). If the type description inherits from another type description, this function is recursive to the base type description, if necessary, to find the item with the requested member ID. Read more on docs.microsoft.com. If a type description describes a COM class, it retrieves the type description of the implemented interface types. The index of the implemented type whose handle is returned. The valid range is 0 to the cImplTypes field in the TYPEATTR structure. A handle for the implemented interface (if any). This handle can be passed to ITypeInfo::GetRefTypeInfo to get the type description. This method can return one of these values. This doc was truncated. If the TKIND_DISPATCH type description is for a dual interface, the TKIND_INTERFACE type description can be obtained by calling GetRefTypeOfImplType with an index of –1, and by passing the returned pRefTypehandle to GetRefTypeInfo to retrieve the type information. Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface or base interface in a type description. The index of the implemented interface or base interface for which to get the flags. The IMPLTYPEFLAGS enumeration value. This method can return one of these values. This doc was truncated. The flags are associated with the act of inheritance, and not with the inherited interface. Maps between member names and member IDs, and parameter names and parameter IDs. An array of names to be mapped. The count of the names to be mapped. Caller-allocated array in which name mappings are placed. This method can return one of these values. This doc was truncated. The function GetIDsOfNames maps the name of a member (rgszNames[0]) and its parameters (rgszNames[1] ...rgszNames[cNames- 1]) to the ID of the member (pMemId[0]), and to the IDs of the specified parameters (pMemId[1] ... pMemId[cNames- 1]). The IDs of parameters are 0 for the first parameter in the member function's argument list, 1 for the second, and so on. If the type description inherits from another type description, this function is recursive to the base type description, if necessary, to find the item with the requested member ID. Read more on docs.microsoft.com. Invokes a method, or accesses a property of an object, that implements the interface described by the type description. An instance of the interface described by this type description. The interface member. Flags describing the context of the invoke call. This doc was truncated. Read more on docs.microsoft.com. An array of arguments, an array of DISPIDs for named arguments, and counts of the number of elements in each array. The result. Should be null if the caller does not expect any result. If wFlags specifies DISPATCH_PROPERTYPUT or DISPATCH_PROPERTYPUTREF, pVarResultis is ignored. An exception information structure, which is filled in only if DISP_E_EXCEPTION is returned. If pExcepInfo is null on input, only an HRESULT error will be returned. If Invoke returns DISP_E_TYPEMISMATCH, puArgErr indicates the index (within rgvarg) of the argument with incorrect type. If more than one argument returns an error, puArgErr indicates only the first argument with an error. Arguments in pDispParams->rgvarg appear in reverse order, so the first argument is the one having the highest index in the array. This parameter cannot be null. This doc was truncated. Use the function ITypeInfo::Invoke to access a member of an object or invoke a method that implements the interface described by this type description. For objects that support the IDispatch interface, you can use Invoke to implement IDispatch::Invoke. ITypeInfo::Invoke takes a pointer to an instance of the class. Otherwise, its parameters are the same as IDispatch::Invoke, except that ITypeInfo::Invoke omits the refiid and lcid parameters. When called, ITypeInfo::Invoke performs the actions described by the IDispatch::Invoke parameters on the specified instance. For VTBL interface members, ITypeInfo::Invoke passes the LCID of the type information into parameters tagged with the lcid attribute, and the returned value into the retval attribute. If the type description inherits from another type description, this function recurses on the base type description to find the item with the requested member ID. Read more on docs.microsoft.com. Retrieves the documentation string, the complete Help file name and path, and the context ID for the Help topic for a specified type description. The ID of the member whose documentation is to be returned. The name of the specified item. If the caller does not need the item name, pBstrName can be null. The documentation string for the specified item. If the caller does not need the documentation string, pBstrDocString can be null. The Help localization context. If the caller does not need the Help context, it can be null. The fully qualified name of the file containing the DLL used for Help file. If the caller does not need the file name, it can be null. This method can return one of these values. This doc was truncated. The function GetDocumentation provides access to the documentation for the member specified by the memid parameter. If the passed-in memid is MEMBERID_NIL, then the documentation for the type description is returned. If the type description inherits from another type description, this function is recursive to the base type description, if necessary, to find the item with the requested member ID. The caller should use SysFreeString to free the BSTRs referenced by pBstrName, pBstrDocString, and pBstrHelpFile. Read more on docs.microsoft.com. Retrieves a description or specification of an entry point for a function in a DLL. The ID of the member function whose DLL entry description is to be returned. The kind of member identified by memid. This is important for properties, because one memid can identify up to three separate functions. If not null, the function sets pBstrDllName to the name of the DLL. If not null, the function sets pBstrName to the name of the entry point. If the entry point is specified by an ordinal, this argument is null. If not null, and if the function is defined by an ordinal, the function sets pwOrdinal to the ordinal. This method can return one of these values. This doc was truncated. The caller passes in a member ID, which represents the member function whose entry description is desired. If the function has a DLL entry point, the name of the DLL that contains the function, as well as its name or ordinal identifier, are placed in the passed-in pointers allocated by the caller. If there is no DLL entry point for the function, an error is returned. If the type description inherits from another type description, this function is recursive to the base type description, if necessary, to find the item with the requested member ID. The caller should use SysFreeString to free the BSTRs referenced by pBstrName and pBstrDllName. Read more on docs.microsoft.com. If a type description references other type descriptions, it retrieves the referenced type descriptions. A handle to the referenced type description to return. The referenced type description. This method can return one of these values. This doc was truncated. On return, the second parameter contains a pointer to a pointer to a type description that is referenced by this type description. A type description must have a reference to each type description that occurs as the type of any of its variables, function parameters, or function return types. For example, if the type of a data member is a record type, the type description for that data member contains the hRefType of a referenced type description. To get a pointer to the type description, the reference is passed to GetRefTypeInfo. Retrieves the addresses of static functions or variables, such as those defined in a DLL. The member ID of the static member whose address is to be retrieved. The member ID is defined by the DISPID. Indicates whether the member is a property, and if so, what kind. The static member. This method can return one of these values. This doc was truncated. The addresses are valid until the caller releases its reference to the type description. The invKind parameter can be ignored unless the address of a property function is being requested. If the type description inherits from another type description, this function is recursive to the base type description, if necessary, to find the item with the requested member ID. Read more on docs.microsoft.com. Creates a new instance of a type that describes a component object class (coclass). The controlling IUnknown. If Null, then a stand-alone instance is created. If valid, then an aggregate object is created. An ID for the interface that the caller will use to communicate with the resulting object. An instance of the created object. This doc was truncated. For types that describe a component object class (coclass), CreateInstance creates a new instance of the class. Normally, CreateInstance calls CoCreateInstance with the type description's GUID. For an Application object, it first calls GetActiveObject. If the application is active, GetActiveObject returns the active object; otherwise, if GetActiveObject fails, CreateInstance calls CoCreateInstance. Retrieves marshaling information. The member ID that indicates which marshaling information is needed. The opcode string used in marshaling the fields of the structure described by the referenced type description, or null if there is no information to return. This method can return one of these values. This doc was truncated. If the passed-in member ID is MEMBERID_NIL, the function returns the opcode string for marshaling the fields of the structure described by the type description. Otherwise, it returns the opcode string for marshaling the function specified by the index. If the type description inherits from another type description, this function recurses on the base type description, if necessary, to find the item with the requested member ID. Read more on docs.microsoft.com. Retrieves the containing type library and the index of the type description within that type library. The containing type library. The index of the type description within the containing type library. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Releases a TYPEATTR previously returned by ITypeInfo::GetTypeAttr. The TYPEATTR to be freed. Learn more about this API from docs.microsoft.com. Releases a FUNCDESC previously returned by ITypeInfo::GetFuncDesc. The FUNCDESC to be freed. Learn more about this API from docs.microsoft.com. Releases a VARDESC previously returned by ITypeInfo::GetVarDesc. The VARDESC to be freed. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {00020401-0000-0000-c000-000000000046} Provides the number of type descriptions that are in a type library. The number of type descriptions in the type library. Learn more about this API from docs.microsoft.com. Retrieves the specified type description in the library. The index of the interface to be returned. If successful, returns a pointer to the pointer to the ITypeInfo interface. This method can return one of these values. This doc was truncated. For dual interfaces, GetTypeInfo returns only the TKIND_DISPATCH type information. To get the TKIND_INTERFACE type information, GetRefTypeOfImplType can be called on the TKIND_DISPATCH type information, passing an index of –1. Then, the returned type information handle can be passed to GetRefTypeInfo. Retrieves the type of a type description. The index of the type description within the type library. The TYPEKIND enumeration value for the type description. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Retrieves the type description that corresponds to the specified GUID. The GUID of the type description. The ITypeInfo interface. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Retrieves the structure that contains the library's attributes. The library's attributes. This method can return one of these values. This doc was truncated. Use ITypeLib::ReleaseTLibAttr to free the memory occupied by the TLIBATTR structure. Enables a client compiler to bind to the types, variables, constants, and global functions for a library. The ITypeComp instance for this ITypeLib. A client compiler uses the methods in the ITypeComp interface to bind to types in ITypeLib, as well as to the global functions, variables, and constants defined in ITypeLib This method can return one of these values. This doc was truncated. The Bind function of the returned TypeComp binds to global functions, variables, constants, enumerated values, and coclass members. The Bind function also binds the names of the TYPEKIND enumerations of TKIND_MODULE, TKIND_ENUM, and TKIND_COCLASS. These names shadow any global names defined within the type information. The members of TKIND_ENUM, TKIND_MODULE, and TKIND_COCLASS types marked as Application objects can be directly bound to from ITypeComp without specifying the name of the module. ITypeComp::Bind and ITypeComp::BindType accept only unqualified names. ITypeLib::GetTypeComp returns a pointer to the ITypeComp interface, which is then used to bind to global elements in the library. The names of some types (TKIND_ENUM, TKIND_MODULE, and TKIND_COCLASS) share the name space with variables, functions, constants, and enumerators. If a member requires qualification to differentiate it from other items in the name space, GetTypeComp can be called successively for each qualifier in order to bind to the desired member. This allows programming language compilers to access members of modules, enumerations, and coclasses, even though the member can't be bound to with a qualified name. Read more on docs.microsoft.com. Retrieves the documentation string for the library, the complete Help file name and path, and the context identifier for the library Help topic in the Help file. The index of the type description whose documentation is to be returned. If index is -1, then the documentation for the library itself is returned. The name of the specified item. If the caller does not need the item name, then pBstrName can be null. The documentation string for the specified item. If the caller does not need the documentation string, then pBstrDocString can be null.. The Help context identifier (ID) associated with the specified item. If the caller does not need the Help context ID, then pdwHelpContext can be null. The fully qualified name of the Help file. If the caller does not need the Help file name, then pBstrHelpFile can be null. This method can return one of these values. This doc was truncated. The caller should free the parameters pBstrName, pBstrDocString, and pBstrHelpFile. Indicates whether a passed-in string contains the name of a type or member described in the library. The string to test. If this method is successful, szNameBuf is modified to match the case (capitalization) found in the type library. The hash value of szNameBuf. True if szNameBuf was found in the type library; otherwise false. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Finds occurrences of a type description in a type library. This may be used to quickly verify that a name exists in a type library. The name to search for. A hash value to speed up the search, computed by the LHashValOfNameSys function. If lHashVal = 0, a value is computed. An array of pointers to the type descriptions that contain the name specified in szNameBuf. This parameter cannot be null. An array of the found items; rgMemId[i] is the MEMBERID that indexes into the type description specified by ppTInfo[i]. This parameter cannot be null. On entry, indicates how many instances to look for. For example, *pcFound = 1 can be called to find the first occurrence. The search stops when one is found. On exit, indicates the number of instances that were found. If the in and out values of *pcFound are identical, there may be more type descriptions that contain the name. Read more on docs.microsoft.com. This method can return one of these values. This doc was truncated. Passing *pcFound = n indicates that there is enough room in the ppTInfo and rgMemId arrays for n (ptinfo, memid) pairs. The function returns MEMBERID_NIL in rgMemId[i], if the name in szNameBuf is the name of the type information in ppTInfo[i]. Releases the TLIBATTR originally obtained from GetLibAttr. The TLIBATTR to be freed. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {00020402-0000-0000-c000-000000000046} Increments the reference count for an interface pointer to a COM object. You should call this method whenever you make a copy of an interface pointer. The method returns the new reference count. This value is intended to be used only for test purposes. A COM object uses a per-interface reference-counting mechanism to ensure that the object doesn't outlive references to it. You use **AddRef** to stabilize a copy of an interface pointer. It can also be called when the life of a cloned pointer must extend beyond the lifetime of the original pointer. The cloned pointer must be released by calling [IUnknown::Release](/windows/desktop/api/unknwn/nf-unknwn-iunknown-queryinterface(refiid_void)) on it. The internal reference counter that **AddRef** maintains should be a 32-bit unsigned integer. Read more on docs.microsoft.com. Decrements the reference count for an interface on a COM object. The method returns the new reference count. This value is intended to be used only for test purposes. When the reference count on an object reaches zero, **Release** must cause the interface pointer to free itself. When the released pointer is the only (formerly) outstanding reference to an object (whether the object supports single or multiple interfaces), the implementation must free the object. Note that aggregation of objects restricts the ability to recover interface pointers. Read more on docs.microsoft.com. The IID guid for this interface. {00000000-0000-0000-c000-000000000046} Controls the type of connections to a class object. In CoRegisterClassObject, members of both the REGCLS and the CLSCTX enumerations, taken together, determine how the class object is registered. An EXE surrogate (in which DLL servers are run) calls CoRegisterClassObject to register a class factory using a new REGCLS value, REGCLS_SURROGATE. All class factories for DLL surrogates should be registered with REGCLS_SURROGATE set. Do not set REGCLS_SINGLUSE or REGCLS_MULTIPLEUSE when you register a surrogate for DLL servers. The following table summarizes the allowable REGCLS value combinations and the object registrations affected by the combinations. This doc was truncated. Read more on docs.microsoft.com. After an application is connected to a class object with CoGetClassObject, the class object is removed from public view so that no other applications can connect to it. This value is commonly used for single document interface (SDI) applications. Specifying this value does not affect the responsibility of the object application to call CoRevokeClassObject; it must always call CoRevokeClassObject when it is finished with an object class. Multiple applications can connect to the class object through calls to CoGetClassObject. If both the REGCLS_MULTIPLEUSE and CLSCTX_LOCAL_SERVER are set in a call to CoRegisterClassObject, the class object is also automatically registered as an in-process server, whether CLSCTX_INPROC_SERVER is explicitly set. Useful for registering separate CLSCTX_LOCAL_SERVER and CLSCTX_INPROC_SERVER class factories through calls to CoGetClassObject. If REGCLS_MULTI_SEPARATE is set, each execution context must be set separately; CoRegisterClassObject does not automatically register an out-of-process server (for which CLSCTX_LOCAL_SERVER is set) as an in-process server. This allows the EXE to create multiple instances of the object for in-process needs, such as self embeddings, without disturbing its CLSCTX_LOCAL_SERVER registration. If an EXE registers a REGCLS_MULTI_SEPARATE class factory and a CLSCTX_INPROC_SERVER class factory, instance creation calls that specify CLSCTX_INPROC_SERVER in the CLSCTX parameter executed by the EXE would be satisfied locally without approaching the SCM. This mechanism is useful when the EXE uses functions such as OleCreate and OleLoad to create embeddings, but at the same does not wish to launch a new instance of itself for the self-embedding case. The distinction is important for embeddings because the default handler aggregates the proxy manager by default and the application should override this default behavior by calling OleCreateEmbeddingHelper for the self-embedding case. If your application need not distinguish between the local and inproc case, you need not register your class factory using REGCLS_MULTI_SEPARATE. In fact, the application incurs an extra network round trip to the SCM when it registers its MULTIPLEUSE class factory as MULTI_SEPARATE and does not register another class factory as INPROC_SERVER. Read more on docs.microsoft.com. Suspends registration and activation requests for the specified CLSID until there is a call to CoResumeClassObjects. This is used typically to register the CLSIDs for servers that can register multiple class objects to reduce the overall registration time, and thus the server application startup time, by making a single call to the SCM, no matter how many CLSIDs are registered for the server.
Note  This flag prevents COM activation errors from a possible race condition between an application shutting down and that application attempting to register a COM class.
 
 Read more on docs.microsoft.com. The class object is a surrogate process used to run DLL servers. The class factory registered by the surrogate process is not the actual class factory implemented by the DLL server, but a generic class factory implemented by the surrogate. This generic class factory delegates instance creation and marshaling to the class factory of the DLL server running in the surrogate. For further information on DLL surrogates, see the DllSurrogate registry value. The class object aggregates the free-threaded marshaler and will be made visible to all inproc apartments. Can be used together with other flags. For example, REGCLS_AGILE | REGCLS_MULTIPLEUSE to register a class object that can be used multiple times from different apartments. Without other flags, behavior will retain REGCLS_SINGLEUSE semantics in that only one instance can be generated. Read more on docs.microsoft.com. Represents a safe array. The array rgsabound is stored with the left-most dimension in rgsabound[0] and the right-most dimension in rgsabound[cDims - 1]. If an array was specified in a C-like syntax as a [2][5], it would have two elements in the rgsabound vector. Element 0 has an lLbound of 0 and a cElements of 2. Element 1 has an lLbound of 0 and a cElements of 5. The fFeatures flags describe attributes of an array that can affect how the array is released. The fFeatures field describes what type of data is stored in the SAFEARRAY and how the array is allocated. This allows freeing the array without referencing its containing variant. Read more on docs.microsoft.com. The number of dimensions. Flags. This doc was truncated. Read more on docs.microsoft.com. The size of an array element. The number of times the array has been locked without a corresponding unlock. The data. One bound for each dimension. Computes the amount of memory that must be allocated to store this struct, including the specified number of elements in the variable length inline array at the end. Represents the bounds of one dimension of the array. Learn more about this API from docs.microsoft.com. The number of elements in the dimension. The lower bound of the dimension. Identifies the target operating system platform. Learn more about this API from docs.microsoft.com. The target operating system for the type library is 16-bit Windows. By default, data members are packed. The target operating system for the type library is 32-bit Windows. By default, data members are naturally aligned (for example, 2-byte integers are aligned on even-byte boundaries; 4-byte integers are aligned on quad-word boundaries, and so on). The target operating system for the type library is Apple Macintosh. By default, all data members are aligned on even-byte boundaries. The target operating system for the type library is 64-bit Windows. Contains information about a type library. Information from this structure is used to identify the type library and to provide national language support for member names. Learn more about this API from docs.microsoft.com. The globally unique identifier. The locale identifier. The target hardware platform. The major version number. The minor version number. The library flags. Contains attributes of a type. Learn more about this API from docs.microsoft.com. The GUID of the type information. The locale of member names and documentation strings. Reserved. The constructor ID, or MEMBERID_NIL if none. The destructor ID, or MEMBERID_NIL if none. Reserved. The size of an instance of this type. The kind of type. The number of functions. The number of variables or data members. The number of implemented interfaces. The size of this type's VTBL. The byte alignment for an instance of this type. A value of 0 indicates alignment on the 64K boundary; 1 indicates no special alignment. For other values, n indicates aligned on byte n. The type flags. See TYPEFLAGS. The major version number. The minor version number. If typekind is TKIND_ALIAS, specifies the type for which this type is an alias. The IDL attributes of the described type. Describes the type of a variable, the return type of a function, or the type of a function parameter. If the variable is VT_SAFEARRAY or VT_PTR, the union portion of the TYPEDESC contains a pointer to a TYPEDESC that specifies the element type. The variant type. Specifies a type. Learn more about this API from docs.microsoft.com. A set of enumerators. A structure with no methods. A module that can only have static functions and data (for example, a DLL). A type that has virtual and pure functions. A set of methods and properties that are accessible through IDispatch::Invoke. By default, dual interfaces return TKIND_DISPATCH. A set of implemented component object interfaces. A type that is an alias for another type. A union, all of whose members have an offset of zero. End of enum marker. Describes a variable, constant, or data member. Learn more about this API from docs.microsoft.com. The member ID. Reserved. The variable type. The variable flags. See VARFLAGS. The variable type. Specifies variable flags. Learn more about this API from docs.microsoft.com. Assignment to the variable should not be allowed. The variable returns an object that is a source of events. The variable supports data binding. When set, any attempt to directly change the property results in a call to IPropertyNotifySink::OnRequestEdit. The implementation of OnRequestEdit determines if the change is accepted. The variable is displayed to the user as bindable. VARFLAG_FBINDABLE must also be set. The variable is the single property that best represents the object. Only one variable in type information can have this attribute. The variable should not be displayed to the user in a browser, although it exists and is bindable. The variable should not be accessible from macro languages. This flag is intended for system-level variables or variables that you do not want type browsers to display. Permits an optimization in which the compiler looks for a member named "xyz" on the type of abc. If such a member is found and is flagged as an accessor function for an element of the default collection, then a call is generated to that member function. Permitted on members in dispinterfaces and interfaces; not permitted on modules. The variable is the default display in the user interface. The variable appears in an object browser, but not in a properties browser. Tags the interface as having default behaviors. The variable is mapped as individual bindable properties. Specifies the variable type. Learn more about this API from docs.microsoft.com. The variable is a field or member of the type. It exists at a fixed offset within each instance of the type. There is only one instance of the variable. The VARDESC describes a symbolic constant. There is no memory associated with it. The variable can only be accessed through IDispatch::Invoke. Describes an array, its element type, and its dimension. Learn more about this API from docs.microsoft.com. The element type. The dimension count. A variable-length array containing one element for each dimension. Computes the amount of memory that must be allocated to store this struct, including the specified number of elements in the variable length inline array at the end. Initializes a new instance of a record. An instance of a record. This method can return one of these values. This doc was truncated. The caller must allocate the memory of the record by its appropriate size using the GetSize method. RecordInit sets all contents of the record to 0 and the record should hold no resources. Read more on docs.microsoft.com. Releases object references and other values of a record without deallocating the record. The record to be cleared. This method can return one of these values. This doc was truncated. RecordClear releases memory blocks held by VT_PTR or VT_SAFEARRAY instance fields. The caller needs to free the instance fields memory, RecordClear will do nothing if there are no resources held. Copies an existing record into the passed in buffer. The current record instance. The destination where the record will be copied. This method can return one of these values. This doc was truncated. RecordCopy will release the resources in the destination first. The caller is responsible for allocating sufficient memory in the destination by calling GetSize or RecordCreate. If RecordCopy fails to copy any of the fields then all fields will be cleared, as though RecordClear had been called. Gets the GUID of the record type. The class GUID of the TypeInfo that describes the UDT. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Gets the name of the record type. The name. This method can return one of these values. This doc was truncated. The caller must free the BSTR by calling SysFreeString. Gets the number of bytes of memory necessary to hold the record instance. The size of a record instance, in bytes. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Retrieves the type information that describes a UDT or safearray of UDTs. The information type of the record. This method can return one of these values. This doc was truncated. AddRef is called on the pointer ppTypeInfo. Returns a pointer to the VARIANT containing the value of a given field name. The instance of a record. The field name. The VARIANT that you want to hold the value of the field name, szFieldName. On return, places a copy of the field's value in the variant. This method can return one of these values. This doc was truncated. The VARIANT that you pass in contains a copy of the field's value upon return. If you modify the VARIANT then the underlying record field does not change. The caller allocates memory of the VARIANT. The method VariantClear is called for pvarField before copying. Read more on docs.microsoft.com. Returns a pointer to the value of a given field name without copying the value and allocating resources. The instance of a record. The name of the field. The VARIANT that will contain the UDT upon return. Receives the value of the field upon return. This method can return one of these values. This doc was truncated. Upon return, the VARIANT you pass contains a direct pointer to the record's field, ppvDataCArray. If you modify the VARIANT, then the underlying record field will change. The caller allocates memory of the VARIANT, but does not own the memory so cannot free pvarField. This method calls VariantClear for pvarField before filling in the requested field. Read more on docs.microsoft.com. Puts a variant into a field. The only legal values for the wFlags parameter is INVOKE_PROPERTYPUT or INVOKE_PROPERTYPUTREF. If INVOKE_PROPERTYPUTREF is passed in then PutField just assigns the value of the variant that is passed in to the field using normal coercion rules. If INVOKE_PROPERTYPUT is passed in then specific rules apply. If the field is declared as a class that derives from IDispatch and the field's value is NULL then an error will be returned. If the field's value is not NULL then the variant will be passed to the default property supported by the object referenced by the field. If the field is not declared as a class derived from IDispatch then an error will be returned. If the field is declared as a variant of type VT_Dispatch then the default value of the object is assigned to the field. Otherwise, the variant's value is assigned to the field. Read more on docs.microsoft.com. The pointer to an instance of the record. The name of the field of the record. The pointer to the variant. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Passes ownership of the data to the assigned field by placing the actual data into the field. The only legal values for the wFlags parameter is INVOKE_PROPERTYPUT or INVOKE_PROPERTYPUTREF. An instance of the record described by IRecordInfo. The name of the field of the record. The variant to be put into the field. This method can return one of these values. This doc was truncated. Learn more about this API from docs.microsoft.com. Gets the names of the fields of the record. The number of names to return. The name of the array of type BSTR. If the rgBstrNames parameter is NULL, then pcNames is returned with the number of field names. It the rgBstrNames parameter is not NULL, then the string names contained in rgBstrNames are returned. If the number of names in pcNames and rgBstrNames are not equal then the lesser number of the two is the number of returned field names. The caller needs to free the BSTRs inside the array returned in rgBstrNames. Read more on docs.microsoft.com. This method can return one of these values. This doc was truncated. The caller should allocate memory for the array of BSTRs. If the array is larger than needed, set the unused portion to 0. On return, the caller will need to free each contained BSTR using SysFreeString. In case of out of memory, pcNames points to error code. Read more on docs.microsoft.com. Determines whether the record that is passed in matches that of the current record information. The information of the record. This doc was truncated. Learn more about this API from docs.microsoft.com. Allocates memory for a new record, initializes the instance and returns a pointer to the record. This method returns a pointer to the created record. The memory is set to zeros before it is returned. The records created must be freed by calling RecordDestroy. Read more on docs.microsoft.com. Creates a copy of an instance of a record to the specified location. An instance of the record to be copied. The new record with data copied from pvSource. This method can return one of these values. This doc was truncated. The records created must be freed by calling RecordDestroy. Releases the resources and deallocates the memory of the record. An instance of the record to be destroyed. This method can return one of these values. This doc was truncated. RecordClear is called to release the resources held by the instance of a record without deallocating memory.
Note  This method can only be called on records allocated through RecordCreate and RecordCreateCopy. If you allocate the record yourself, you cannot call this method.
 
 Read more on docs.microsoft.com. The IID guid for this interface. {0000002f-0000-0000-c000-000000000046} Contains information needed for transferring a structure element, parameter, or function return value between processes. Learn more about this API from docs.microsoft.com. The default value for the parameter, if PARAMFLAG_FHASDEFAULT is specified in wParamFlags. The parameter flags. See PARAMFLAG Constants. Contains information about the default value of a parameter. Learn more about this API from docs.microsoft.com. The size of the structure. The default value of the parameter. Specifies the variant types. The following table shows where these values can be used. This doc was truncated. Read more on docs.microsoft.com. Not specified. Null. A 2-byte integer. A 4-byte integer. A 4-byte real. An 8-byte real. Currency. A date. A string. An IDispatch pointer. An SCODE value. A Boolean value. True is -1 and false is 0. A variant pointer. An IUnknown pointer. A 16-byte fixed-pointer value. A character. An unsigned character. An unsigned short. An unsigned long. A 64-bit integer. A 64-bit unsigned integer. An integer. An unsigned integer. A C-style void. An HRESULT value. A pointer type. A safe array. Use VT_ARRAY in VARIANT. A C-style array. A user-defined type. A null-terminated string. A wide null-terminated string. A user-defined type. A signed machine register size width. An unsigned machine register size width. A FILETIME value. Length-prefixed bytes. The name of the stream follows. The name of the storage follows. The stream contains an object. The storage contains an object. The blob contains an object. A clipboard format. A class ID. A stream with a GUID version. Reserved. A simple counted array. A SAFEARRAY pointer. A void pointer for local use. VARIANTARG describes arguments passed within DISPPARAMS, and VARIANT to specify variant data that cannot be passed by reference. Learn more about this API from docs.microsoft.com. Gets the length of the BSTR in characters. The COLORREF value is used to specify an RGB color. When specifying an explicit [RGB](/windows/desktop/api/Wingdi/nf-wingdi-rgb) color, the **COLORREF** value has the following hexadecimal form: `0x00bbggrr` The low-order byte contains a value for the relative intensity of red; the second byte contains a value for green; and the third byte contains a value for blue. The high-order byte must be zero. The maximum value for a single byte is 0xFF. To create a **COLORREF** color value, use the [RGB](/windows/desktop/api/Wingdi/nf-wingdi-rgb) macro. To extract the individual values for the red, green, and blue components of a color value, use the [**GetRValue**](/windows/desktop/api/Wingdi/nf-wingdi-getrvalue), [GetGValue](/windows/desktop/api/Wingdi/nf-wingdi-getgvalue), and [GetBValue](/windows/desktop/api/Wingdi/nf-wingdi-getbvalue) macros, respectively. Read more on docs.microsoft.com. The DECIMAL structure represents a decimal data type that provides a sign and scale for a number. Reserved. The high 32 bits of the number. The **HRESULT** data type is the same as the [SCODE](scode.md) data type. An **HRESULT** value consists of the following fields: - A 1-bit code indicating severity, where zero represents success and 1 represents failure. - A 4-bit reserved value. - An 11-bit code indicating responsibility for the error or warning, also known as a facility code. - A 16-bit code describing the error or warning. Most MAPI interface methods and functions return **HRESULT** values to provide detailed cause formation. **HRESULT** values are also used widely in OLE interface methods. OLE provides several macros for converting between **HRESULT** values and **SCODE** values, another common data type for error handling. > [!NOTE] > In 64-bit MAPI, **HRESULT** is still a 32-bit value. For information about the OLE use of **HRESULT** values, see the *OLE Programmer's Reference*. For more information about the use of these values in MAPI, see [Error Handling](error-handling-in-mapi.md) and any of the following interface methods: [IABLogon::GetLastError](iablogon-getlasterror.md) [IMAPISupport::GetLastError](imapisupport-getlasterror.md) [IMAPIControl::GetLastError](imapicontrol-getlasterror.md) [IMAPITable::GetLastError](imapitable-getlasterror.md) [IMAPIProp::GetLastError](imapiprop-getlasterror.md) [IMAPIViewAdviseSink::OnPrint](imapiviewadvisesink-onprint.md) Read more on docs.microsoft.com. A pointer to the IErrorInfo interface that provides more information about the error. You can specify to use the current IErrorInfo interface, or new IntPtr(-1) to ignore the current IErrorInfo interface and construct the exception just from the error code. , if it does not reflect an error. Documentation varies per use. Refer to each: IMbnConnectionContextEvents.OnSetProvisionedContextComplete, IMbnConnectionEvents.OnConnectComplete, IMbnPinEvents.OnChangeComplete, IMbnPinEvents.OnDisableComplete, IMbnPinEvents.OnEnableComplete, IMbnPinEvents.OnEnterComplete, IMbnPinEvents.OnUnblockComplete, IMbnPinManagerEvents.OnGetPinStateComplete, IMbnRadioEvents.OnSetSoftwareRadioStateComplete, IMbnServiceActivationEvents.OnActivationComplete, IMbnSmsEvents.OnSetSmsConfigurationComplete, IMbnSmsEvents.OnSmsDeleteComplete, IMbnSmsEvents.OnSmsReadComplete, IMbnSmsEvents.OnSmsSendComplete. A pointer to a null-terminated, constant, ANSI character string. A pointer to the first character in the string. The content should be considered readonly, as it was typed as constant in the SDK. Gets the number of characters up to the first null character (exclusive). Returns a with a copy of this character array, decoding as UTF-8. A , or if is . Returns a span of the characters in this string, up to the first null character (exclusive). A pointer to a null-terminated, constant character string. A pointer to the first character in the string. The content should be considered readonly, as it was typed as constant in the SDK. Gets the number of characters up to the first null character (exclusive). Returns a with a copy of this character array, up to the first null character (exclusive). A , or if is . Returns a span of the characters in this string, up to the first null character (exclusive). Returns a span of the characters in this string, up to the first null character (exclusive). Returns a span of the characters in this string, up to the first null character (exclusive). The RECT structure defines a rectangle by the coordinates of its upper-left and lower-right corners. The RECT structure is identical to the RECTL structure. Specifies the x-coordinate of the upper-left corner of the rectangle. Specifies the y-coordinate of the upper-left corner of the rectangle. Specifies the x-coordinate of the lower-right corner of the rectangle. Specifies the y-coordinate of the lower-right corner of the rectangle. Defines the initialization parameters passed to the window procedure of an application. These members are identical to the parameters of the CreateWindowEx function. (Unicode) Because the lpszClass member can contain a pointer to a local (and thus inaccessible) atom, do not obtain the class name by using this member. Use the GetClassName function instead. You should access the data represented by the lpCreateParams member using a pointer that has been declared using the UNALIGNED type, because the pointer may not be DWORD aligned. This is demonstrated in the following example: This doc was truncated. Read more on docs.microsoft.com. Type: LPVOID Contains additional data which may be used to create the window. If the window is being created as a result of a call to the CreateWindow or CreateWindowEx function, this member contains the value of the lpParam parameter specified in the function call. If the window being created is a MDI client window, this member contains a pointer to a CLIENTCREATESTRUCT structure. If the window being created is a MDI child window, this member contains a pointer to an MDICREATESTRUCT structure. If the window is being created from a dialog template, this member is the address of a SHORT value that specifies the size, in bytes, of the window creation data. The value is immediately followed by the creation data. For more information, see the following Remarks section. Read more on docs.microsoft.com. Type: HINSTANCE A handle to the module that owns the new window. Read more on docs.microsoft.com. Type: HMENU A handle to the menu to be used by the new window. Read more on docs.microsoft.com. Type: HWND A handle to the parent window, if the window is a child window. If the window is owned, this member identifies the owner window. If the window is not a child or owned window, this member is NULL. Read more on docs.microsoft.com. Type: int The height of the new window, in pixels. Read more on docs.microsoft.com. Type: int The width of the new window, in pixels. Read more on docs.microsoft.com. Type: int The y-coordinate of the upper left corner of the new window. If the new window is a child window, coordinates are relative to the parent window. Otherwise, the coordinates are relative to the screen origin. Read more on docs.microsoft.com. Type: int The x-coordinate of the upper left corner of the new window. If the new window is a child window, coordinates are relative to the parent window. Otherwise, the coordinates are relative to the screen origin. Read more on docs.microsoft.com. Type: LPCTSTR The name of the new window. Read more on docs.microsoft.com. Type: LPCTSTR A pointer to a null-terminated string or an atom that specifies the class name of the new window. Read more on docs.microsoft.com. Type: DWORD The extended window style for the new window. For a list of possible values, see Extended Window Styles. Read more on docs.microsoft.com. Contains information about a window's maximized size and position and its minimum and maximum tracking size. For systems with multiple monitors, the ptMaxSize and ptMaxPosition members describe the maximized size and position of the window on the primary monitor, even if the window ultimately maximizes onto a secondary monitor. In that case, the window manager adjusts these values to compensate for differences between the primary monitor and the monitor that displays the window. Thus, if the user leaves ptMaxSize untouched, a window on a monitor larger than the primary monitor maximizes to the size of the larger monitor. Type: POINT Reserved; do not use. Read more on docs.microsoft.com. Type: POINT The maximized width (x member) and the maximized height (y member) of the window. For top-level windows, this value is based on the width of the primary monitor. Read more on docs.microsoft.com. Type: POINT The position of the left side of the maximized window (x member) and the position of the top of the maximized window (y member). For top-level windows, this value is based on the position of the primary monitor. Read more on docs.microsoft.com. Type: POINT The minimum tracking width (x member) and the minimum tracking height (y member) of the window. This value can be obtained programmatically from the system metrics SM_CXMINTRACK and SM_CYMINTRACK (see the GetSystemMetrics function). Read more on docs.microsoft.com. Type: POINT The maximum tracking width (x member) and the maximum tracking height (y member) of the window. This value is based on the size of the virtual screen and can be obtained programmatically from the system metrics SM_CXMAXTRACK and SM_CYMAXTRACK (see the GetSystemMetrics function). Read more on docs.microsoft.com. Contains information about a low-level mouse input event. Learn more about this API from docs.microsoft.com. Type: POINT The x- and y-coordinates of the cursor, in per-monitor-aware screen coordinates. Read more on docs.microsoft.com. Type: DWORD If the message is WM_MOUSEWHEEL, the high-order word of this member is the wheel delta. The low-order word is reserved. A positive value indicates that the wheel was rotated forward, away from the user; a negative value indicates that the wheel was rotated backward, toward the user. One wheel click is defined as WHEEL_DELTA, which is 120. Read more on docs.microsoft.com. Type: DWORD The event-injected flags. An application can use the following values to test the flags. Testing LLMHF_INJECTED (bit 0) will tell you whether the event was injected. If it was, then testing LLMHF_LOWER_IL_INJECTED (bit 1) will tell you whether or not the event was injected from a process running at lower integrity level. This doc was truncated. Read more on docs.microsoft.com. Type: DWORD The time stamp for this message. Read more on docs.microsoft.com. Type: ULONG_PTR Additional information associated with the message. Read more on docs.microsoft.com. Contains information about the size and position of a window. Learn more about this API from docs.microsoft.com. Type: HWND A handle to the window. Read more on docs.microsoft.com. Type: HWND The position of the window in Z order (front-to-back position). This member can be a handle to the window behind which this window is placed, or can be one of the special values listed with the SetWindowPos function. Read more on docs.microsoft.com. Type: int The position of the left edge of the window. Read more on docs.microsoft.com. Type: int The position of the top edge of the window. Read more on docs.microsoft.com. Type: int The window width, in pixels. Read more on docs.microsoft.com. Type: int The window height, in pixels. Read more on docs.microsoft.com. Type: UINT Contains window class information. (Unicode) > [!NOTE] > The winuser.h header defines WNDCLASSEX as an alias which automatically selects the ANSI or Unicode version of this function based on the definition of the UNICODE preprocessor constant. Mixing usage of the encoding-neutral alias with code that not encoding-neutral can lead to mismatches that result in compilation or runtime errors. For more information, see [Conventions for Function Prototypes](/windows/win32/intl/conventions-for-function-prototypes). Read more on docs.microsoft.com. Type: UINT The size, in bytes, of this structure. Set this member to sizeof(WNDCLASSEX). Be sure to set this member before calling the GetClassInfoEx function. Read more on docs.microsoft.com. Type: UINT The class style(s). This member can be any combination of the Class Styles. Read more on docs.microsoft.com. Type: WNDPROC A pointer to the window procedure. You must use the CallWindowProc function to call the window procedure. For more information, see WindowProc. Read more on docs.microsoft.com. Type: int The number of extra bytes to allocate following the window-class structure. The system initializes the bytes to zero. Read more on docs.microsoft.com. Type: int The number of extra bytes to allocate following the window instance. The system initializes the bytes to zero. If an application uses WNDCLASSEX to register a dialog box created by using the CLASS directive in the resource file, it must set this member to DLGWINDOWEXTRA. Read more on docs.microsoft.com. Type: HINSTANCE A handle to the instance that contains the window procedure for the class. Read more on docs.microsoft.com. Type: HICON A handle to the class icon. This member must be a handle to an icon resource. If this member is NULL, the system provides a default icon. Read more on docs.microsoft.com. Type: HCURSOR A handle to the class cursor. This member must be a handle to a cursor resource. If this member is NULL, an application must explicitly set the cursor shape whenever the mouse moves into the application's window. Read more on docs.microsoft.com. Type: HBRUSH A handle to the class background brush. This member can be a handle to the brush to be used for painting the background, or it can be a color value. A color value must be one of the following standard system colors (the value 1 must be added to the chosen color). If a color value is given, you must convert it to one of the following HBRUSH types: This doc was truncated. Read more on docs.microsoft.com. Type: LPCTSTR Pointer to a null-terminated character string that specifies the resource name of the class menu, as the name appears in the resource file. If you use an integer to identify the menu, use the MAKEINTRESOURCE macro. If this member is NULL, windows belonging to this class have no default menu. Read more on docs.microsoft.com. Type: LPCTSTR A pointer to a null-terminated string or is an atom. If this parameter is an atom, it must be a class atom created by a previous call to the RegisterClass or RegisterClassEx function. The atom must be in the low-order word of lpszClassName; the high-order word must be zero. If lpszClassName is a string, it specifies the window class name. The class name can be any name registered with RegisterClass or RegisterClassEx, or any of the predefined control-class names. The maximum length for lpszClassName is 256. If lpszClassName is greater than the maximum length, the RegisterClassEx function will fail. Read more on docs.microsoft.com. Type: HICON A handle to a small icon that is associated with the window class. If this member is NULL, the system searches the icon resource specified by the hIcon member for an icon of the appropriate size to use as the small icon. Read more on docs.microsoft.com. Contains information about an image list draw operation and is used with the IImageList::Draw function. (IMAGELISTDRAWPARAMS) An overlay image is an image that is drawn on top of the primary image specified in the i member of this structure. To specify an overlay image, use the bitwise OR operator to combine fStyle with the INDEXTOOVERLAYMASK macro, passing the one-based index of the overlay image in the macro. This image must have been previously specified as an overlay image using the ImageList_SetOverlayImage API. To extract the overlay image from the fStyle, use the bitwise AND operator to mask fStyle with the ILD_OVERLAYMASK value. Comctl32.dll version 6 is not redistributable.. To use Comctl32.dll version 6, you must specify it in a manifest. For more information on manifests, see Enabling Visual Styles. Read more on docs.microsoft.com. Type: DWORD The size of this structure, in bytes. Read more on docs.microsoft.com. Type: HIMAGELIST A handle to the image list that contains the image to be drawn. Read more on docs.microsoft.com. Type: int The zero-based index of the image to be drawn. Read more on docs.microsoft.com. Type: HDC A handle to the destination device context. Read more on docs.microsoft.com. Type: int The x-coordinate that specifies where the image is drawn. Read more on docs.microsoft.com. Type: int The y-coordinate that specifies where the image is drawn. Read more on docs.microsoft.com. Type: int A value that specifies the number of pixels to draw, relative to the upper-left corner of the drawing operation as specified by xBitmap and yBitmap. If cx and cy are zero, then Draw draws the entire valid section. The method does not ensure that the parameters are valid. Read more on docs.microsoft.com. Type: int A value that specifies the number of pixels to draw, relative to the upper-left corner of the drawing operation as specified by xBitmap and yBitmap. If cx and cy are zero, then Draw draws the entire valid section. The method does not ensure that the parameters are valid. Read more on docs.microsoft.com. Type: int The x-coordinate that specifies the upper-left corner of the drawing operation in reference to the image itself. Pixels of the image that are to the left of xBitmap and above yBitmap do not appear. Read more on docs.microsoft.com. Type: int The y-coordinate that specifies the upper-left corner of the drawing operation in reference to the image itself. Pixels of the image that are to the left of xBitmap and above yBitmap do not appear. Read more on docs.microsoft.com. Type: COLORREF Type: COLORREF Type: UINT A flag specifying the drawing style and, optionally, the overlay image. See the comments section at the end of this topic for information on the overlay image. This member can contain one or more image list drawing flags. Read more on docs.microsoft.com. Type: DWORD A value specifying a raster operation code. These codes define how the color data for the source rectangle will be combined with the color data for the destination rectangle to achieve the final color. This member is ignored if fStyle does not include the ILD_ROP flag. Some common raster operation codes include: This doc was truncated. Read more on docs.microsoft.com. Type: DWORD A flag that specifies the drawing state. This member can contain one or more image list state flags. You must use comctl32.dll version 6 to use this member. See the Remarks. Read more on docs.microsoft.com. Type: DWORD Used with the alpha blending effect. When used with ILS_ALPHA, this member holds the value for the alpha channel. This value can be from 0 to 255, with 0 being completely transparent, and 255 being completely opaque. You must use comctl32.dll version 6 to use this member. See the Remarks. Read more on docs.microsoft.com. Type: DWORD A color used for the glow and shadow effects. You must use comctl32.dll version 6 to use this member. See the Remarks. Read more on docs.microsoft.com. Specifies the type of Microsoft UI Automation provider; for example, whether it is a client-side (proxy) or server-side provider. The method must return either ProviderOptions_ServerSideProvider or ProviderOptions_ClientSideProvider. UI Automation handles the various types of providers differently. For example, events from a server-side provider are broadcast to all listening clients, but events from client-side (proxy) providers remain in the client. Read more on docs.microsoft.com. Retrieves a pointer to an object that provides support for a control pattern on a Microsoft UI Automation element. Type: PATTERNID The identifier of the control pattern. For a list of control pattern IDs, see Control Pattern Identifiers. Read more on docs.microsoft.com. Type: HRESULT If this method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. Learn more about this API from docs.microsoft.com. Retrieves the value of a property supported by the Microsoft UI Automation provider. Type: PROPERTYID The property identifier. For a list of property IDs, see Property Identifiers. Read more on docs.microsoft.com. Type: HRESULT If this method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. If the provider does not support the propertyId property, the provider should set pRetVal->vt to VT_EMPTY and return S_OK. If a provider is explicitly hiding the property value (that is, the provider does not supply the property, and the request is not to be passed through to other providers), it should return a pointer obtained by using the UiaGetReservedNotSupportedValue function. For example: This doc was truncated. Read more on docs.microsoft.com. Specifies the host provider for this element. This property is generally the Microsoft UI Automation provider for the window of a custom control. UI Automation uses this provider in combination with the custom provider. For example, the runtime identifier of the element is usually obtained from the host provider. A host provider must be returned in the following cases: when the element is a fragment root, when the element is a simple element (such as a push button), and when the provider is a repositioning placeholder (for more information, see Provider Repositioning). In other cases, the property should be NULL. Read more on docs.microsoft.com. The IID guid for this interface. {d6dd68d1-86fd-4332-8666-9abedea2d24c} Defines values that indicate the type of a notification event, and a hint to the listener about the processing of the event. Learn more about this API from docs.microsoft.com. The current element and/or the container has had something added to it that should be presented to the user. The current element has had something removed from inside of it that should be presented to the user. The current element has a notification that an action was completed. The current element has a notification that an action was aborted. The current element has a notification not an add, remove, completed, or aborted action. Defines values that indicate how a notification should be processed. Learn more about this API from docs.microsoft.com. These notifications should be presented to the user as soon as possible and all of the notifications from this source should be delivered to the user.
Warning  Use this in a limited capacity as this style of message could cause a flooding of information to the user due to the nature of the request to deliver all notifications.
 
 Read more on docs.microsoft.com. These notifications should be presented to the user as soon as possible. The most recent notification from this source should be delivered to the user because it supersedes all of the other notifications. Read more on docs.microsoft.com. These notifications should be presented to the user when possible. All of the notifications from this source should be delivered to the user. Read more on docs.microsoft.com. These notifications should be presented to the user when possible. The most recent notification from this source should be delivered to the user because it supersedes all of the other notifications. Read more on docs.microsoft.com. These notifications should be presented to the user when possible. Don’t interrupt the current notification for this one. If new notifications come in from the same source while the current notification is being presented, keep the most recent and ignore the rest until the current processing is completed. Then, use the most recent message as the current message. Read more on docs.microsoft.com. Contains values that specify the type of UI Automation provider. The IRawElementProviderSimple::ProviderOptions property uses this enumeration. Learn more about this API from docs.microsoft.com. The provider is a client-side (proxy) provider. The provider is a server-side provider. The provider is a non-client-area provider. The provider overrides another provider. The provider handles its own focus, and does not want UI Automation to set focus to the nearest window on its behalf. This option is typically used by providers for windows that appear to take focus without actually receiving Win32 focus, such as menus and drop-downs. The provider has explicit support for COM threading models, so that calls by UI Automation on COM-based providers are received on the appropriate thread. This means that STA-based provider implementations will be called back on their own STA thread, and therefore do not need extra synchronization to safely access resources that belong to that STA. MTA-based provider implementations will be called back on some other thread in the MTA, and will require appropriate synchronization to be added, as is usual for MTA code. The provider handles its own non-client area and does not want UI Automation to provide default accessibility support for controls in the non-client area, such as minimize/maximize buttons and menu bars. The provider implements the IAccessible interface. The provider works in client coordinates instead of screen coordinates. Identifies a change in the state of a button associated with a pointer. Learn more about this API from docs.microsoft.com. No change in button state. The first button (see POINTER_FLAG_FIRSTBUTTON) transitioned to a pressed state. The first button (see POINTER_FLAG_FIRSTBUTTON) transitioned to a released state. The second button (see POINTER_FLAG_SECONDBUTTON) transitioned to a pressed state. The second button (see POINTER_FLAG_SECONDBUTTON) transitioned to a released state. The third button (see POINTER_FLAG_THIRDBUTTON) transitioned to a pressed state. The third button (see POINTER_FLAG_THIRDBUTTON) transitioned to a released state. The fourth button (see POINTER_FLAG_FOURTHBUTTON) transitioned to a pressed state. The fourth button (see POINTER_FLAG_FOURTHBUTTON) transitioned to a released state. The fifth button (see POINTER_FLAG_FIFTHBUTTON) transitioned to a pressed state. The fifth button (see POINTER_FLAG_FIFTHBUTTON) transitioned to a released state. Contains basic pointer information common to all pointer types. Applications can retrieve this information using the GetPointerInfo, GetPointerFrameInfo, GetPointerInfoHistory and GetPointerFrameInfoHistory functions. Learn more about this API from docs.microsoft.com. Type: POINTER_INPUT_TYPE A value from the POINTER_INPUT_TYPE enumeration that specifies the pointer type. Read more on docs.microsoft.com. Type: UINT32 An identifier that uniquely identifies a pointer during its lifetime. A pointer comes into existence when it is first detected and ends its existence when it goes out of detection range. Note that if a physical entity (finger or pen) goes out of detection range and then returns to be detected again, it is treated as a new pointer and may be assigned a new pointer identifier. Read more on docs.microsoft.com. Type: UINT32 An identifier common to multiple pointers for which the source device reported an update in a single input frame. For example, a parallel-mode multi-touch digitizer may report the positions of multiple touch contacts in a single update to the system. Note that frame identifier is assigned as input is reported to the system for all pointers across all devices. Therefore, this field may not contain strictly sequential values in a single series of messages that a window receives. However, this field will contain the same numerical value for all input updates that were reported in the same input frame by a single device. Read more on docs.microsoft.com. Type: POINTER_FLAGS May be any reasonable combination of flags from the Pointer Flags constants. Read more on docs.microsoft.com. Type: HANDLE Handle to the source device that can be used in calls to the raw input device API and the digitizer device API. Read more on docs.microsoft.com. Type: HWND Window to which this message was targeted. If the pointer is captured, either implicitly by virtue of having made contact over this window or explicitly using the pointer capture API, this is the capture window. If the pointer is uncaptured, this is the window over which the pointer was when this message was generated. Read more on docs.microsoft.com. Type: POINT The predicted screen coordinates of the pointer, in pixels. The predicted value is based on the pointer position reported by the digitizer and the motion of the pointer. This correction can compensate for visual lag due to inherent delays in sensing and processing the pointer location on the digitizer. This is applicable to pointers of type PT_TOUCH. For other pointer types, the predicted value will be the same as the non-predicted value (see ptPixelLocationRaw). Read more on docs.microsoft.com. Type: POINT The predicted screen coordinates of the pointer, in HIMETRIC units. The predicted value is based on the pointer position reported by the digitizer and the motion of the pointer. This correction can compensate for visual lag due to inherent delays in sensing and processing the pointer location on the digitizer. This is applicable to pointers of type PT_TOUCH. For other pointer types, the predicted value will be the same as the non-predicted value (see ptHimetricLocationRaw). Read more on docs.microsoft.com. Type: POINT The screen coordinates of the pointer, in pixels. For adjusted screen coordinates, see ptPixelLocation. Read more on docs.microsoft.com. Type: POINT The screen coordinates of the pointer, in HIMETRIC units. For adjusted screen coordinates, see ptHimetricLocation. Read more on docs.microsoft.com. Type: DWORD 0 or the time stamp of the message, based on the system tick count when the message was received. The application can specify the input time stamp in either dwTime or PerformanceCount. The value cannot be more recent than the current tick count or QueryPerformanceCount (QPC) value of the injection thread. Once a frame is injected with a time stamp, all subsequent frames must include a timestamp until all contacts in the frame go to an UP state. The custom timestamp value must also be provided for the first element in the contacts array. The time stamp values after the first element are ignored. The custom timestamp value must increment in every injection frame. When PerformanceCount is specified, the time stamp will be converted to the current time in .1 millisecond resolution upon actual injection. If a custom PerformanceCount resulted in the same .1 millisecond window from the previous injection, ERROR_NOT_READY is returned and injection will not occur. While injection will not be invalidated immediately by the error, the next successful injection must have a PerformanceCount value that is at least 0.1 millisecond from the previously successful injection. This is also true if dwTime is used. If both dwTime and PerformanceCount are specified in InjectTouchInput, ERROR_INVALID_PARAMETER is returned. InjectTouchInput cannot switch between dwTime and PerformanceCount once injection has started. If neither dwTime and PerformanceCount are specified, InjectTouchInput allocates the timestamp based on the timing of the call. If InjectTouchInput calls are repeatedly less than 0.1 millisecond apart, ERROR_NOT_READY might be returned. The error will not invalidate the input immediately, but the injection application needs to retry the same frame again for injection to succeed. Read more on docs.microsoft.com. Type: UINT32 Count of inputs that were coalesced into this message. This count matches the total count of entries that can be returned by a call to GetPointerInfoHistory. If no coalescing occurred, this count is 1 for the single input represented by the message. Read more on docs.microsoft.com. Type: DWORD Type: UINT64 The value of the high-resolution performance counter when the pointer message was received (high-precision, 64 bit alternative to dwTime). The value can be calibrated when the touch digitizer hardware supports the scan timestamp information in its input report. Read more on docs.microsoft.com. Type: POINTER_BUTTON_CHANGE_TYPE A value from the POINTER_BUTTON_CHANGE_TYPE enumeration that specifies the change in button state between this input and the previous input. Read more on docs.microsoft.com. Defines basic pen information common to all pointer types. Applications can retrieve this information using the GetPointerPenInfo, GetPointerFramePenInfo, GetPointerPenInfoHistory and GetPointerFramePenInfoHistory API functions. Type: POINTER_INFO An embedded POINTER_INFO structure. Read more on docs.microsoft.com. Type: PEN_FLAGS The pen flag. This member can be zero or any reasonable combination of the values from the Pen Flags constants. Read more on docs.microsoft.com. Type: PEN_MASK The pen mask. This member can be zero or any reasonable combination of the values from the Pen Mask constants. Read more on docs.microsoft.com. Type: UINT32 A pen pressure normalized to a range between 0 and 1024. The default is 0 if the device does not report pressure. Read more on docs.microsoft.com. Type: UINT32 The clockwise rotation, or twist, of the pointer normalized in a range of 0 to 359. The default is 0. Read more on docs.microsoft.com. Type: INT32 The angle of tilt of the pointer along the x-axis in a range of -90 to +90, with a positive value indicating a tilt to the right. The default is 0. Read more on docs.microsoft.com. Type: INT32 The angle of tilt of the pointer along the y-axis in a range of -90 to +90, with a positive value indicating a tilt toward the user. The default is 0. Read more on docs.microsoft.com. Defines basic touch information common to all pointer types. Learn more about this API from docs.microsoft.com. Type: **[POINTER_INFO](ns-winuser-pointer_info.md)** An embedded [POINTER_INFO](ns-winuser-pointer_info.md) header structure. Read more on docs.microsoft.com. Type: **[Touch Flags](/windows/win32/inputmsg/touch-flags-constants)** Currently none. Read more on docs.microsoft.com. Type: **[Touch Mask](/windows/win32/inputmsg/touch-mask-constants)** Indicates which of the optional fields contain valid values. The member can be zero or any combination of the values from the [Touch Mask](/windows/win32/inputmsg/touch-mask-constants) constants. Read more on docs.microsoft.com. Type: **RECT** The predicted screen coordinates of the contact area, in pixels. By default, if the device does not report a contact area, this field defaults to a 0-by-0 rectangle centered around the pointer location. The predicted value is based on the pointer position reported by the digitizer and the motion of the pointer. This correction can compensate for visual lag due to inherent delays in sensing and processing the pointer location on the digitizer. This is applicable to pointers of type [PT_TOUCH](ne-winuser-tagpointer_input_type.md). Read more on docs.microsoft.com. Type: **RECT** The raw screen coordinates of the contact area, in pixels. For adjusted screen coordinates, see **rcContact**. Read more on docs.microsoft.com. Type: **UINT32** A pointer orientation, with a value between 0 and 359, where 0 indicates a touch pointer aligned with the x-axis and pointing from left to right; increasing values indicate degrees of rotation in the clockwise direction. This field defaults to 0 if the device does not report orientation. > [!NOTE] > Some touchscreen devices that support orientation will only report half-range (0-180°) values, while other devices will only report full-range (0-359°) values. Read more on docs.microsoft.com. Type: **UINT32** A pen pressure normalized to a range between 0 and 1024. The default is 512. Read more on docs.microsoft.com. Represents a Win32 handle that can be closed with . Represents a Win32 handle that can be closed with . The MONITORINFO structure contains information about a display monitor.The GetMonitorInfo function stores information in a MONITORINFO structure or a MONITORINFOEX structure.The MONITORINFO structure is a subset of the MONITORINFOEX structure. Learn more about this API from docs.microsoft.com. The size of the structure, in bytes. Set this member to sizeof ( MONITORINFO ) before calling the GetMonitorInfo function. Doing so lets the function determine the type of structure you are passing to it. Read more on docs.microsoft.com. A RECT structure that specifies the display monitor rectangle, expressed in virtual-screen coordinates. Note that if the monitor is not the primary display monitor, some of the rectangle's coordinates may be negative values. A RECT structure that specifies the work area rectangle of the display monitor, expressed in virtual-screen coordinates. Note that if the monitor is not the primary display monitor, some of the rectangle's coordinates may be negative values. A set of flags that represent attributes of the display monitor. The following flag is defined. This doc was truncated. Read more on docs.microsoft.com. The IID guid for this interface. The reference that is returned comes from a permanent memory address, and is therefore safe to convert to a pointer and pass around or hold long-term. Non generic interface that allows constraining against a COM wrapper type directly. COM structs should implement . Represents a Win32 handle that can be closed with . Represents a Win32 handle that can be closed with . GeneratedInternalTypeHelper CreateInstance GetPropertyValue SetPropertyValue CreateDelegate AddEventHandler