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. Adapter that converts a framework-agnostic DelegateCommand from Core into a WPF RelayCommand for data binding in UI projects. Converts a DelegateCommand to a RelayCommand for use in WPF data binding. The RelayCommand will delegate all calls to the underlying DelegateCommand. The framework-agnostic command from Core. A WPF RelayCommand that wraps the DelegateCommand. Converts a parameterless DelegateCommand to a RelayCommand. The framework-agnostic command from Core. A WPF RelayCommand that wraps the DelegateCommand. Converts a DelegateCommand from Core to an ICommand for WPF data binding. Known Keyboards that do not have the AltGr key 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. Converter to convert WPF KeyEventArgs to the base KeyboardEventArgs. This is used in XAML code-behind files to bridge WPF-specific events to the framework-agnostic base class. 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 TakeoverNanoConnectionErrorView.xaml TakeoverNanoConnectionErrorView InitializeComponent Interaction logic for TakeoverNearbyConnectionView.xaml TakeoverNearbyConnectionView InitializeComponent Interaction logic for TakeoverNearbyDeviceLockView.xaml TakeoverNearbyDeviceLockView InitializeComponent Interaction logic for TakeoverNearbySkipNotificationView.xaml TakeoverNearbySkipNotificationView 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 "api-ms-win-shcore-scaling-l1-1-1.dll". Contains extern methods from "GDI32.dll". Contains extern methods from "KERNEL32.dll". Contains extern methods from "OLEAUT32.dll". Contains extern methods from "UIAutomationCore.dll". Contains extern methods from "USER32.dll". Queries the dots per inch (dpi) of a display. Handle of the monitor being queried. The type of DPI being queried. Possible values are from the MONITOR_DPI_TYPE enumeration. The value of the DPI along the X axis. This value always refers to the horizontal edge, even when the screen is rotated. The value of the DPI along the Y axis. This value always refers to the vertical edge, even when the screen is rotated. This function returns one of the following values. This doc was truncated. 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 GetDpiForWindow. When you call GetDpiForMonitor, you will receive different DPI values depending on the DPI awareness of the calling application. DPI awareness is an application-level property usually defined in the application manifest. For more information about DPI awareness values, see PROCESS_DPI_AWARENESS. The following table indicates how the results will differ based on the PROCESS_DPI_AWARENESS value of your application. 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. The DeleteEnhMetaFile function deletes an enhanced-format metafile or an enhanced-format metafile handle. A handle to an enhanced metafile. If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. If the hemf parameter identifies an enhanced metafile stored in memory, the DeleteEnhMetaFile function deletes the metafile. If hemf identifies a metafile stored on a disk, the function deletes the metafile handle but does not destroy the actual metafile. An application can retrieve the file by calling the GetEnhMetaFile function. 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. Frees the specified global memory object and invalidates its handle. A handle to the global memory object. This handle is returned by either the GlobalAlloc or GlobalReAlloc function. It is not safe to free memory allocated with LocalAlloc. Read more on docs.microsoft.com. If the function succeeds, the return value is NULL. If the function fails, the return value is equal to a handle to the global memory object. To get extended error information, call GetLastError. If the process examines or modifies the memory after it has been freed, heap corruption may occur or an access violation exception (EXCEPTION_ACCESS_VIOLATION) may be generated. The GlobalFree function will free a locked memory object. A locked memory object has a lock count greater than zero. The GlobalLock function locks a global memory object and increments the lock count by one. The GlobalUnlock function unlocks it and decrements the lock count by one. To get the lock count of a global memory object, use the GlobalFlags function. If an application is running under a debug version of the system, GlobalFree will issue a message that tells you that a locked object is being freed. If you are debugging the application, GlobalFree will enter a breakpoint just before freeing a locked object. This allows you to verify the intended behavior, then continue execution. 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 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. 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 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. 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 MonitorFromPoint function retrieves a handle to the display monitor that contains a specified point. A POINT structure that specifies the point of interest in virtual-screen coordinates. Determines the function's return value if the point is not contained within any display monitor. If the point is contained by a display monitor, the return value is an HMONITOR handle to that display monitor. If the point is not contained by a display monitor, the return value depends on the value of dwFlags. Learn more about this API from docs.microsoft.com. 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. 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. 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. Sets the specified window's show state. Type: HWND A handle to the window. Read more on docs.microsoft.com. Type: int Type: BOOL If the window was previously visible, the return value is nonzero. If the window was previously hidden, the return value is zero. To perform certain special effects when showing or hiding a window, use AnimateWindow. The first time an application calls ShowWindow, it should use the WinMain function's nCmdShow parameter as its nCmdShow parameter. Subsequent calls to ShowWindow must use one of the values in the given list, instead of the one specified by the WinMain function's nCmdShow parameter. As noted in the discussion of the nCmdShow parameter, the nCmdShow value is ignored in the first call to ShowWindow if the program that launched the application specifies startup information in the structure. In this case, ShowWindow uses the information specified in the STARTUPINFO structure to show the window. On subsequent calls, the application must call ShowWindow with nCmdShow set to SW_SHOWDEFAULT to use the startup information provided by the program that launched the application. This behavior is designed for the following situations: This doc was truncated. 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. Contains parameters used during a moniker-binding operation. A BIND_OPTS structure is stored in a bind context; the same bind context is used by each component of a composite moniker during binding, allowing the same parameters to be passed to all components of a composite moniker. See IBindCtx for more information about bind contexts. Moniker clients (use a moniker to acquire an interface pointer to an object) typically do not need to specify values for the members of this structure. The CreateBindCtx function creates a bind context with the bind options set to default values that are suitable for most situations; the BindMoniker function does the same thing when creating a bind context for use in binding a moniker. If you want to modify the values of these bind options, you can do so by passing a BIND_OPTS structure to the IBindCtx::SetBindOptions method. Moniker implementers can pass a BIND_OPTS structure to the IBindCtx::GetBindOptions method to retrieve the values of these bind options. Read more on docs.microsoft.com. The size of this structure, in bytes. Flags that control aspects of moniker binding operations. This value is any combination of the bit flags in the BIND_FLAGS enumeration. The CreateBindCtx function initializes this member to zero. Flags that should be used when opening the file that contains the object identified by the moniker. Possible values are the STGM constants. The binding operation uses these flags in the call to IPersistFile::Load when loading the file. If the object is already running, these flags are ignored by the binding operation. The CreateBindCtx function initializes this field to STGM_READWRITE. The clock time by which the caller would like the binding operation to be completed, in milliseconds. This member lets the caller limit the execution time of an operation when speed is of primary importance. A value of zero indicates that there is no deadline. Callers most often use this capability when calling the IMoniker::GetTimeOfLastChange method, though it can be usefully applied to other operations as well. The CreateBindCtx function initializes this field to zero. Typical deadlines allow for a few hundred milliseconds of execution. This deadline is a recommendation, not a requirement; however, operations that exceed their deadline by a large amount may cause delays for the end user. Each moniker implementation should try to complete its operation by the deadline, or fail with the error MK_E_EXCEEDEDDEADLINE. If a binding operation exceeds its deadline because one or more objects that it needs are not running, the moniker implementation should register the objects responsible in the bind context using the IBindCtx::RegisterObjectParam. The objects should be registered under the parameter names "ExceededDeadline", "ExceededDeadline1", "ExceededDeadline2", and so on. If the caller later finds the object in the running object table, the caller can retry the binding operation. The GetTickCount function indicates the number of milliseconds since system startup, and wraps back to zero after 2^31 milliseconds. Consequently, callers should be careful not to inadvertently pass a zero value (which indicates no deadline), and moniker implementations should be aware of clock wrapping problems. Read more on docs.microsoft.com. Identifies the calling convention used by a member function described in the METHODDATA structure. Learn more about this API from 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. Specifies information about the target device for which data is being composed. DVTARGETDEVICE contains enough information about a Windows target device so a handle to a device context (HDC) can be created using the CreateDC function. Some OLE 1 client applications incorrectly construct target devices by allocating too few bytes in the DEVMODE structure for the DVTARGETDEVICE. They typically only supply the number of bytes in the dmSize member of DEVMODE. The number of bytes to be allocated should be the sum of dmSize + dmDriverExtra. When a call is made to the CreateDC function with an incorrect target device, the printer driver tries to access the additional bytes and unpredictable results can occur. To help protect against a crash and make the additional bytes available, OLE pads the size of OLE 2 target devices created from OLE 1 target devices. The size, in bytes, of the DVTARGETDEVICE structure. The initial size is included so the structure can be copied more easily. The offset, in bytes, from the beginning of the structure to the device driver name, which is stored as a NULL-terminated string in the tdData buffer. The offset, in bytes, from the beginning of the structure to the device name, which is stored as a NULL-terminated string in the tdData buffer. This value can be zero to indicate no device name. The offset, in bytes, from the beginning of the structure to the port name, which is stored as a NULL-terminated string in the tdData buffer. This value can be zero to indicate no port name. The offset, in bytes, from the beginning of the structure to the DEVMODE structure retrieved by calling DocumentProperties. An array of bytes containing data for the target device. It is not necessary to include empty strings in tdData (for names where the offset value is zero). 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. 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.) Represents a generalized clipboard format. The FORMATETC structure is used by methods in the data transfer and presentation interfaces as a parameter specifying the data being transferred. For example, the IDataObject::GetData method uses the FORMATETC structure to indicate exactly what kind of data the caller is requesting. The clipboard format of interest. There are three types of formats recognized by OLE: This doc was truncated. Read more on docs.microsoft.com. A pointer to a DVTARGETDEVICE structure containing information about the target device for which the data is being composed. A NULL value is used whenever the specified data format is independent of the target device or when the caller doesn't care what device is used. In the latter case, if the data requires a target device, the object should pick an appropriate default device (often the display for visual components). Data obtained from an object with a NULL target device, such as most metafiles, is independent of the target device. The resulting data is usually the same as it would be if the user chose the Save As command from the File menu and selected an interchange format. Indicates how much detail should be contained in the rendering. This parameter should be one of the DVASPECT enumeration values. A single clipboard format can support multiple aspects or views of the object. Most data and presentation transfer and caching methods pass aspect information. For example, a caller might request an object's iconic picture, using the metafile clipboard format to retrieve it. Note that only one DVASPECT value can be used in dwAspect. That is, dwAspect cannot be the result of a Boolean OR operation on several DVASPECT values. Part of the aspect when the data must be split across page boundaries. The most common value is -1, which identifies all of the data. For the aspects DVASPECT_THUMBNAIL and DVASPECT_ICON, lindex is ignored. One of the TYMED enumeration constants which indicate the type of storage medium used to transfer the object's data. Data can be transferred using whatever medium makes sense for the object. For example, data can be passed using global memory, a disk file, or structured storage objects. For more information, see the TYMED enumeration. 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. Called by the server to notify a data object's currently registered advise sinks that data in the object has changed. A pointer to a FORMATETC structure, which describes the format, target device, rendering, and storage information of the calling data object. A pointer to a STGMEDIUM structure, which defines the storage medium (global memory, disk file, storage object, stream object, GDI object, or undefined) and ownership of that medium for the calling data object. Object handlers and containers of link objects implement IAdviseSink::OnDataChange to take appropriate steps when notified that data in the object has changed. They also must call IDataObject::DAdvise to set up advisory connections with the objects in whose data they are interested. Containers that take advantage of OLE's caching support do not need to register for data-change notifications, because the information necessary to update the container's presentation of the object, including any changes in its data, are maintained in the object's cache.

Notes to Implementers

If you implement IAdviseSink::OnDataChange for a container, remember that this method is asynchronous and that making synchronous calls within asynchronous methods is not valid. Therefore, you cannot call IDataObject::GetData to obtain the data you need to update your object. Instead, you either post an internal message, or invalidate the rectangle for the changed data by calling InvalidateRect and waiting for a WM_PAINT message, at which point you are free to get the data and update the object. The data itself, which is valid only for the duration of the call, is passed using the storage medium pointed to by pStgmed. Since the caller owns the medium, the advise sink should not free it. Also, if pStgmed points to an IStorage or IStream interface, the sink must not increment the reference count. Read more on docs.microsoft.com. Notifies an object's registered advise sinks that its view has changed. The aspect, or view, of the object. Contains a value taken from the DVASPECT enumeration. The portion of the view that has changed. Currently only -1 is valid. Containers register to be notified when an object's view changes by calling IViewObject::SetAdvise. After it is registered, the object will call the sink's IAdviseSink::OnViewChange method when appropriate. OnViewChange can be called when the object is in either the loaded or running state. Even though DVASPECT values are individual flag bits, dwAspect may represent only one value. That is, dwAspect cannot contain the result of an OR operation combining two or more DVASPECT values. The lindex parameter represents the part of the aspect that is of interest. The value of lindex depends on the value of dwAspect. If dwAspect is either DVASPECT_THUMBNAIL or DVASPECT_ICON, lindex is ignored. If dwAspect is DVASPECT_CONTENT, lindex must be -1, which indicates that the entire view is of interest and is the only value that is currently valid. Read more on docs.microsoft.com. Called by the server to notify all registered advisory sinks that the object has been renamed. A pointer to the IMoniker interface on the new full moniker of the object. OLE link objects normally implement IAdviseSink::OnRename to receive notification of a change in the name of a link source or its container. The object serving as the link source calls OnRename and passes its new full moniker to the object handler, which forwards the notification to the link object. In response, the link object must update its moniker. The link object, in turn, forwards the notification to its own container. Called by the server to notify all registered advisory sinks that the object has been saved. Object handlers and link objects normally implement IAdviseSink::OnSave to receive notifications of when an object is saved to disk, either to its original storage (through a Save operation) or to new storage (through a Save As operation). Object Handlers and link objects register to be notified when an object is saved for the purpose of updating their caches, but then only if the advise flag passed during registration specifies ADVFCACHE_ONSAVE. Object handlers and link objects forward these notifications to their containers. Called by the server to notify all registered advisory sinks that the object has changed from the running to the loaded state. The OnClose notification indicates that an object is making the transition from the running to the loaded state, so its container can take appropriate measures to ensure an orderly shutdown. For example, an object handler must release its pointer to the object. If the object that is closing is the last open object supported by its OLE server application, the application can also shut down. In the case of a link object, the notification that the object is closing should always be interpreted to mean that the connection to the link source has broken. Read more on docs.microsoft.com. The IID guid for this interface. {0000010f-0000-0000-c000-000000000046} Registers an object with the bind context to ensure that the object remains active until the bind context is released. A pointer to the IUnknown interface on the object that is being registered as bound. This method can return the standard return values E_OUTOFMEMORY and S_OK. Those writing a new moniker class (through an implementation of the IMoniker interface) should call this method whenever the implementation activates an object. This happens most often in the course of binding a moniker, but it can also happen while retrieving a moniker's display name, parsing a display name into a moniker, or retrieving the time that an object was last modified. RegisterObjectBound calls AddRef to create an additional reference to the object. You must, however, still release your own copy of the pointer. Calling this method twice for the same object creates two references to that object. You can release a reference obtained through a call to this method by calling IBindCtx::RevokeObjectBound. All references held by the bind context are released when the bind context itself is released. Calling RegisterObjectBound to register an object with a bind context keeps the object active until the bind context is released. Reusing a bind context in a subsequent binding operation (either for another piece of the same composite moniker or for a different moniker) can make the subsequent binding operation more efficient because it doesn't have to reload that object. This, however, improves performance only if the subsequent binding operation requires some of the same objects as the original one, so you need to balance the possible performance improvement of reusing a bind context against the costs of keeping objects activated unnecessarily. IBindCtx does not provide a method to retrieve a pointer to an object registered using RegisterObjectBound. Assuming the object has registered itself with the running object table, moniker implementations can call IRunningObjectTable::GetObject to retrieve a pointer to the object. Read more on docs.microsoft.com. Removes the object from the bind context, undoing a previous call to RegisterObjectBound. A pointer to the IUnknown interface on the object to be removed. This method can return the following values. This doc was truncated. You would rarely call this method. It is documented primarily for completeness. Releases all pointers to all objects that were previously registered by calls to RegisterObjectBound. If this method succeeds, it returns S_OK. Otherwise, it returns an HRESULT error code. You rarely call this method directly. The system's IBindCtx implementation calls this method when the pointer to the IBindCtx interface on the bind context is released (the bind context is released). If a bind context is not released, all of the registered objects remain active. If the same object has been registered more than once, this method calls the Release method on the object the number of times it was registered. Read more on docs.microsoft.com. Sets new values for the binding parameters stored in the bind context. A pointer to a [BIND_OPTS3](/windows/win32/api/objidl/ns-objidl-bind_opts3-r1) structure containing the binding parameters. This method can return the standard return values E_OUTOFMEMORY and S_OK. A bind context contains a block of parameters that are common to most IMoniker operations. These parameters do not change as the operation moves from piece to piece of a composite moniker. Subsequent binding operations can call IBindCtx::GetBindOptions to retrieve these parameters.

Notes to Callers

This method can be called by moniker clients (those who use monikers to acquire interface pointers to objects). When you first create a bind context by using the CreateBindCtx function, the fields of the BIND_OPTS structure are initialized to the following values: This doc was truncated. Read more on docs.microsoft.com. Retrieves the binding options stored in this bind context. A pointer to an initialized structure that receives the current binding parameters on return. See [BIND_OPTS3](/windows/win32/api/objidl/ns-objidl-bind_opts3-r1). This method can return the standard return values E_UNEXPECTED and S_OK. A bind context contains a block of parameters that are common to most IMoniker operations and that do not change as the operation moves from piece to piece of a composite moniker.

Notes to Callers

You typically call this method if you are writing your own moniker class. (This requires that you implement the IMoniker interface.) You call this method to retrieve the parameters specified by the moniker client. You must initialize the structure that is filled in by this method. Before calling this method, you must initialize the cbStruct member to the size of the structure. Read more on docs.microsoft.com. Retrieves an interface pointer to the running object table (ROT) for the computer on which this bind context is running. The address of a IRunningObjectTable* pointer variable that receives the interface pointer to the running object table. If an error occurs, *pprot is set to NULL. If *pprot is non-NULL, the implementation calls AddRef on the running table object; it is the caller's responsibility to call Release. This method can return the standard return values E_OUTOFMEMORY, E_UNEXPECTED, and S_OK. The running object table is a globally accessible table on each computer. It keeps track of all the objects that are currently running on the computer.

Notes to Callers

Typically, those implementing a new moniker class (through an implementation of IMoniker interface) call GetRunningObjectTable. It is useful to call this method in an implementation of IMoniker::BindToObject or IMoniker::IsRunning to check whether an object is currently running. You can also call this method in the implementation of IMoniker::GetTimeOfLastChange to learn when a running object was last modified. Moniker implementations should call this method instead of using the GetRunningObjectTable function. This makes it possible for future implementations of IBindCtx to modify binding behavior. Read more on docs.microsoft.com. Associates an object with a string key in the bind context's string-keyed table of pointers. The bind context string key under which the object is being registered. Key string comparison is case-sensitive. A pointer to the IUnknown interface on the object that is to be registered. The method calls AddRef on the pointer. Read more on docs.microsoft.com. This method can return the standard return values E_OUTOFMEMORY and S_OK. A bind context maintains a table of interface pointers, each associated with a string key. This enables communication between a moniker implementation and the caller that initiated the binding operation. One party can store an interface pointer under a string known to both parties so that the other party can later retrieve it from the bind context. Binding operations subsequent to the use of this method can use IBindCtx::GetObjectParam to retrieve the stored pointer.

Notes to Callers

RegisterObjectParam is useful to those implementing a new moniker class (through an implementation of IMoniker) and to moniker clients (those who use monikers to bind to objects). In implementing a new moniker class, you call this method when an error occurs during moniker binding to inform the caller of the cause of the error. The key that you would obtain with a call to this method would depend on the error condition. Following is a list of common moniker binding errors, describing for each the keys that would be appropriate: This doc was truncated. Read more on docs.microsoft.com. Retrieves an interface pointer to the object associated with the specified key in the bind context's string-keyed table of pointers. The bind context string key to be searched for. Key string comparison is case-sensitive. The address of an IUnknown* pointer variable that receives the interface pointer to the object associated with pszKey. When successful, the implementation calls AddRef on *ppunk. It is the caller's responsibility to call Release. If an error occurs, the implementation sets *ppunk to NULL. If the method succeeds, the return value is S_OK. Otherwise, it is E_FAIL. A bind context maintains a table of interface pointers, each associated with a string key. This enables communication between a moniker implementation and the caller that initiated the binding operation. One party can store an interface pointer under a string known to both parties so that the other party can later retrieve it from the bind context. The pointer this method retrieves must have previously been inserted into the table using the IBindCtx::RegisterObjectParam method.

Notes to Callers

Objects using monikers to locate other objects can call this method when a binding operation fails to get specific information about the error that occurred. Depending on the error, it may be possible to correct the situation and retry the binding operation. See IBindCtx::RegisterObjectParam for more information. Moniker implementations can call this method to handle situations where a caller initiates a binding operation and requests specific information. By convention, the implementer should use key names that begin with the string form of the CLSID of a moniker class. (See the StringFromCLSID function.) Read more on docs.microsoft.com. Retrieves a pointer to an interface that can be used to enumerate the keys of the bind context's string-keyed table of pointers. The address of an IEnumString* pointer variable that receives the interface pointer to the enumerator. If an error occurs, *ppenum is set to NULL. If *ppenum is non-NULL, the implementation calls AddRef on *ppenum; it is the caller's responsibility to call Release. This method can return the standard return values E_OUTOFMEMORY and S_OK. The keys returned by the enumerator are the ones previously specified in calls to IBindCtx::RegisterObjectParam.

Notes to Callers

A bind context maintains a table of interface pointers, each associated with a string key. This enables communication between a moniker implementation and the caller that initiated the binding operation. One party can store an interface pointer under a string known to both parties so that the other party can later retrieve it from the bind context. In the system implementation of the IBindCtx interface, this method is not implemented. Therefore, calling this method results in a return value of E_NOTIMPL. Read more on docs.microsoft.com. Removes the specified key and its associated pointer from the bind context's string-keyed table of objects. The key must have previously been inserted into the table with a call to RegisterObjectParam. The bind context string key to be removed. Key string comparison is case-sensitive. This method can return the following values. This doc was truncated. A bind context maintains a table of interface pointers, each associated with a string key. This enables communication between a moniker implementation and the caller that initiated the binding operation. One party can store an interface pointer under a string known to both parties so that the other party can later retrieve it from the bind context. This method is used to remove an entry from the table. If the specified key is found, the bind context also releases its reference to the object. Read more on docs.microsoft.com. The IID guid for this interface. {0000000e-0000-0000-c000-000000000046} Called by a data consumer to obtain data from a source data object. A pointer to the FORMATETC structure that defines the format, medium, and target device to use when passing the data. It is possible to specify more than one medium by using the Boolean OR operator, allowing the method to choose the best medium among those specified. 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. If pUnkForRelease is NULL, the receiver of the medium is responsible for releasing it; otherwise, pUnkForRelease points to the IUnknown on the appropriate object so its Release method can be called. The medium must be allocated and filled in by GetData. This method returns S_OK on success. Other possible values include the following. This doc was truncated. A data consumer calls GetData to retrieve data from a data object, conveyed through a storage medium (defined through the STGMEDIUM structure).

Notes to Callers

You can specify more than one acceptable tymed medium with the Boolean OR operator. GetData must choose from the OR'd values the medium that best represents the data, do the allocation, and indicate responsibility for releasing the medium. Data transferred across a stream extends from position zero of the stream pointer through to the position immediately before the current stream pointer (that is, the stream pointer position upon exit).

Notes to Implementers

GetData must check all fields in the FORMATETC structure. It is important that GetData render the requested aspect and, if possible, use the requested medium. If the data object cannot comply with the information specified in the FORMATETC, the method should return DV_E_FORMATETC. If an attempt to allocate the medium fails, the method should return STG_E_MEDIUMFULL. It is important to fill in all of the fields in the STGMEDIUM structure. Although the caller can specify more than one medium for returning the data, GetData can provide only one medium. If the initial transfer fails with the selected medium, this method can be implemented to try one of the other media specified before returning an error. Read more on docs.microsoft.com. Called by a data consumer to obtain data from a source data object. This method differs from the GetData method in that the caller must allocate and free the specified storage medium. A pointer to the FORMATETC structure that defines the format, medium, and target device to use when passing the data. Only one medium can be specified in tymed, and only the following values are valid: TYMED_ISTORAGE, TYMED_ISTREAM, TYMED_HGLOBAL, or TYMED_FILE. A pointer to the STGMEDIUM structure that defines the storage medium containing the data being transferred. The medium must be allocated by the caller and filled in by GetDataHere. The caller must also free the medium. The implementation of this method must always supply a value of NULL for the punkForRelease member of the STGMEDIUM structure to which this parameter points. This method returns S_OK on success. Other possible values include the following. This doc was truncated. The GetDataHere method is similar to IDataObject::GetData, except that the caller must both allocate and free the medium specified in pmedium. GetDataHere renders the data described in a FORMATETC structure and copies the data into that caller-provided STGMEDIUM structure. For example, if the medium is TYMED_HGLOBAL, this method cannot resize the medium or allocate a new hGlobal. Some media are not appropriate in a call to GetDataHere, including GDI types such as metafiles. The GetDataHere method cannot put data into a caller-provided metafile. In general, the only storage media it is necessary to support in this method are TYMED_ISTORAGE, TYMED_ISTREAM, and TYMED_FILE. When the transfer medium is a stream, OLE makes assumptions about where the data is being returned and the position of the stream's seek pointer. In a GetData call, the data returned is from stream position zero through just before the current seek pointer of the stream (that is, the position on exit). For GetDataHere, the data returned is from the stream position on entry through just before the position on exit. Read more on docs.microsoft.com. Determines whether the data object is capable of rendering the data as specified. Objects attempting a paste or drop operation can call this method before calling IDataObject::GetData to get an indication of whether the operation may be successful. A pointer to the FORMATETC structure defining the format, medium, and target device to use for the query. This method returns S_OK on success. Other possible values include the following This doc was truncated. The client of a data object calls QueryGetData to determine whether passing the specified FORMATETC structure to a subsequent call to IDataObject::GetData is likely to be successful. A successful return from this method does not necessarily ensure the success of the subsequent paste or drop operation. Provides a potentially different but logically equivalent FORMATETC structure. You use this method to determine whether two different FORMATETC structures would return the same data, removing the need for duplicate rendering. A pointer to the 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 IDataObject::GetData. The tymed member is not significant in this case and should be ignored. A pointer to a FORMATETC structure that contains the most general information possible for a specific rendering, making it canonically equivalent to pformatetcIn. The caller must allocate this structure and the GetCanonicalFormatEtc method must fill in the data. To retrieve data in a subsequent call like IDataObject::GetData, the caller uses the specified value of pformatetcOut, unless the value specified is NULL. This value is NULL if the method returns DATA_S_SAMEFORMATETC. The tymed member is not significant in this case and should be ignored. This method can return the following values. This doc was truncated. If a data object can supply exactly the same data for more than one requested FORMATETC structure, GetCanonicalFormatEtc can supply a "canonical", or standard FORMATETC that gives the same rendering as a set of more complicated FORMATETC structures. For example, it is common for the data returned to be insensitive to the target device specified in any one of a set of otherwise similar FORMATETC structures.

Notes to Callers

A call to this method can determine whether two calls to IDataObject::GetData on a data object, specifying two different FORMATETC structures, would actually produce the same renderings, thus eliminating the need for the second call and improving performance. If the call to GetCanonicalFormatEtc results in a canonical format being written to the pformatetcOut parameter, the caller then uses that structure in a subsequent call to IDataObject::GetData.

Notes to Implementers

Conceptually, it is possible to think of FORMATETC structures in groups defined by a canonical FORMATETC that provides the same results as each of the group members. In constructing the canonical FORMATETC, you should make sure it contains the most general information possible that still produces a specific rendering. For data objects that never provide device-specific renderings, the simplest implementation of this method is to copy the input FORMATETC to the output FORMATETC, store a NULL in the ptd member of the output FORMATETC, and return DATA_S_SAMEFORMATETC. Read more on docs.microsoft.com. Called by an object containing a data source to transfer data to the object that implements this method. A pointer to the FORMATETC structure defining the format used by the data object when interpreting the data contained in the storage medium. A pointer to the STGMEDIUM structure defining the storage medium in which the data is being passed. If TRUE, the data object called, which implements SetData, owns the storage medium after the call returns. This means it must free the medium after it has been used by calling the ReleaseStgMedium function. If FALSE, the caller retains ownership of the storage medium and the data object called uses the storage medium for the duration of the call only. This method returns S_OK on success. Other possible values include the following. This doc was truncated. SetData allows another object to attempt to send data to the implementing data object. A data object implements this method if it supports receiving data from another object. If it does not support this, it should be implemented to return E_NOTIMPL. The caller allocates the storage medium indicated by the pmedium parameter, in which the data is passed. The data object called does not take ownership of the data until it has successfully received it and no error code is returned. The value of the fRelease parameter indicates the ownership of the medium after the call returns. FALSE indicates the caller still owns the medium, and the data object only has the use of it during the call; TRUE indicates that the data object now owns it and must release it when it is no longer needed. The type of medium specified in the pformatetc and pmedium parameters must be the same. For example, one cannot be a global handle and the other a stream. Read more on docs.microsoft.com. Creates an object to enumerate the formats supported by a data object. The direction of the data. Possible values come from the DATADIR enumeration. The value DATADIR_GET enumerates the formats that can be passed in to a call to IDataObject::GetData. The value DATADIR_SET enumerates those formats that can be passed in to a call to IDataObject::SetData. Read more on docs.microsoft.com. A pointer to an IEnumFORMATETC pointer variable that receives the interface pointer to the new enumerator object. This method returns S_OK on success. Other possible values include the following. This doc was truncated. EnumFormatEtc creates an enumerator object that can be used to determine all of the ways the data object can describe data in a FORMATETC structure, and provides a pointer to its IEnumFORMATETC interface. This is one of the standard enumerator interfaces.

Notes to Callers

Having obtained the pointer, the caller can enumerate the FORMATETC structures by calling the enumeration methods of IEnumFORMATETC. Because the formats can change over time, there is no guarantee that an enumerated format is currently supported because the formats can change over time. Accordingly, applications should treat the enumeration as a hint of the format types that can be passed. The caller is responsible for calling Release when it is finished with the enumerator. EnumFormatEtc is called when one of the following actions occurs: This doc was truncated. Read more on docs.microsoft.com. Called by an object supporting an advise sink to create a connection between a data object and the advise sink. This enables the advise sink to be notified of changes in the data of the object. A pointer to a FORMATETC structure that defines the format, target device, aspect, and medium that will be used for future notifications. For example, one sink may want to know only when the bitmap representation of the data in the data object changes. Another sink may be interested in only the metafile format of the same object. Each advise sink is notified when the data of interest changes. This data is passed back to the advise sink when notification occurs. A group of flags for controlling the advisory connection. Possible values are from the ADVF enumeration. However, only some of the possible ADVF values are relevant for this method. The following table briefly describes the relevant values. This doc was truncated. Read more on docs.microsoft.com. A pointer to the IAdviseSink interface on the advisory sink that will receive the change notification. A token that identifies this connection. You can use this token later to delete the advisory connection (by passing it to IDataObject::DUnadvise). If this value is 0, the connection was not established. This method returns S_OK on success. Other possible values include the following. This doc was truncated. DAdvise creates a change notification connection between a data object and the caller. The caller provides an advisory sink to which the notifications can be sent when the object's data changes. Objects used simply for data transfer typically do not support advisory notifications and return OLE_E_ADVISENOTSUPPORTED from DAdvise.

Notes to Callers

The object supporting the advise sink calls DAdvise to set up the connection, specifying the format, aspect, medium, and/or target device of interest in the FORMATETC structure passed in. If the data object does not support one or more of the requested attributes or the sending of notifications at all, it can refuse the connection by returning OLE_E_ADVISENOTSUPPORTED. Containers of linked objects can set up advisory connections directly with the bound link source or indirectly through the standard OLE link object that manages the connection. Connections set up with the bound link source are not automatically deleted. The container must explicitly call IDataObject::DUnadvise on the bound link source to delete an advisory connection. The OLE link object, manipulated through the IOleLink interface, is implemented in the default handler. Connections set up through the OLE link object are destroyed when the link object is deleted. The OLE default link object creates a "wildcard advise" with the link source so OLE can maintain the time of last change. This advise is specifically used to note the time that anything changed. OLE ignores all data formats that may have changed, noting only the time of last change. To allow wildcard advises, set the FORMATETC members as follows before calling DAdvise: This doc was truncated. Read more on docs.microsoft.com. Destroys a notification connection that had been previously set up. A token that specifies the connection to be removed. Use the value returned by IDataObject::DAdvise when the connection was originally established. This method returns S_OK on success. Other possible values include the following. This doc was truncated. This methods destroys a notification created with a call to the IDataObject::DAdvise method. If the advisory connection being deleted was initially set up by delegating the IDataObject::DAdvise call to IDataAdviseHolder::Advise, you must delegate this call to IDataAdviseHolder::Unadvise to delete it. Read more on docs.microsoft.com. Creates an object that can be used to enumerate the current advisory connections. A pointer to an IEnumSTATDATA pointer variable that receives the interface pointer to the new enumerator object. If the implementation sets *ppenumAdvise to NULL, there are no connections to advise sinks at this time. This method returns S_OK if the enumerator object is successfully instantiated or there are no connections. Other possible values include the following. This doc was truncated. The enumerator object created by this method implements the IEnumSTATDATA interface. IEnumSTATDATA permits the enumeration of the data stored in an array of STATDATA structures. Each of these structures provides information on a single advisory connection, and includes FORMATETC and ADVF information, as well as the pointer to the advise sink and the token representing the connection.

Notes to Callers

It is recommended that you use the OLE data advise holder object to handle advisory connections. With the pointer obtained through a call to CreateDataAdviseHolder, implementing IDataObject::EnumDAdvise becomes a simple matter of delegating the call to IDataAdviseHolder::EnumAdvise. This creates the enumerator and supplies the pointer to the OLE implementation of IEnumSTATDATA. At that point, you can call its methods to enumerate the current advisory connections. Read more on docs.microsoft.com. The IID guid for this interface. {0000010e-0000-0000-c000-000000000046} 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} Retrieves the specified number of items in the enumeration sequence. (IEnumFORMATETC.Next) The number of items to be retrieved. If there are fewer than the requested number of items left in the sequence, this method retrieves the remaining elements. An array of enumerated items. The enumerator is responsible for allocating any memory, and the caller is responsible for freeing it. If celt is greater than 1, the caller must also pass a non-NULL pointer passed to pceltFetched to know how many pointers to release. Read more on docs.microsoft.com. The number of items that were retrieved. This parameter is always less than or equal to the number of items requested. This parameter can be NULL if celt is 1. If the method retrieves the number of items requested, the return value is S_OK. Otherwise, it is S_FALSE. Learn more about this API from docs.microsoft.com. Skips over the specified number of items in the enumeration sequence. (IEnumFORMATETC.Skip) The number of items to be skipped. If the method skips the number of items requested, the return value is S_OK. Otherwise, it is S_FALSE. Learn more about this API from docs.microsoft.com. Resets the enumeration sequence to the beginning. (IEnumFORMATETC.Reset) This method returns S_OK on success. There is no guarantee that the same set of objects will be enumerated after the reset operation has completed. A static collection is reset to the beginning, but it can be too expensive for some collections, such as files in a directory, to guarantee this condition. Creates a new enumerator that contains the same enumeration state as the current one. (IEnumFORMATETC.Clone) Address of an IEnumFORMATETC pointer variable that receives the interface pointer to the enumeration object. If the method is unsuccessful, the value of this output variable is undefined. This method returns S_OK on success. Other possible values include the following. This doc was truncated. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {00000103-0000-0000-c000-000000000046} Retrieves the specified number of items in the enumeration sequence. (IEnumMoniker.Next) The number of items to be retrieved. If there are fewer than the requested number of items left in the sequence, this method retrieves the remaining elements. An array of enumerated items. The enumerator is responsible for calling AddRef, and the caller is responsible for calling Release through each pointer enumerated. If celt is greater than 1, the caller must also pass a non-NULL pointer passed to pceltFetched to know how many pointers to release. Read more on docs.microsoft.com. The number of items that were retrieved. This parameter is always less than or equal to the number of items requested. This parameter can be NULL if celt is 1. If the method retrieves the number of items requested, the return value is S_OK. Otherwise, it is S_FALSE. Learn more about this API from docs.microsoft.com. Skips over the specified number of items in the enumeration sequence. (IEnumMoniker.Skip) The number of items to be skipped. If the method skips the number of items requested, the return value is S_OK. Otherwise, it is S_FALSE. Learn more about this API from docs.microsoft.com. Resets the enumeration sequence to the beginning. (IEnumMoniker.Reset) This method returns S_OK on success. There is no guarantee that the same set of objects will be enumerated after the reset operation has completed. A static collection is reset to the beginning, but it can be too expensive for some collections, such as files in a directory, to guarantee this condition. Creates a new enumerator that contains the same enumeration state as the current one. (IEnumMoniker.Clone) Address of an IEnumMoniker pointer variable that receives the interface pointer to the enumeration object. If the method is unsuccessful, the value of this output variable is undefined. This method returns S_OK on success. Other possible values include the following. This doc was truncated. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {00000102-0000-0000-c000-000000000046} Retrieves the specified number of items in the enumeration sequence. (IEnumSTATDATA.Next) The number of items to be retrieved. If there are fewer than the requested number of items left in the sequence, this method retrieves the remaining elements. An array of enumerated items. The enumerator is responsible for allocating any memory, and the caller is responsible for freeing it. If celt is greater than 1, the caller must also pass a non-NULL pointer passed to pceltFetched to know how many pointers to release. Read more on docs.microsoft.com. The number of items that were retrieved. This parameter is always less than or equal to the number of items requested. This parameter can be NULL if celt is 1. If the method retrieves the number of items requested, the return value is S_OK. Otherwise, it is S_FALSE. Learn more about this API from docs.microsoft.com. Skips over the specified number of items in the enumeration sequence. (IEnumSTATDATA.Skip) The number of items to be skipped. If the method skips the number of items requested, the return value is S_OK. Otherwise, it is S_FALSE. Learn more about this API from docs.microsoft.com. Resets the enumeration sequence to the beginning. (IEnumSTATDATA.Reset) This method returns S_OK on success. There is no guarantee that the same set of objects will be enumerated after the reset operation has completed. A static collection is reset to the beginning, but it can be too expensive for some collections, such as files in a directory, to guarantee this condition. Creates a new enumerator that contains the same enumeration state as the current one. (IEnumSTATDATA.Clone) A pointer to an IEnumSTATDATA pointer variable that receives the interface pointer to the enumeration object. If the method is unsuccessful, the value of this output variable is undefined. This method returns S_OK on success. Other possible values include the following. This doc was truncated. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {00000105-0000-0000-c000-000000000046} Retrieves a specified number of STATSTG structures, that follow in the enumeration sequence. The number of STATSTG structures requested. An array of STATSTG structures returned. The number of STATSTG structures retrieved in the rgelt parameter. This method supports the following return values: This doc was truncated. Learn more about this API from docs.microsoft.com. Skips a specified number of STATSTG structures in the enumeration sequence. The number of STATSTG structures to skip. This method supports the following return values: | Return code | Description | |----------------|---------------| | S_OK | The specified number of **STATSTG** structures that were successfully skipped. | | S_FALSE | The number of **STATSTG** structures skipped is less than the *celt* parameter. | Learn more about this API from docs.microsoft.com. Resets the enumeration sequence to the beginning of the STATSTG structure array. This method supports the S_OK return value. This doc was truncated. Learn more about this API from docs.microsoft.com. Creates a new enumerator that contains the same enumeration state as the current STATSTG structure enumerator. A pointer to the variable that receives the IEnumSTATSTG interface pointer. If the method is unsuccessful, the value of the ppenum parameter is undefined. Read more on docs.microsoft.com. This method supports the following return values. This doc was truncated. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {0000000d-0000-0000-c000-000000000046} Creates and opens a stream object with the specified name contained in this storage object. A pointer to a wide character null-terminated Unicode string that contains the name of the newly created stream. The name can be used later to open or reopen the stream. The name must not exceed 31 characters in length, not including the string terminator. The 000 through 01f characters, serving as the first character of the stream/storage name, are reserved for use by OLE. This is a compound file restriction, not a structured storage restriction. Specifies the access mode to use when opening the newly created stream. For more information and descriptions of the possible values, see STGM Constants. Reserved for future use; must be zero. Reserved for future use; must be zero. On return, pointer to the location of the new IStream interface pointer. This is only valid if the operation is successful. When an error occurs, this parameter is set to NULL. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The new stream was successfully created.| |E_PENDING | Asynchronous Storage only: Part or all of the necessary data is currently unavailable. | |STG_E_ACCESSDENIED | Not enough permissions to create stream.| |STG_E_FILEALREADYEXISTS | The name specified for the stream already exists in the storage object and the *grfMode* parameter includes the value STGM_FAILIFTHERE.| |STG_E_INSUFFICIENTMEMORY | The stream was not created due to a lack of memory.| |STG_E_INVALIDFLAG | The value specified for the *grfMode* parameter is not a valid **STGM** constants value.| |STG_E_INVALIDFUNCTION | The specified combination of flags in the *grfMode* parameter is not supported; for example, when this method is called without the STGM_SHARE_EXCLUSIVE flag.| |STG_E_INVALIDNAME | Invalid value for *pwcsName*.| |STG_E_INVALIDPOINTER | The pointer specified for the stream object was invalid.| |STG_E_INVALIDPARAMETER | One of the parameters was invalid.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| |STG_E_TOOMANYOPENFILES | The stream was not created because there are too many open files.| If a stream with the name specified in the pwcsName parameter already exists and the grfMode parameter includes the STGM_CREATE flag, the existing stream is replaced by a newly created one. Both the destruction of the old stream and the creation of the new stream object are subject to the transaction mode on the parent storage object. The COM-provided compound file implementation of the IStorage::CreateStream method does not support the following behaviors: This doc was truncated. Read more on docs.microsoft.com. Opens an existing stream object within this storage object in the specified access mode. A pointer to a wide character null-terminated Unicode string that contains the name of the stream to open. The 000 through 01f characters, serving as the first character of the stream/storage name, are reserved for use by OLE. This is a compound file restriction, not a structured storage restriction. Reserved for future use; must be NULL. Specifies the access mode to be assigned to the open stream. For more information and descriptions of possible values, see STGM Constants. Other modes you choose must at least specify STGM_SHARE_EXCLUSIVE when calling this method in the compound file implementation. Reserved for future use; must be zero. A pointer to IStream pointer variable that receives the interface pointer to the newly opened stream object. If an error occurs, *ppstm must be set to NULL. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The stream was successfully opened.| |E_PENDING | Asynchronous Storage only: Part or all of the stream data is currently unavailable. | |STG_E_ACCESSDENIED | Not enough permissions to open stream.| |STG_E_FILENOTFOUND | The stream with specified name does not exist.| |STG_E_INSUFFICIENTMEMORY | The stream was not opened due to a lack of memory.| |STG_E_INVALIDFLAG | The value specified for the *grfMode* parameter is not a valid **STGM** constants value.| |STG_E_INVALIDFUNCTION | The specified combination of flags in the *grfMode* parameter is not supported; for example, when this method is called without the STGM_SHARE_EXCLUSIVE flag.| |STG_E_INVALIDNAME | Invalid value for *pwcsName*.| |STG_E_INVALIDPOINTER | The pointer specified for the stream object was not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| |STG_E_TOOMANYOPENFILES | The stream was not opened because there are too many open files.| IStorage::OpenStream opens an existing stream object within this storage object in the access mode specified in grfMode. There are restrictions on the permissions that can be given in grfMode. For example, the permissions on this storage object restrict the permissions on its streams. In general, access restrictions on streams need to be stricter than those on their parent storages. Compound-file streams must be opened with STGM_SHARE_EXCLUSIVE. Opens an existing storage object with the specified name in the specified access mode. A pointer to a wide character null-terminated Unicode string that contains the name of the storage object to open. The 000 through 01f characters, serving as the first character of the stream/storage name, are reserved for use by OLE. This is a compound file restriction, not a structured storage restriction. It is ignored if pstgPriority is non-NULL. Must be NULL. A non-NULL value will return STG_E_INVALIDPARAMETER. Specifies the access mode to use when opening the storage object. For descriptions of the possible values, see STGM Constants. Other modes you choose must at least specify STGM_SHARE_EXCLUSIVE when calling this method. Must be NULL. A non-NULL value will return STG_E_INVALIDPARAMETER. Reserved for future use; must be zero. When successful, pointer to the location of an IStorage pointer to the opened storage object. This parameter is set to NULL if an error occurs. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The storage object was opened successfully.| |E_PENDING | Asynchronous Storage only: Part or all of the storage's data is currently unavailable. | |STG_E_ACCESSDENIED | Not enough permissions to open storage object.| |STG_E_FILENOTFOUND | The storage object with the specified name does not exist.| |STG_E_INSUFFICIENTMEMORY | The storage object was not opened due to a lack of memory.| |STG_E_INVALIDFLAG | The value specified for the *grfMode* parameter is not a valid **STGM** constants value.| |STG_E_INVALIDFUNCTION | The specified combination of flags in the *grfMode* parameter is not supported.| |STG_E_INVALIDNAME | Not a valid value for *pwcsName*.| |STG_E_INVALIDPOINTER | The pointer specified for the storage object was not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| |STG_E_TOOMANYOPENFILES | The storage object was not created because there are too many open files.| |STG_S_CONVERTED | The existing stream with the specified name was replaced with a new storage object containing a single stream called CONTENTS. In direct mode, the new storage is immediately written to disk. In transacted mode, the new storage is written to a temporary storage in memory and later written to disk when it is committed.| If the pstgPriority parameter is NULL, it is ignored. If the pstgPriority parameter is not NULL, it is an IStorage pointer to a previous opening of an element of the storage object, usually one that was opened in priority mode. The storage object should be closed and reopened according to grfMode. When the IStorage::OpenStorage method returns, pstgPriority is no longer valid. Use the value supplied in the ppstg parameter. Storage objects can be opened with STGM_DELETEONRELEASE, in which case the object is destroyed when it receives its final release. This is useful for creating temporary storage objects. Read more on docs.microsoft.com. Copies the entire contents of an open storage object to another storage object. The number of elements in the array pointed to by rgiidExclude. If rgiidExclude is NULL, then ciidExclude is ignored. An array of interface identifiers (IIDs) that either the caller knows about and does not want copied or that the storage object does not support, but whose state the caller will later explicitly copy. The array can include IStorage, indicating that only stream objects are to be copied, and IStream, indicating that only storage objects are to be copied. An array length of zero indicates that only the state exposed by the IStorage object is to be copied; all other interfaces on the object are to be ignored. Passing NULL indicates that all interfaces on the object are to be copied. Read more on docs.microsoft.com. A string name block (refer to SNB) that specifies a block of storage or stream objects that are not to be copied to the destination. These elements are not created at the destination. If IID_IStorage is in the rgiidExclude array, this parameter is ignored. This parameter may be NULL. Read more on docs.microsoft.com. A pointer to the open storage object into which this storage object is to be copied. The destination storage object can be a different implementation of the IStorage interface from the source storage object. Thus, IStorage::CopyTo can use only publicly available methods of the destination storage object. If pstgDest is open in transacted mode, it can be reverted by calling its IStorage::Revert method. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The storage object was successfully copied.| |E_PENDING | Asynchronous Storage only: Part or all of the data to be copied is currently unavailable. | |STG_E_ACCESSDENIED | The destination storage object is a child of the source storage object.| |STG_E_INSUFFICIENTMEMORY | The copy was not completed due to a lack of memory.| |STG_E_INVALIDPOINTER | The pointer specified for the storage object was not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| |STG_E_TOOMANYOPENFILES | The copy was not completed because there are too many open files.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| |STG_E_MEDIUMFULL | The copy was not completed because the storage medium is full.| This method merges elements contained in the source storage object with those already present in the destination. The layout of the destination storage object may differ from the source storage object. The copy process is recursive, invoking IStorage::CopyTo and IStream::CopyTo on the elements nested inside the source. When copying a stream on top of an existing stream with the same name, the existing stream is first removed and then replaced with the source stream. When copying a storage on top of an existing storage with the same name, the existing storage is not removed. As a result, after the copy operation, the destination IStorage contains older elements, unless they were replaced by newer ones with the same names. A storage object may expose interfaces other than IStorage, including IRootStorage, IPropertyStorage, or IPropertySetStorage. The rgiidExclude parameter permits the exclusion of any or all of these additional interfaces from the copy operation. A caller with a newer or more efficient copy of an existing substorage or stream object may want to exclude the current versions of these objects from the copy operation. The snbExclude and rgiidExclude parameters provide two ways of excluding a storage objects existing storages or streams.

Note to Callers

The most common way to use the IStorage::CopyTo method is to copy everything from the source to the destination, as in most full-save and save-as operations. The following example code shows how to copy everything from the source storage object to the destination storage object. This doc was truncated. Read more on docs.microsoft.com. The MoveElementTo method copies or moves a substorage or stream from this storage object to another storage object. Pointer to a wide character null-terminated Unicode string that contains the name of the element in this storage object to be moved or copied. IStorage pointer to the destination storage object. Pointer to a wide character null-terminated unicode string that contains the new name for the element in its new storage object. Specifies whether the operation should be a move (STGMOVE_MOVE) or a copy (STGMOVE_COPY). See the STGMOVE enumeration. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The storage object was successfully copied or moved.| |E_PENDING | Asynchronous Storage only: Part or all of the element's data is currently unavailable. | |STG_E_ACCESSDENIED | The destination storage object is a child of the source storage object. Or, the destination object and element name are the same as the source object and element name. In other words, you cannot move an element to itself.| |STG_E_FILENOTFOUND | The element with the specified name does not exist.| |STG_E_FILEALREADYEXISTS | The specified file already exists.| |STG_E_INSUFFICIENTMEMORY | The copy or move was not completed due to a lack of memory.| |STG_E_INVALIDFLAG | The value for the *grfFlags* parameter is not valid.| |STG_E_INVALIDNAME | Not a valid value for *pwcsName*.| |STG_E_INVALIDPOINTER | The pointer specified for the storage object was not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| |STG_E_TOOMANYOPENFILES | The copy or move was not completed because there are too many open files.| The IStorage::MoveElementTo method is typically the same as invoking the IStorage::CopyTo method on the indicated element and then removing the source element. In this case, the MoveElementTo method uses only the publicly available functions of the destination storage object to carry out the move. If the source and destination storage objects have special knowledge about each other's implementation (they could, for example, be different instances of the same implementation), this method can be implemented more efficiently. Before calling this method, the element to be moved must be closed, and the destination storage must be open. Also, the destination object and element cannot be the same storage object/element name as the source of the move. That is, you cannot move an element to itself. Read more on docs.microsoft.com. The Commit method ensures that any changes made to a storage object open in transacted mode are reflected in the parent storage. Controls how the changes are committed to the storage object. See the STGC enumeration for a definition of these values. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | Changes to the storage object were successfully committed to the parent level. If STGC_CONSOLIDATE was specified, the storage was successfully consolidated, or the storage was already too compact to consolidate further.| |STG_S_MULTIPLEOPENS | The commit operation succeeded, but the storage could not be consolidated because it had been opened multiple times using the STGM_NOSNAPSHOT flag.| |STG_S_CANNOTCONSOLIDATE | The commit operation succeeded, but the storage could not be consolidated due to an incorrect storage mode. For compound files, the storage may have been opened using the STGM_NOSCRATCH flag, or the storage may not be the outermost transacted level.| |STG_S_CONSOLIDATIONFAILED | The commit operation succeeded, but the storage could not be consolidated due to an internal error (for example, a memory allocation failure).| |E_PENDING | Asynchronous storage only: Part or all of the data to be committed is currently unavailable.| |STG_E_INVALIDFLAG | The value for the *grfCommitFlags* parameter is not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| |STG_E_NOTCURRENT | Another open instance of the storage object has committed changes. As a result, the current commit operation may overwrite previous changes.| |STG_E_MEDIUMFULL | No space left on device to commit.| |STG_E_TOOMANYOPENFILES | The commit operation could not be completed because there are too many open files.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| IStorage::Commit makes permanent changes to a storage object that is in transacted mode, in which changes are accumulated in a buffer, and not reflected in the storage object until there is a call to this method. The alternative is to open an object in direct mode, in which changes are immediately reflected in the storage object. An object opened in the direct mode does not require calling IStorage::Commit to make permanent changes in the storage object. Calling the IStorage::Commit method on a nonroot storage opened in direct mode has no effect. Opening a root storage object in direct mode ensures that changes in memory buffers are written to the underlying storage device. The commit operation publishes the current changes in this storage object and its children to the next level up in the storage hierarchy. To undo current changes before committing them, call IStorage::Revert to roll back to the last-committed version. Calling IStorage::Commit has no effect on currently opened nested elements of this storage object. They remain valid and can be used. However, the IStorage::Commit method does not automatically commit changes to these nested elements. The commit operation publishes only known changes to the next higher level in the storage hierarchy. Thus, transactions to nested levels must be committed to this storage object before they can be committed to higher levels. In commit operations, you need to take steps to ensure that data is protected during the commit process: This doc was truncated. Read more on docs.microsoft.com. The Revert method discards all changes that have been made to the storage object since the last commit operation. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The revert operation was successful.| |E_PENDING | Asynchronous Storage only: Part or all of the storage's data is currently unavailable. | |STG_E_INSUFFICIENTMEMORY | The revert operation could not be completed due to a lack of memory.| |STG_E_TOOMANYOPENFILES | The revert operation could not be completed because there are too many open files.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| For storage objects opened in transacted mode, the IStorage::Revert method discards any uncommitted changes to this storage object or changes that have been committed to this storage object from nested elements. After this method returns, any existing elements (substorages or streams) that were opened from the reverted storage object are invalid and can no longer be used. Specifying these reverted elements in any call except IUnknown::Release returns the error STG_E_REVERTED This method has no effect on storage objects opened in direct mode. Read more on docs.microsoft.com. The EnumElements method retrieves a pointer to an enumerator object that can be used to enumerate the storage and stream objects contained within this storage object. Reserved for future use; must be zero. Reserved for future use; must be NULL. Reserved for future use; must be zero. Pointer to IEnumSTATSTG* pointer variable that receives the interface pointer to the new enumerator object. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The enumerator object was successfully returned.| |E_PENDING | Asynchronous Storage only: Part or all of the element's data is currently unavailable.| |STG_E_INSUFFICIENTMEMORY | The enumerator object could not be created due to lack of memory.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| The enumerator object returned by this method implements the IEnumSTATSTG interface, one of the standard enumerator interfaces that contain the Next, Reset, Clone, and Skip methods. IEnumSTATSTG enumerates the data stored in an array of STATSTG structures. The storage object must be open in read mode to allow the enumeration of its elements. The enumerator object is permitted to enumerate the elements in any order. The enumerator object is also permitted to treat the enumeration as a snapshot or to have the enumeration reflect the current state of the storage object. Read more on docs.microsoft.com. The RenameElement method renames the specified substorage or stream in this storage object. Pointer to a wide character null-terminated Unicode string that contains the name of the substorage or stream to be changed.
Note  The pwcsName, created in CreateStorage or CreateStream must not exceed 31 characters in length, not including the string terminator.
 
 Read more on docs.microsoft.com. Pointer to a wide character null-terminated unicode string that contains the new name for the specified substorage or stream.
Note  The pwcsName, created in CreateStorage or CreateStream must not exceed 31 characters in length, not including the string terminator.
 
 Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The element was successfully renamed.| |E_PENDING | Asynchronous Storage only: Part or all of the element's data is currently unavailable.| |STG_E_ACCESSDENIED | The caller does not have enough permissions for renaming the element.| |STG_E_FILENOTFOUND | The element with the specified old name does not exist.| |STG_E_FILEALREADYEXISTS | The element specified by the new name already exists.| |STG_E_INSUFFICIENTMEMORY | The element was not renamed due to a lack of memory.| |STG_E_INVALIDNAME | Invalid value for one of the names.| |STG_E_INVALIDPOINTER | The pointer specified for the element was not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| |STG_E_TOOMANYOPENFILES | The element was not renamed because there are too many open files.| IStorage::RenameElement renames the specified substorage or stream in this storage object. An element in a storage object cannot be renamed while it is open. The rename operation is subject to committing the changes if the storage is open in transacted mode. The IStorage::RenameElement method is not guaranteed to work in low memory with storage objects open in transacted mode. It may work in direct mode. Read more on docs.microsoft.com. The SetElementTimes method sets the modification, access, and creation times of the specified storage element, if the underlying file system supports this method. The name of the storage object element whose times are to be modified. If NULL, the time is set on the root storage rather than one of its elements. Either the new creation time for the element or NULL if the creation time is not to be modified. Either the new access time for the element or NULL if the access time is not to be modified. Either the new modification time for the element or NULL if the modification time is not to be modified. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The time values were successfully set.| |E_PENDING | Asynchronous Storage only: Part or all of the element's data is currently unavailable.| |STG_E_ACCESSDENIED | The caller does not have enough permissions for changing the element.| |STG_E_FILENOTFOUND | The element with the specified name does not exist.| |STG_E_INSUFFICIENTMEMORY | The element was not changed due to a lack of memory.| |STG_E_INVALIDNAME | Not a valid value for the element name.| |STG_E_INVALIDPOINTER | The pointer specified for the element was not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| |STG_E_TOOMANYOPENFILES | The element was not changed because there are too many open files.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| SetElementTimes sets time statistics for the specified storage element within this storage object. Not all file systems support all the time values. This method sets those times that are supported and ignores the rest. Each time-value parameter can be NULL; indicating that no modification should occur. Call the IStorage::Stat method to retrieve these time values. Read more on docs.microsoft.com. The SetClass method assigns the specified class identifier (CLSID) to this storage object. The CLSID that is to be associated with the storage object. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The CLSID was successfully assigned.| |E_PENDING | Asynchronous Storage only: Part or all of the storage's data is currently unavailable.| |STG_E_ACCESSDENIED | The caller does not have enough permissions for assigning a CLSID to the storage object.| |STG_E_MEDIUMFULL | Not enough space was left on device to complete the operation.| |STG_E_REVERTED | The storage object has been invalidated by a revert operation above it in the transaction tree.| When first created, a storage object has an associated CLSID of CLSID_NULL. Call SetClass to assign a CLSID to the storage object. Call the IStorage::Stat method to retrieve the current CLSID of a storage object. Read more on docs.microsoft.com. The SetStateBits method stores up to 32 bits of state information in this storage object. Specifies the new values of the bits to set. No legal values are defined for these bits; they are all reserved for future use and must not be used by applications. A binary mask indicating which bits in grfStateBits are significant in this call. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The state information was successfully set.| |E_PENDING | Asynchronous Storage only: Part or all of the storage's data is currently unavailable. | |STG_E_ACCESSDENIED | The caller does not have enough permissions for changing this storage object.| |STG_E_INVALIDFLAG | The value for the grfStateBits or *grfMask* parameter is not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| The values for the state bits are not currently defined. The Stat method retrieves the STATSTG structure for this open storage object. On return, pointer to a STATSTG structure where this method places information about the open storage object. This parameter is NULL if an error occurs. Read more on docs.microsoft.com. Specifies that some of the members in the STATSTG structure are not returned, thus saving a memory allocation operation. Values are taken from the STATFLAG enumeration. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The STATSTG structure was successfully returned at the specified location.| |E_PENDING | Asynchronous Storage only: Part or all of the storage's data is currently unavailable.| |STG_E_ACCESSDENIED | The caller does not have enough permissions for accessing statistics for this storage object.| |STG_E_INSUFFICIENTMEMORY | The STATSTG structure was not returned due to a lack of memory.| |STG_E_INVALIDFLAG | The value for the *grfStateFlag* parameter is not valid.| |STG_E_INVALIDPARAMETER | One of the parameters was not valid.| IStorage::Stat retrieves the STATSTG structure for the current storage object. The STATSTG structure contains statistical information about the storage object. IStorage::EnumElements returns a pointer to an enumerator object. The enumerator object returned by this method implements the IEnumSTATSTG interface, through which the data stored in the array of the STATSTG structures is enumerated. Read more on docs.microsoft.com. The IID guid for this interface. {0000000b-0000-0000-c000-000000000046} The IEnumString::Next (objidlbase.h) method retrieves the specified number of items in the enumeration sequence. The number of items to be retrieved. If there are fewer than the requested number of items left in the sequence, this method retrieves the remaining elements. An array of enumerated items. The enumerator is responsible for allocating any memory, and the caller is responsible for freeing it. If celt is greater than 1, the caller must also pass a non-NULL pointer passed to pceltFetched to know how many pointers to release. Read more on docs.microsoft.com. The number of items that were retrieved. This parameter is always less than or equal to the number of items requested. If the method retrieves the number of items requested, the return value is S_OK. Otherwise, it is S_FALSE. Learn more about this API from docs.microsoft.com. The IEnumString::Skip (objidlbase.h) method skips over the specified number of items in the enumeration sequence. The number of items to be skipped. If the method skips the number of items requested, the return value is S_OK. Otherwise, it is S_FALSE. Learn more about this API from docs.microsoft.com. The IEnumString::Reset (objidlbase.h) method resets the enumeration sequence to the beginning. The return value is S_OK. There is no guarantee that the same set of objects will be enumerated after the reset operation has completed. A static collection is reset to the beginning, but it can be too expensive for some collections, such as files in a directory, to guarantee this condition. The IEnumString::Clone (objidlbase.h) method creates a new enumerator that contains the same enumeration state as the current one. A pointer to the cloned enumerator object. This method can return the standard return values E_INVALIDARG, E_OUTOFMEMORY, E_UNEXPECTED, and S_OK. Learn more about this API from docs.microsoft.com. The IID guid for this interface. {00000101-0000-0000-c000-000000000046} Binds to the specified object. The binding process involves finding the object, putting it into the running state if necessary, and providing the caller with a pointer to a specified interface on the identified object. A pointer to the IBindCtx interface on the bind context object, which is used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment. If the moniker is part of a composite moniker, pointer to the moniker to the left of this moniker. This parameter is primarily used by moniker implementers to enable cooperation between the various components of a composite moniker. Moniker clients should use NULL. The IID of the interface the client wishes to use to communicate with the object that the moniker identifies. The address of pointer variable that receives the interface pointer requested in riid. Upon successful return, *ppvResult contains the requested interface pointer to the object the moniker identifies. When successful, the implementation must call AddRef on the moniker. It is the caller's responsibility to call Release. If an error occurs, *ppvResult should be NULL. This method can return the standard return values E_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. This doc was truncated. BindToObject implements the primary function of a moniker, which is to locate the object identified by the moniker and return a pointer to one of its interfaces.

Notes to Callers

If you are using a moniker as a persistent connection between two objects, you activate the connection by calling BindToObject. You typically call BindToObject during the following process: This doc was truncated. Read more on docs.microsoft.com. Binds to the storage for the specified object. Unlike the IMoniker::BindToObject method, this method does not activate the object identified by the moniker. A pointer to the IBindCtx interface on the bind context object, which is used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment. If the moniker is part of a composite moniker, pointer to the moniker to the left of this moniker. This parameter is primarily used by moniker implementers to enable cooperation between the various components of a composite moniker. Moniker clients should use NULL. A reference to the identifier of the storage interface requested, whose pointer will be returned in ppvObj. Storage interfaces commonly requested include IStorage, IStream, and ILockBytes. The address of pointer variable that receives the interface pointer requested in riid. Upon successful return, *ppvObj contains the requested interface pointer to the storage of the object the moniker identifies. When successful, the implementation must call AddRef on the storage. It is the caller's responsibility to call Release. If an error occurs, *ppvObj should be NULL. This method can return the standard return values E_UNEXPECTED, as well as the following values. This doc was truncated. There is an important difference between the BindToObject and BindToStorage methods. If, for example, you have a moniker that identifies a spreadsheet object, calling BindToObject provides access to the spreadsheet object itself, while calling BindToStorage provides access to the storage object in which the spreadsheet resides.

Notes to Callers

Although none of the COM moniker classes call this method in their binding operations, it might be appropriate to call it in the implementation of a new moniker class. You could call this method in an implementation of BindToObject that requires information from the object identified by the pmkToLeft parameter and can get it from the persistent storage of the object without activation. For example, if your monikers are used to identify objects that can be activated without activating their containers, you may find this method useful. A client that can read the storage of the object its moniker identifies could also call this method.

Notes to Implementers

Your implementation should locate the persistent storage for the object identified by the current moniker and return the desired interface pointer. Some types of monikers represent pseudo-objects, which are objects that do not have their own persistent storage. Such objects comprise some portion of the internal state of its container, for example, a range of cells in a spreadsheet. If your moniker class identifies this type of object, your implementation of BindToStorage should return the error MK_E_NOSTORAGE. If the bind context's BIND_OPTS structure specifies the BINDFLAGS_JUSTTESTEXISTENCE flag, your implementation has the option of returning NULL in ppvObj (although you can also ignore the flag and perform the complete binding operation).

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Reduces a moniker to its simplest form. A pointer to the IBindCtx interface on the bind context to be used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment. Specifies how far this moniker should be reduced. This parameter must be one of the values from the MKRREDUCE enumeration. On entry, a pointer to an IMoniker pointer variable that contains the interface pointer to moniker to the left of this moniker. This parameter is used primarily by moniker implementers to enable cooperation between the various components of a composite moniker; moniker clients can usually pass NULL. On return, *ppmkToLeft is usually set to NULL, indicating no change in the original moniker to the left. In rare situations, *ppmkToLeft indicates a moniker, indicating that the previous moniker to the left should be disregarded and the moniker returned through *ppmkToLeft is the replacement. In such a situation, the implementation must call Release on the old moniker to the left of this moniker and must call AddRef on the new returned moniker; the caller must release it later. If an error occurs, the implementation can either leave the interface pointer unchanged or set it to NULL. Read more on docs.microsoft.com. A pointer to an IMoniker pointer variable that receives the interface pointer to the reduced form of this moniker, which can be NULL if an error occurs or if this moniker is reduced to nothing. If this moniker cannot be reduced, *ppmkReduced is simply set to this moniker and the return value is MK_S_REDUCED_TO_SELF. If *ppmkReduced is non-NULL, the implementation must call AddRef on the new moniker; it is the caller's responsibility to call Release. (This is true even if *ppmkReduced is set to this moniker.) This method can return the standard return values E_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. This doc was truncated. This method is intended for the following uses: This doc was truncated. Read more on docs.microsoft.com. Creates a new composite moniker by combining the current moniker with the specified moniker. A pointer to the IMoniker interface on the moniker to compose onto the end of this moniker. If TRUE, the caller requires a nongeneric composition, so the operation should proceed only if pmkRight is a moniker class that this moniker can compose with in some way other than forming a generic composite. If FALSE, the method can create a generic composite if necessary. Most callers should set this parameter to FALSE. A pointer to an IMoniker pointer variable that receives the composite moniker pointer. When successful, the implementation must call AddRef on the resulting moniker; it is the caller's responsibility to call Release. If an error occurs or if the monikers compose to nothing (for example, composing an anti-moniker with an item moniker or a file moniker), *ppmkComposite should be set to NULL. This method can return the standard return values E_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. This doc was truncated. Joining two monikers together is called composition. Sometimes two monikers of the same class can be combined in what is called nongeneric composition. For example, a file moniker representing an incomplete path and another file moniker representing a relative path can be combined to form a single file moniker representing the complete path. Nongeneric composition for a given moniker class can be handled only in the implementation of ComposeWith for that moniker class. Combining two monikers of any class is called generic composition, which can be accomplished through a call to the CreateGenericComposite function. Composition of monikers is an associative operation. That is, if A, B, and C are monikers, then, where Comp() represents the composition operation, Comp( Comp( A, B ), C ) is always equal to Comp( A, Comp( B, C ) ).

Notes to Callers

To combine two monikers, you should call ComposeWith rather than calling the CreateGenericComposite function to give the first moniker a chance to perform a nongeneric composition. An object that provides item monikers to identify its objects would call ComposeWith to provide a moniker that completely identifies the location of the object. This would apply, for example, to a server that supports linking to portions of a document, or to a container that supports linking to embedded objects within its documents. In such a situation, you would do the following: This doc was truncated. Read more on docs.microsoft.com. Retrieves a pointer to an enumerator for the components of a composite moniker. If TRUE, enumerates the monikers from left to right. If FALSE, enumerates from right to left. A pointer to an IEnumMoniker pointer variable that receives the interface pointer to the enumerator object for the moniker. When successful, the implementation must call AddRef on the enumerator object. It is the caller's responsibility to call Release. If an error occurs or if the moniker has no enumerable components, the implementation sets *ppenumMoniker to NULL. This method can return the standard return values E_OUTOFMEMORY, E_UNEXPECTED, and S_OK. This method must supply an IEnumMoniker pointer to an enumerator that can enumerate the components of a moniker. For example, the implementation of the IMoniker::Enum method for a generic composite moniker creates an enumerator that can determine the individual monikers that make up the composite, while the IMoniker::Enum method for a file moniker creates an enumerator that returns monikers representing each of the components in the path.

Notes to Callers

Call this method to examine the components that make up a composite moniker.

Notes to Implementers

If the new moniker class has no discernible internal structure, your implementation of this method can simply return S_OK and set ppenumMoniker to NULL.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Determines whether this moniker is identical to the specified moniker. A pointer to the IMoniker interface on the moniker to be used for comparison with this one (the one from which this method is called). This method returns S_OK to indicate that the two monikers are identical, and S_FALSE otherwise. Previous implementations of the running object table (ROT) called this method. The current implementation of the ROT uses the IROTData interface instead.

Notes to Callers

Call this method to determine whether two monikers are identical. The reduced form of a moniker is considered different from the unreduced form. You should call the IMoniker::Reduce method before calling IsEqual, because a reduced moniker is in its most specific form. IsEqual may return S_FALSE on two monikers before they are reduced, and S_OK after they are reduced.

Notes to Implementers

Your implementation should not reduce the current moniker before performing the comparison. It is the caller's responsibility to call IMoniker::Reduce to compare reduced monikers. Two monikers that compare as equal must hash to the same value using IMoniker::Hash.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Creates a hash value using the internal state of the moniker. A pointer to a variable that receives the hash value. This method returns S_OK to indicate that the hash value was retrieved successfully.

Notes to Callers

You can use the value returned by this method to maintain a hash table of monikers. The hash value determines a hash bucket in the table. To search such a table for a specified moniker, calculate its hash value and then compare it to the monikers in that hash bucket using IMoniker::IsEqual.

Notes to Implementers

The hash value must be constant for the lifetime of the moniker. Two monikers that compare as equal using IMoniker::IsEqual must hash to the same value. Marshaling and then unmarshaling a moniker should have no effect on its hash value. Consequently, your implementation of IMoniker::Hash should rely only on the internal state of the moniker, not on its memory address.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Determines whether the object identified by this moniker is currently loaded and running. A pointer to the IBindCtx interface on the bind context to be used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment. A pointer to the IMoniker interface on the moniker to the left of this moniker if this moniker is part of a composite. This parameter is used primarily by moniker implementers to enable cooperation between the various components of a composite moniker; moniker clients can usually pass NULL. A pointer to the IMoniker interface on the moniker most recently added to the running object table (ROT). This can be NULL. If non-NULL, the implementation can return the results of calling IMoniker::IsEqual on the pmkNewlyRunning parameter, passing the current moniker. This parameter is intended to enable IsRunning implementations that are more efficient than just searching the ROT, but the implementation can choose to ignore pmkNewlyRunning without causing any harm. This method can return the standard return values E_UNEXPECTED, as well as the following values. This doc was truncated.

Notes to Callers

If speed is important when you're requesting services from the object identified by the moniker, you may want those services only if the object is already running (because loading an object into the running state may be time-consuming). In such a situation, you should call IsRunning to determine whether the object is running. For the monikers stored within linked objects, IsRunning is primarily called by the default handler's implementation of IOleLink::BindIfRunning.

Notes to Implementers

To get a pointer to the ROT, your implementation should call IBindCtx::GetRunningObjectTable on the pbc parameter. Your implementation can then call IRunningObjectTable::IsRunning to determine whether the object identified by the moniker is running. The object identified by the moniker must have registered itself with the ROT when it first began running.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Retrieves the time at which the object identified by this moniker was last changed. A pointer to the bind context to be used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment. For more information, see IBindCtx. If the moniker is part of a composite moniker, pointer to the moniker to the left of this moniker. This parameter is primarily used by moniker implementers to enable cooperation between the various components of a composite moniker. Moniker clients should pass NULL. A pointer to the FILETIME structure that receives the time of last change. A value of {0xFFFFFFFF,0x7FFFFFFF} indicates an error (for example, exceeded time limit, information not available). This method can return the standard return values E_OUTOFMEMORY, as well as the following values. This doc was truncated. To be precise, the time returned is the earliest time COM can identify after which no change has occurred, so this time may be later than the time of the last change to the object.

Notes to Callers

If you're caching information returned by the object identified by the moniker, you may want to ensure that your information is up-to-date. To do so, you would call GetTimeOfLastChange and compare the time returned with the time you last retrieved information from the object. For the monikers stored within linked objects, GetTimeOfLastChange is primarily called by the default handler's implementation of IOleObject::IsUpToDate. Container applications call IOleObject::IsUpToDate to determine if a linked object (or an embedded object containing linked objects) is up-to-date without actually binding to the object. This enables an application to determine quickly which linked objects require updating when the end user opens a document. The application can then bind only those linked objects that need updating (after prompting the end user to determine whether they should be updated) instead of binding every linked object in the document.

Notes to Implementers

It is important to perform this operation quickly because, for linked objects, this method is called when a user first opens a compound document. Consequently, your GetTimeOfLastChange implementation should not bind to any objects. In addition, your implementation should check the deadline parameter in the bind context and return MK_E_EXCEEDEDDEADLINE if the operation cannot be completed by the specified time. Following are some strategies you can use in your implementations: This doc was truncated. Read more on docs.microsoft.com. Creates a moniker that is the inverse of this moniker. When composed to the right of this moniker or one of similar structure, the moniker will compose to nothing. The address of an IMoniker pointer variable that receives the interface pointer to a moniker that is the inverse of this moniker. When successful, the implementation must call AddRef on the new inverse moniker. It is the caller's responsibility to call Release. If an error occurs, the implementation should set *ppmk to NULL. This method can return the standard return values E_OUTOFMEMORY, as well as the following values. This doc was truncated. The inverse of a moniker is analogous to the ".." directory in MS-DOS file systems; the ".." directory acts as the inverse to any other directory name, because appending ".." to a directory name results in an empty path. In the same way, the inverse of a moniker typically is also the inverse of all monikers in the same class. However, it is not necessarily the inverse of a moniker of a different class. The inverse of a composite moniker is a composite consisting of the inverses of the components of the original moniker, arranged in reverse order. For example, if the inverse of A is Inv( A ) and the composite of A, B, and C is Comp( A, B, C ), then Inv( Comp( A, B, C ) ) is equal to Comp( Inv( C ), Inv( B ), Inv( A ) ). Not all monikers have inverses. Most monikers that are themselves inverses, such as anti-monikers, do not have inverses. Monikers that have no inverse cannot have relative monikers formed from inside the objects they identify to other objects outside.

Notes to Callers

An object that is using a moniker to locate another object usually does not know the class of the moniker it is using. To get the inverse of a moniker, you should always call IMoniker::Inverse rather than the CreateAntiMoniker function, because you cannot be certain that the moniker you're using considers an anti-moniker to be its inverse. The Inverse method is also called by the implementation of the IMoniker::RelativePathTo method, to assist in constructing a relative moniker.

Notes to Implementers

If your monikers have no internal structure, you can call the CreateAntiMoniker function in to get an anti-moniker in your implementation of IMoniker::Inverse. In your implementation of IMoniker::ComposeWith, you need to check for the inverse you supply in the implementation of Inverse.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Creates a new moniker based on the prefix that this moniker has in common with the specified moniker. A pointer to the IMoniker interface on another moniker to be compared with this one to determine whether there is a common prefix. The address of an IMoniker* pointer variable that receives the interface pointer to the moniker that is the common prefix of this moniker and pmkOther. When successful, the implementation must call AddRef on the resulting moniker; it is the caller's responsibility to call Release. If an error occurs or if there is no common prefix, the implementation should set *ppmkPrefix to NULL. This method can return the standard return values E_OUTOFMEMORY, as well as the following values. This doc was truncated. CommonPrefixWith creates a new moniker that consists of the common prefixes of the moniker on this moniker object and another moniker. For example, if one moniker represents the path "c:\projects\secret\art\pict1.bmp" and another moniker represents the path "c:\projects\secret\docs\chap1.txt", the common prefix of these two monikers would be a moniker representing the path "c:\projects\secret".

Notes to Callers

The CommonPrefixWith method is primarily called in the implementation of the IMoniker::RelativePathTo method. Clients using a moniker to locate an object rarely need to call this method. Call this method only if pmkOther and this moniker are both absolute monikers. An absolute moniker is either a file moniker or a generic composite whose leftmost component is a file moniker that represents an absolute path. Do not call this method on relative monikers because it would not produce meaningful results.

Notes to Implementers

Your implementation should first determine whether pmkOther is a moniker of a class that you recognize and for which you can provide special handling (for example, if it is of the same class as this moniker). If so, your implementation should determine the common prefix of the two monikers. Otherwise, it should pass both monikers in a call to the MonikerCommonPrefixWith function, which correctly handles the generic case.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Creates a relative moniker between this moniker and the specified moniker. A pointer to the IMoniker interface on the moniker to which a relative path should be taken. A pointer to an IMoniker pointer variable that receives the interface pointer to the relative moniker. When successful, the implementation must call AddRef on the new moniker; it is the caller's responsibility to call Release. If an error occurs, the implementation sets *ppmkRelPath to NULL. This method can return the standard return values E_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. This doc was truncated. A relative moniker is analogous to a relative path (such as "..\backup"). For example, suppose you have one moniker that represents the path "c:\projects\secret\art\pict1.bmp" and another moniker that represents the path "c:\projects\secret\docs\chap1.txt". Calling RelativePathTo on the first moniker, passing the second one as the pmkOther parameter, would create a relative moniker representing the path "..\docs\chap1.txt".

Notes to Callers

Moniker clients typically do not need to call RelativePathTo. This method is called primarily by the default handler for linked objects. Linked objects contain both an absolute and a relative moniker to identify the link source. (This enables link tracking if the user moves a directory tree containing both the container and source files.) The default handler calls this method to create a relative moniker from the container document to the link source. (That is, it calls RelativePathTo on the moniker identifying the container document, passing the moniker identifying the link source as the pmkOther parameter.) If you do call RelativePathTo, call it only on absolute monikers, for example, a file moniker or a composite moniker whose leftmost component is a file moniker, where the file moniker represents an absolute path. Do not call this method on relative monikers.

Notes to Implementers

Your implementation of RelativePathTo should first determine whether pmkOther is a moniker of a class that you recognize and for which you can provide special handling (for example, if it is of the same class as this moniker). If so, your implementation should determine the relative path. Otherwise, it should pass both monikers in a call to the MonikerRelativePathTo function, which correctly handles the generic case. The first step in determining a relative path is determining the common prefix of this moniker and pmkOther. The next step is to break this moniker and pmkOther into two parts each, say (P, myTail) and (P, otherTail) respectively, where P is the common prefix. The correct relative path is then the inverse of myTail composed with otherTail: Comp( Inv( myTail ), otherTail ) where Comp() represents the composition operation and Inv() represents the inverse operation. For certain types of monikers, you cannot use your IMoniker::Inverse method to construct the inverse of myTail. For example, a file moniker returns an anti-moniker as an inverse, while its RelativePathTo method must use one or more file monikers that each represent the path ".." to construct the inverse of myTail.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Retrieves the display name for the moniker. A pointer to the IBindCtx interface on the bind context to be used in this operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment. If the moniker is part of a composite moniker, pointer to the moniker to the left of this moniker. This parameter is used primarily by moniker implementers to enable cooperation between the various components of a composite moniker. Moniker clients should pass NULL. The address of a pointer variable that receives a pointer to the display name string for the moniker. The implementation must use IMalloc::Alloc to allocate the string returned in ppszDisplayName, and the caller is responsible for calling IMalloc::Free to free it. Both the caller and the implementation of this method use the COM task allocator returned by CoGetMalloc. If an error occurs, the implementation must set *ppszDisplayName should be set to NULL. This method can return the standard return values E_OUTOFMEMORY, as well as the following values. This doc was truncated. GetDisplayName provides a string that is a displayable representation of the moniker. A display name is not a complete representation of a moniker's internal state; it is simply a form that can be read by users. As a result, it is possible (though rare) for two different monikers to have the same display name. While there is no guarantee that the display name of a moniker can be parsed back into that moniker when calling the MkParseDisplayName function with it, failure to do so is rare.

Notes to Callers

It is possible that retrieving a moniker's display name may be an expensive operation. For efficiency, you may want to cache the results of the first successful call to GetDisplayName, rather than making repeated calls.

Notes to Implementers

If you are writing a moniker class in which the display name does not change, simply cache the display name and supply the cached name when requested. If the display name can change over time, getting the current display name might mean that the moniker has to access the object's storage or bind to the object, either of which can be expensive operations. If this is the case, your implementation of GetDisplayName should return MK_E_EXCEEDEDDEADLINE if the name cannot be retrieved by the time specified in the bind context's BIND_OPTS structure. A moniker that is intended to be part of a generic composite moniker should include any preceding delimiter (such as '\') as part of its display name. For example, the display name returned by an item moniker includes the delimiter specified when it was created with the CreateItemMoniker function. The display name for a file moniker does not include a delimiter because file monikers are always expected to be the leftmost component of a composite.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. Converts a display name into a moniker. A pointer to the IBindCtx interface on the bind context to be used in this binding operation. The bind context caches objects bound during the binding process, contains parameters that apply to all operations using the bind context, and provides the means by which the moniker implementation should retrieve information about its environment. A pointer to the IMoniker interface on the moniker that has been built out of the display name up to this point. The remaining display name to be parsed. A pointer to a variable that receives the number of characters in pszDisplayName that were consumed in this step. A pointer to an IMoniker pointer variable that receives the interface pointer to the moniker that was built from pszDisplayName. When successful, the implementation must call AddRef on the new moniker; it is the caller's responsibility to call Release. If an error occurs, the implementation sets *ppmkOut to NULL. This method can return the standard return valuesE_OUTOFMEMORY and E_UNEXPECTED, as well as the following values. This doc was truncated.

Notes to Callers

Moniker clients do not typically call ParseDisplayName directly. Instead, they call the MkParseDisplayName function when they want to convert a display name into a moniker (for example, in implementing the Links dialog box for a container application, or for implementing a macro language that supports references to objects outside the document). That function first parses the initial portion of the display name itself. It then calls ParseDisplayName on the moniker it has just created, passing the remainder of the display name and getting a new moniker in return; this step is repeated until the entire display name has been parsed.

Notes to Implementers

Your implementation may be able to perform this parsing by itself if your moniker class is designed to designate only certain kinds of objects. Otherwise, you must get an IParseDisplayName interface pointer for the object identified by the moniker-so-far (that is, the composition of pmkToLeft and this moniker) and then return the results of calling IParseDisplayName::ParseDisplayName. There are different strategies for getting an IParseDisplayName pointer, as follows: This doc was truncated. Read more on docs.microsoft.com. Determines whether this moniker is one of the system-provided moniker classes. A pointer to a variables that receives one of the values from the MKSYS enumeration and refers to one of the COM moniker classes. This parameter cannot be NULL. This method returns S_OK to indicate that the moniker is a system moniker, and S_FALSE otherwise.

Notes to Callers

New values of the MKSYS enumeration may be defined in the future; therefore, you should explicitly test for each value you are interested in.

Notes to Implementers

Your implementation of this method must return MKSYS_NONE. You cannot use this function to identify your own monikers (for example, in your implementation of IMoniker::ComposeWith). Instead, you should use your moniker's implementation of IPersist::GetClassID or use QueryInterface to test for your own private interface.

Implementation-specific Notes

 This doc was truncated. Read more on docs.microsoft.com. The IID guid for this interface. {0000000f-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. Retrieves the class identifier (CLSID) of the object. A pointer to the location that receives the CLSID on return. The CLSID is a globally unique identifier (GUID) that uniquely represents an object class that defines the code that can manipulate the object's data. If the method succeeds, the return value is S_OK. Otherwise, it is E_FAIL. The GetClassID method retrieves the class identifier (CLSID) for an object, used in later operations to load object-specific code into the caller's context.

Notes to Callers

A container application might call this method to retrieve the original CLSID of an object that it is treating as a different class. Such a call would be necessary if a user performed an editing operation that required the object to be saved. If the container were to save it using the treat-as CLSID, the original application would no longer be able to edit the object. Typically, in this case, the container calls the OleSave helper function, which performs all the necessary steps. For this reason, most container applications have no need to call this method directly. The exception would be a container that provides an object handler for certain objects. In particular, a container application should not get an object's CLSID and then use it to retrieve class specific information from the registry. Instead, the container should use IOleObject and IDataObject interfaces to retrieve such class-specific information directly from the object.

Notes to Implementers

Typically, implementations of this method simply supply a constant CLSID for an object. If, however, the object's TreatAs registry key has been set by an application that supports emulation (and so is treating the object as one of a different class), a call to GetClassID must supply the CLSID specified in the TreatAs key. For more information on emulation, see CoTreatAsClass. When an object is in the running state, the default handler calls an implementation of GetClassID that delegates the call to the implementation in the object. When the object is not running, the default handler instead calls the ReadClassStg function to read the CLSID that is saved in the object's storage. If you are writing a custom object handler for your object, you might want to simply delegate this method to the default handler implementation (see OleCreateDefaultHandler).

URL Moniker Notes

This method returns CLSID_StdURLMoniker. Read more on docs.microsoft.com. The IID guid for this interface. {0000010c-0000-0000-c000-000000000046} Determines whether an object has changed since it was last saved to its stream. (IPersistStream.IsDirty) This method returns S_OK to indicate that the object has changed. Otherwise, it returns S_FALSE. Use this method to determine whether an object should be saved before closing it. The dirty flag for an object is conditionally cleared in the IPersistStream::Save method.

Notes to Callers

You should treat any error return codes as an indication that the object has changed. Unless this method explicitly returns S_FALSE, assume that the object must be saved. Note that the OLE-provided implementations of the IPersistStream::IsDirty method in the OLE-provided moniker interfaces always return S_FALSE because their internal state never changes. Read more on docs.microsoft.com. Initializes an object from the stream where it was saved previously. (IPersistStream.Load) An IStream pointer to the stream from which the object should be loaded. This method can return the following values. This doc was truncated. This method loads an object from its associated stream. The seek pointer is set as it was in the most recent IPersistStream::Save method. This method can seek and read from the stream, but cannot write to it.

Notes to Callers

Rather than calling IPersistStream::Load directly, you typically call the OleLoadFromStream function does the following: This doc was truncated. Read more on docs.microsoft.com. Saves an object to the specified stream. (IPersistStream.Save) An IStream pointer to the stream into which the object should be saved. Indicates whether to clear the dirty flag after the save is complete. If TRUE, the flag should be cleared. If FALSE, the flag should be left unchanged. This method can return the following values. This doc was truncated. IPersistStream::Save saves an object into the specified stream and indicates whether the object should reset its dirty flag. The seek pointer is positioned at the location in the stream at which the object should begin writing its data. The object calls the ISequentialStream::Write method to write its data. On exit, the seek pointer must be positioned immediately past the object data. The position of the seek pointer is undefined if an error returns.

Notes to Callers

Rather than calling IPersistStream::Save directly, you typically call the OleSaveToStream helper function which does the following: This doc was truncated. Read more on docs.microsoft.com. Retrieves the size of the stream needed to save the object. (IPersistStream.GetSizeMax) The size in bytes of the stream needed to save this object, in bytes. This method returns S_OK to indicate that the size was retrieved successfully. This method returns the size needed to save an object. You can call this method to determine the size and set the necessary buffers before calling the IPersistStream::Save method.

Notes to Implementers

The GetSizeMax implementation should return a conservative estimate of the necessary size because the caller might call the IPersistStream::Save method with a non-growable stream.

URL Moniker Notes

This method retrieves the maximum number of bytes in the stream that will be required by a subsequent call to IPersistStream::Save. This value is sizeof(ULONG)==4 plus sizeof(WCHAR)*n where n is the length of the full or partial URL string, including the NULL terminator. Read more on docs.microsoft.com. The IID guid for this interface. {00000109-0000-0000-c000-000000000046} Registers an object and its identifying moniker in the running object table (ROT). Specifies whether the ROT's reference to punkObject is weak or strong and controls access to the object through its entry in the ROT. For details, see the Remarks section. This doc was truncated. Read more on docs.microsoft.com. A pointer to the object that is being registered as running. A pointer to the moniker that identifies punkObject. An identifier for this ROT entry that can be used in subsequent calls to IRunningObjectTable::Revoke or IRunningObjectTable::NoteChangeTime. The caller cannot specify NULL for this parameter. If an error occurs, *pdwRegister is set to zero. This method can return the standard return values E_INVALIDARG and E_OUTOFMEMORY, as well as the following values. This doc was truncated. This method registers a pointer to an object under a moniker that identifies the object. The moniker is used as the key when the table is searched with IRunningObjectTable::GetObject. When an object is registered, the ROT always calls AddRef on the object. For a weak registration (ROTFLAGS_REGISTRATIONKEEPSALIVE not set), the ROT will release the object whenever the last strong reference to the object is released. For a strong registration (ROTFLAGS_REGISTRATIONKEEPSALIVE set), the ROT prevents the object from being destroyed until the object's registration is explicitly revoked. A server registered as either LocalService or RunAs can set the ROTFLAGS_ALLOWANYCLIENT flag in its call to Register to allow any client to connect to it. A server setting this bit must have its executable name in the AppID section of the registry that refers to the AppID for the executable. An "activate as activator" server (not registered as LocalService or RunAs) must not set this flag in its call to Register. For details on installing services, see Installing as a Service Application. Registering a second object with the same moniker, or re-registering the same object with the same moniker, creates a second entry in the ROT. In this case, Register returns MK_S_MONIKERALREADYREGISTERED. Each call to Register must be matched by a call to IRunningObjectTable::Revoke because even duplicate entries have different pdwRegister identifiers. A problem with duplicate registrations is that there is no way to determine which object will be returned if the moniker is specified in a subsequent call to IRunningObjectTable::IsRunning.

Notes to Callers

If you are a moniker provider (that is, you hand out monikers identifying your objects to make them accessible to others), you must call the Register method to register your objects when they begin running. You must also call this method if you rename your objects while they are loaded. The most common type of moniker provider is a compound-document link source. This includes server applications that support linking to their documents (or portions of a document) and container applications that support linking to embeddings within their documents. Server applications that do not support linking can also use the ROT to cooperate with container applications that support linking to embeddings. If you are writing a server application, you should register an object with the ROT when it begins running, typically in your implementation of IOleObject::DoVerb. The object must be registered under its full moniker, which requires getting the moniker of its container document using IOleClientSite::GetMoniker. You should also revoke and re-register the object in your implementation of IOleObject::SetMoniker, which is called if the container document is renamed. If you are writing a container application that supports linking to embeddings, you should register your document with the ROT when it is loaded. If your document is renamed, you should revoke and re-register it with the ROT and call IOleObject::SetMoniker for any embedded objects in the document to give them an opportunity to re-register themselves. Objects registered in the ROT must be explicitly revoked when the object is no longer running or when its moniker changes. This revocation is important because there is no way for the system to automatically remove entries from the ROT. You must cache the identifier that is written through pdwRegister and use it in a call to IRunningObjectTable::Revoke to revoke the registration. For a strong registration, a strong reference is released when the objects registration is revoked. As of Windows Server 2003, if there are stale entries that remain in the ROT due to unexpected server problems, COM will automatically remove these stale entries from the ROT. The system's implementation of Register calls IMoniker::Reduce on the pmkObjectName parameter to ensure that the moniker is fully reduced before registration. If an object is known by more than one fully reduced moniker, it should be registered under all such monikers. Read more on docs.microsoft.com. Removes an entry from the running object table (ROT) that was previously registered by a call to IRunningObjectTable::Register. The identifier of the ROT entry to be revoked. This method can return the standard return values E_INVALIDARG and S_OK. This method undoes the effect of a call to IRunningObjectTable::Register, removing both the moniker and the pointer to the object identified by that moniker.

Notes to Callers

A moniker provider (hands out monikers identifying its objects to make them accessible to others) must call the Revoke method to revoke the registration of its objects when it stops running. It must have previously called IRunningObjectTable::Register and stored the identifier returned by that method; it uses that identifier when calling Revoke. The most common type of moniker provider is a compound-document link source. This includes server applications that support linking to their documents (or portions of a document) and container applications that support linking to embeddings within their documents. Server applications that do not support linking can also use the ROT to cooperate with container applications that support linking to embeddings. If you are writing a container application, you must revoke a document's registration when the document is closed. You must also revoke a document's registration before re-registering it when it is renamed. If you are writing a server application, you must revoke an object's registration when the object is closed. You must also revoke an object's registration before re-registering it when its container document is renamed (see IOleObject::SetMoniker). Read more on docs.microsoft.com. Determines whether the object identified by the specified moniker is currently running. A pointer to the IMoniker interface on the moniker. If the object is in the running state, the return value is TRUE. Otherwise, it is FALSE. This method simply indicates whether a object is running. To retrieve a pointer to a running object, use the IRunningObjectTable::GetObject method.

Notes to Callers

Generally, you call the IsRunning method only if you are writing your own moniker class (that is, implementing the IMoniker interface). You typically call this method from your implementation of IMoniker::IsRunning. However, you should do so only if the pmkToLeft parameter of IMoniker::IsRunning is NULL. Otherwise, you should call IMoniker::IsRunning on your pmkToLeft parameter instead. Read more on docs.microsoft.com. Determines whether the object identified by the specified moniker is running, and if it is, retrieves a pointer to that object. A pointer to the IMoniker interface on the moniker. A pointer to an IUnknown pointer variable that receives the interface pointer to the running object. When successful, the implementation calls AddRef on the object; it is the caller's responsibility to call Release. If the object is not running or if an error occurs, the implementation sets *ppunkObject to NULL. This method can return the following values. This doc was truncated. This method checks the ROT for the moniker specified by pmkObjectName. If that moniker had previously been registered with a call to IRunningObjectTable::Register, this method returns the pointer that was registered at that time.

Notes to Callers

Generally, you call the IRunningObjectTable::GetObject method only if you are writing your own moniker class (that is, implementing the IMoniker interface). You typically call this method from your implementation of IMoniker::BindToObject. However, note that not all implementations of IMoniker::BindToObject need to call this method. If you expect your moniker to have a prefix (indicated by a non-NULLpmkToLeft parameter to IMoniker::BindToObject), you should not check the ROT. The reason for this is that only complete monikers are registered with the ROT, and if your moniker has a prefix, your moniker is part of a composite and thus not complete. Instead, your moniker should request services from the object identified by the prefix (for example, the container of the object identified by your moniker). Read more on docs.microsoft.com. Records the time that a running object was last modified. The object must have previously been registered with the running object table (ROT). This method stores the time of last change in the ROT. The identifier of the ROT entry of the changed object. This value was previously returned by IRunningObjectTable::Register. A pointer to a FILETIME structure containing the object's last change time. This method can return the standard return values E_INVALIDARG and S_OK. The time recorded by this method can be retrieved by calling IRunningObjectTable::GetTimeOfLastChange.

Notes to Callers

A moniker provider (hands out monikers identifying its objects to make them accessible to others) must call the NoteChangeTime method whenever its objects are modified. It must have previously called IRunningObjectTable::Register and stored the identifier returned by that method; it uses that identifier when calling NoteChangeTime. The most common type of moniker provider is a compound-document link source. This includes server applications that support linking to their documents (or portions of a document) and container applications that support linking to embeddings within their documents. Server applications that do not support linking can also use the ROT to cooperate with container applications that support linking to embeddings. When an object is first registered in the ROT, the ROT records its last change time as the value returned by calling IMoniker::GetTimeOfLastChange on the moniker being registered. Read more on docs.microsoft.com. Retrieves the time that an object was last modified. A pointer to the IMoniker interface on the moniker. A pointer to a FILETIME structure that receives the object's last change time. This method can return the following values. This doc was truncated. This method returns the change time that was last reported for this object by a call to IRunningObjectTable::NoteChangeTime. If NoteChangeTime has not been called previously, the method returns the time that was recorded when the object was registered. This method is provided to enable checking whether a connection between two objects (represented by one object holding a moniker that identifies the other) is up-to-date. For example, if one object is holding cached information about the other object, this method can be used to check whether the object has been modified since the cache was last updated. See IMoniker::GetTimeOfLastChange.

Notes to Callers

Generally, you call GetTimeOfLastChange only if you are writing your own moniker class (that is, implementing the IMoniker interface). You typically call this method from your implementation of IMoniker::GetTimeOfLastChange. However, you should do so only if the pmkToLeft parameter of IMoniker::GetTimeOfLastChange is NULL. Otherwise, you should call IMoniker::GetTimeOfLastChange on your pmkToLeft parameter instead. Read more on docs.microsoft.com. Creates and returns a pointer to an enumerator that can list the monikers of all the objects currently registered in the running object table (ROT). A pointer to an IEnumMoniker pointer variable that receives the interface pointer to the new enumerator for the ROT. When successful, the implementation calls AddRef on the enumerator; it is the caller's responsibility to call Release. If an error occurs; the implementation sets *ppenumMoniker to NULL. This method can return the standard return values E_OUTOFMEMORY and S_OK. IRunningObjectTable::EnumRunning must create and return a pointer to an IEnumMoniker interface on an enumerator object. The standard enumerator methods can then be called to enumerate the monikers currently registered in the registry. The enumerator cannot be used to enumerate monikers that are registered in the ROT after the enumerator has been created. The EnumRunning method is intended primarily for the use by the system in implementing the alert object table. Note that OLE 2 does not include an implementation of the alert object table. Read more on docs.microsoft.com. The IID guid for this interface. {00000010-0000-0000-c000-000000000046} Reads a specified number of bytes from the stream object into memory, starting at the current seek pointer. A pointer to the buffer which the stream data is read into. The number of bytes of data to read from the stream object. A pointer to a ULONG variable that receives the actual number of bytes read from the stream object.
Note  The number of bytes read may be zero.
 
 Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | All of the requested data was successfully read from the stream object; the number of bytes requested in *cb* is the same as the number of bytes returned in *pcbRead*.| |S_FALSE | The value returned in *pcbRead* is less than the number of bytes requested in *cb*. This indicates the end of the stream has been reached. The number of bytes read indicates how much of the *pv* buffer has been filled.| |E_PENDING | Asynchronous storage only: Part or all of the data to be read is currently unavailable. | |STG_E_ACCESSDENIED | The caller does not have permissions required to read this stream object.| |STG_E_INVALIDPOINTER | One of the pointer values is invalid.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| This method reads bytes from this stream object into memory. The stream object must be opened in STGM_READ mode. This method adjusts the seek pointer by the actual number of bytes read. The number of bytes actually read is also returned in the pcbRead parameter.

Notes to Callers

The actual number of bytes read can be less than the number of bytes requested if an error occurs or if the end of the stream is reached during the read operation. The number of bytes returned should always be compared to the number of bytes requested. If the number of bytes returned is less than the number of bytes requested, it usually means the Read method attempted to read past the end of the stream. The application should handle both a returned error and S_OK return values on end-of-stream read operations. Read more on docs.microsoft.com. Writes a specified number of bytes into the stream object starting at the current seek pointer. A pointer to the buffer that contains the data that is to be written to the stream. A valid pointer must be provided for this parameter even when cb is zero. The number of bytes of data to attempt to write into the stream. This value can be zero. A pointer to a ULONG variable where this method writes the actual number of bytes written to the stream object. The caller can set this pointer to NULL, in which case this method does not provide the actual number of bytes written. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The data was successfully written to the stream object.| |E_PENDING | Asynchronous Storage only: Part or all of the data to be written is currently unavailable.| |STG_E_MEDIUMFULL | The write operation failed because there is no space left on the storage device.| |STG_E_ACCESSDENIED | The caller does not have the required permissions for writing to this stream object.| |STG_E_CANTSAVE | Data cannot be written for reasons other than improper access or insufficient space.| |STG_E_INVALIDPOINTER | One of the pointer values is not valid. The *pv* parameter must contain a valid pointer even if *cb* is zero.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| |STG_E_WRITEFAULT | The write operation failed due to a disk error. This value is also returned when this method attempts to write to a stream that was opened in simple mode (using the STGM_SIMPLE flag).| ISequentialStream::Write writes the specified data to a stream object. The seek pointer is adjusted for the number of bytes actually written. The number of bytes actually written is returned in the pcbWritten parameter. If the byte count is zero bytes, the write operation has no effect. If the seek pointer is currently past the end of the stream and the byte count is nonzero, this method increases the size of the stream to the seek pointer and writes the specified bytes starting at the seek pointer. The fill bytes written to the stream are not initialized to any particular value. This is the same as the end-of-file behavior in the MS-DOS FAT file system. With a zero byte count and a seek pointer past the end of the stream, this method does not create the fill bytes to increase the stream to the seek pointer. In this case, you must call the IStream::SetSize method to increase the size of the stream and write the fill bytes. The pcbWritten parameter can have a value even if an error occurs. In the COM-provided implementation, stream objects are not sparse. Any fill bytes are eventually allocated on the disk and assigned to the stream. Read more on docs.microsoft.com. The IID guid for this interface. {0c733a30-2a1c-11ce-ade5-00aa0044773d} Changes the seek pointer to a new location. The new location is relative to either the beginning of the stream, the end of the stream, or the current seek pointer. The displacement to be added to the location indicated by the dwOrigin parameter. If dwOrigin is STREAM_SEEK_SET, this is interpreted as an unsigned value rather than a signed value. The origin for the displacement specified in dlibMove. The origin can be the beginning of the file (STREAM_SEEK_SET), the current seek pointer (STREAM_SEEK_CUR), or the end of the file (STREAM_SEEK_END). For more information about values, see the STREAM_SEEK enumeration. A pointer to the location where this method writes the value of the new seek pointer from the beginning of the stream. You can set this pointer to NULL. In this case, this method does not provide the new seek pointer. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The seek pointer was successfully adjusted.| |E_PENDING | Asynchronous Storage only: Part or all of the stream data is currently unavailable. | |STG_E_INVALIDPOINTER | Indicates that *plibNewPosition* points to invalid memory, because *plibNewPosition* is not read.| |STG_E_INVALIDFUNCTION | The *dwOrigin* parameter contains an invalid value, or the *dlibMove* parameter contains a bad offset value. For example, the result of the seek pointer is a negative offset value.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| IStream::Seek changes the seek pointer so that subsequent read and write operations can be performed at a different location in the stream object. It is an error to seek before the beginning of the stream. It is not, however, an error to seek past the end of the stream. Seeking past the end of the stream is useful for subsequent write operations, as the stream byte range will be extended to the new seek position immediately before the write is complete. You can also use this method to obtain the current value of the seek pointer by calling this method with the dwOrigin parameter set to STREAM_SEEK_CUR and the dlibMove parameter set to 0 so that the seek pointer is not changed. The current seek pointer is returned in the plibNewPosition parameter. Read more on docs.microsoft.com. Changes the size of the stream object. Specifies the new size, in bytes, of the stream. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The size of the stream object was successfully changed.| |E_PENDING | Asynchronous Storage only: Part or all of the stream's data is currently unavailable.| |STG_E_MEDIUMFULL | The stream size is not changed because there is no space left on the storage device.| |STG_E_INVALIDFUNCTION | The value of the *libNewSize* parameter is not supported by the implementation. Not all streams support greater than 232 bytes. If a stream does not support more than 232 bytes, the high DWORD data type of *libNewSize* must be zero. If it is nonzero, the implementation may return STG_E_INVALIDFUNCTION. In general, COM-based implementations of the IStream interface do not support streams larger than 232 bytes.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| IStream::SetSize changes the size of the stream object. Call this method to preallocate space for the stream. If the libNewSize parameter is larger than the current stream size, the stream is extended to the indicated size by filling the intervening space with bytes of undefined value. This operation is similar to the ISequentialStream::Write method if the seek pointer is past the current end of the stream. If the libNewSize parameter is smaller than the current stream, the stream is truncated to the indicated size. The seek pointer is not affected by the change in stream size. Calling IStream::SetSize can be an effective way to obtain a large chunk of contiguous space. Read more on docs.microsoft.com. Copies a specified number of bytes from the current seek pointer in the stream to the current seek pointer in another stream. A pointer to the destination stream. The stream pointed to by pstm can be a new stream or a clone of the source stream. The number of bytes to copy from the source stream. A pointer to the location where this method writes the actual number of bytes read from the source. You can set this pointer to NULL. In this case, this method does not provide the actual number of bytes read. A pointer to the location where this method writes the actual number of bytes written to the destination. You can set this pointer to NULL. In this case, this method does not provide the actual number of bytes written. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The stream object was successfully copied.| |E_PENDING | Asynchronous Storage only: Part or all of the data to be copied is currently unavailable. | |STG_E_INVALIDPOINTER | The value of one of the pointer parameters is invalid.| |STG_E_MEDIUMFULL | The stream is not copied because there is no space left on the storage device.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| The CopyTo method copies the specified bytes from one stream to another. It can also be used to copy a stream to itself. The seek pointer in each stream instance is adjusted for the number of bytes read or written. This method is equivalent to reading cb bytes into memory using ISequentialStream::Read and then immediately writing them to the destination stream using ISequentialStream::Write, although IStream::CopyTo will be more efficient. The destination stream can be a clone of the source stream created by calling the IStream::Clone method. If IStream::CopyTo returns an error, you cannot assume that the seek pointers are valid for either the source or destination. Additionally, the values of pcbRead and pcbWritten are not meaningful even though they are returned. If IStream::CopyTo returns successfully, the actual number of bytes read and written are the same. To copy the remainder of the source from the current seek pointer, specify the maximum large integer value for the cb parameter. If the seek pointer is the beginning of the stream, this operation copies the entire stream. Read more on docs.microsoft.com. The Commit method ensures that any changes made to a stream object open in transacted mode are reflected in the parent storage. Controls how the changes for the stream object are committed. See the STGC enumeration for a definition of these values. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | Changes to the stream object were successfully committed to the parent level.| |E_PENDING | Asynchronous Storage only: Part or all of the stream's data is currently unavailable. | |STG_E_MEDIUMFULL | The commit operation failed due to lack of space on the storage device.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| The Commit method ensures that changes to a stream object opened in transacted mode are reflected in the parent storage. Changes that have been made to the stream since it was opened or last committed are reflected to the parent storage object. If the parent is opened in transacted mode, the parent may revert at a later time, rolling back the changes to this stream object. The compound file implementation does not support the opening of streams in transacted mode, so this method has very little effect other than to flush memory buffers. For more information, see IStream - Compound File Implementation. If the stream is open in direct mode, this method ensures that any memory buffers have been flushed out to the underlying storage object. This is much like a flush in traditional file systems. The IStream::Commit method is useful on a direct mode stream when the implementation of the IStream interface is a wrapper for underlying file system APIs. In this case, IStream::Commit would be connected to the file system's flush call. Read more on docs.microsoft.com. The Revert method discards all changes that have been made to a transacted stream since the last IStream::Commit call. On streams open in direct mode and streams using the COM compound file implementation of IStream::Revert, this method has no effect. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The stream was successfully reverted to its previous version.| |E_PENDING | Asynchronous Storage only: Part or all of the stream's data is currently unavailable. | The Revert method discards changes made to a transacted stream since the last commit operation. The LockRegion method restricts access to a specified range of bytes in the stream. Integer that specifies the byte offset for the beginning of the range. Integer that specifies the length of the range, in bytes, to be restricted. Specifies the restrictions being requested on accessing the range. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The specified range of bytes was locked.| |E_PENDING | Asynchronous Storage only: Part or all of the stream's data is currently unavailable. | |STG_E_INVALIDFUNCTION | Locking is not supported at all or the specific type of lock requested is not supported.| |STG_E_LOCKVIOLATION | Requested lock is supported, but cannot be granted because of an existing lock.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| The byte range of the stream can be extended. Locking an extended range for the stream is useful as a method of communication between different instances of the stream without changing data that is actually part of the stream. Three types of locking can be supported: locking to exclude other writers, locking to exclude other readers or writers, and locking that allows only one requester to obtain a lock on the given range, which is usually an alias for one of the other two lock types. A given stream instance might support either of the first two types, or both. The lock type is specified by dwLockType, using a value from the LOCKTYPE enumeration. Any region locked with IStream::LockRegion must later be explicitly unlocked by calling IStream::UnlockRegion with exactly the same values for the libOffset, cb, and dwLockType parameters. The region must be unlocked before the stream is released. Two adjacent regions cannot be locked separately and then unlocked with a single unlock call.

Notes to Callers

Since the type of locking supported is optional and can vary in different implementations of IStream, you must provide code to deal with the STG_E_INVALIDFUNCTION error. The LockRegion method has no effect in the compound file implementation, because the implementation does not support range locking.

Notes to Implementers

Support for this method is optional for implementations of stream objects since it may not be supported by the underlying file system. The type of locking supported is also optional. The STG_E_INVALIDFUNCTION error is returned if the requested type of locking is not supported. Read more on docs.microsoft.com. The UnlockRegion method removes the access restriction on a range of bytes previously restricted with IStream::LockRegion. Specifies the byte offset for the beginning of the range. Specifies, in bytes, the length of the range to be restricted. Specifies the access restrictions previously placed on the range. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The byte range was unlocked.| |E_PENDING | Asynchronous Storage only: Part or all of the stream's data is currently unavailable.| |STG_E_INVALIDFUNCTION | Locking is not supported at all or the specific type of lock requested is not supported.| |STG_E_LOCKVIOLATION | The requested unlock operation cannot be granted.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| IStream::UnlockRegion unlocks a region previously locked with the IStream::LockRegion method. Locked regions must later be explicitly unlocked by calling IStream::UnlockRegion with exactly the same values for the libOffset, cb, and dwLockType parameters. The region must be unlocked before the stream is released. Two adjacent regions cannot be locked separately and then unlocked with a single unlock call. Read more on docs.microsoft.com. The Stat method retrieves the STATSTG structure for this stream. Pointer to a STATSTG structure where this method places information about this stream object. Read more on docs.microsoft.com. Specifies that this method does not return some of the members in the STATSTG structure, thus saving a memory allocation operation. Values are taken from the STATFLAG enumeration. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The STATSTG structure was successfully returned at the specified location.| |E_PENDING | Asynchronous Storage only: Part or all of the stream's data is currently unavailable. | |STG_E_ACCESSDENIED | The caller does not have enough permissions for accessing statistics for this storage object.| |STG_E_INSUFFICIENTMEMORY | The STATSTG structure was not returned due to a lack of memory.| |STG_E_INVALIDFLAG | The value for the *grfStateFlag* parameter is not valid.| |STG_E_INVALIDPOINTER | The *pStatStg* pointer is not valid.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| IStream::Stat retrieves a pointer to the STATSTG structure that contains information about this open stream. When this stream is within a structured storage and IStorage::EnumElements is called, it creates an enumerator object with the IEnumSTATSTG interface on it, which can be called to enumerate the storages and streams through the STATSTG structures associated with each of them. Read more on docs.microsoft.com. The Clone method creates a new stream object with its own seek pointer that references the same bytes as the original stream. When successful, pointer to the location of an IStream pointer to the new stream object. If an error occurs, this parameter is NULL. Read more on docs.microsoft.com. This method can return one of these values. | Return code | Description | |----------------|---------------| |S_OK | The stream was successfully cloned.| |E_PENDING | Asynchronous Storage only: Part or all of the stream's data is currently unavailable. | |STG_E_INSUFFICIENTMEMORY | The stream was not cloned due to a lack of memory.| |STG_E_INVALIDPOINTER | The ppStm pointer is not valid.| |STG_E_REVERTED | The object has been invalidated by a revert operation above it in the transaction tree.| The Clone method creates a new stream object for accessing the same bytes but using a separate seek pointer. The new stream object sees the same data as the source-stream object. Changes written to one object are immediately visible in the other. Range locking is shared between the stream objects. The initial setting of the seek pointer in the cloned stream instance is the same as the current setting of the seek pointer in the original stream at the time of the clone operation. Read more on docs.microsoft.com. The IID guid for this interface. {0000000c-0000-0000-c000-000000000046} 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} The LOCKTYPE enumeration values indicate the type of locking requested for the specified range of bytes. The values are used in the ILockBytes::LockRegion and IStream::LockRegion methods. Learn more about this API from docs.microsoft.com. If this lock is granted, the specified range of bytes can be opened and read any number of times, but writing to the locked range is prohibited except for the owner that was granted this lock. If this lock is granted, writing to the specified range of bytes is prohibited except by the owner that was granted this lock. If this lock is granted, no other LOCK_ONLYONCE lock can be obtained on the range. Usually this lock type is an alias for some other lock type. Thus, specific implementations can have additional behavior associated with this lock type. 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. Contains information used to specify each advisory connection. Learn more about this API from docs.microsoft.com. The FORMATETC structure for the data of interest to the advise sink. The advise sink receives notification of changes to the data specified by this FORMATETC structure. The ADVF enumeration value that determines when the advisory sink is notified of changes in the data. The pointer for the IAdviseSink interface that will receive change notifications. The token that uniquely identifies the advisory connection. This token is returned by the method that sets up the advisory connection. Contains statistical data about an open storage, stream, or byte-array object. Learn more about this API from docs.microsoft.com. A pointer to a NULL-terminated Unicode string that contains the name. Space for this string is allocated by the method called and freed by the caller (for more information, see CoTaskMemFree). To not return this member, specify the STATFLAG_NONAME value when you call a method that returns a STATSTG structure, except for calls to IEnumSTATSTG::Next, which provides no way to specify this value. Read more on docs.microsoft.com. Indicates the type of storage object. This is one of the values from the STGTY enumeration. Read more on docs.microsoft.com. Specifies the size, in bytes, of the stream or byte array. Indicates the last modification time for this storage, stream, or byte array. Indicates the creation time for this storage, stream, or byte array. Indicates the last access time for this storage, stream, or byte array. Indicates the access mode specified when the object was opened. This member is only valid in calls to Stat methods. Read more on docs.microsoft.com. Indicates the class identifier for the storage object; set to CLSID_NULL for new storage objects. This member is not used for streams or byte arrays. Indicates the current state bits of the storage object; that is, the value most recently set by the IStorage::SetStateBits method. This member is not valid for streams or byte arrays. Read more on docs.microsoft.com. Reserved for future use. Flags that indicate conditions for creating and deleting the object and access modes for the object. You can combine these flags, but you can only choose one flag from each group of related flags. Typically one flag from each of the access and sharing groups must be specified for all functions and methods which use these constants. Flags from other groups are optional. 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. Indicates the type of storage medium being used in a data transfer. They are used in the STGMEDIUM or FORMATETC structures. During data transfer operations, a storage medium is specified. This medium must be released after the data transfer operation. The provider of the medium indicates its choice of ownership scenarios in the value it provides in the STGMEDIUM structure. A NULL value for the pUnkForRelease member indicates that the receiving body of code owns and can free the medium. A non-NULL pointer specifies that ReleaseStgMedium can always be called to free the medium. The storage medium is a global memory handle (HGLOBAL). Allocate the global handle with the GMEM_MOVEABLE flag. If the punkForRelease member of STGMEDIUM is NULL, the destination process should use GlobalFree to release the memory. The storage medium is a disk file identified by a path. If the STGMEDIUM punkForRelease member is NULL, the destination process should use OpenFile to delete the file. The storage medium is a stream object identified by an IStream pointer. Use ISequentialStream::Read to read the data. If the STGMEDIUM punkForRelease member is not NULL, the destination process should use Release to release the stream component. The storage medium is a storage component identified by an IStorage pointer. The data is in the streams and storages contained by this IStorage instance. If the STGMEDIUM punkForRelease member is not NULL, the destination process should use Release to release the storage component. The storage medium is a GDI component (HBITMAP). If the STGMEDIUM punkForRelease member is NULL, the destination process should use DeleteObject to delete the bitmap. The storage medium is a metafile (METAFILEPICT). Use the GDI functions to access the metafile's data. If the STGMEDIUM punkForRelease member is NULL, the destination process should use DeleteMetaFile to delete the bitmap. The storage medium is an enhanced metafile (HENHMETAFILE). If the STGMEDIUM punkForRelease member is NULL, the destination process should use DeleteEnhMetaFile to delete the bitmap. No data is being passed. 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 DECIMAL structure represents a decimal data type that provides a sign and scale for a number. Reserved. The high 32 bits of the number. Describes FILETIME and provides syntax, members, and additional remarks. A property of type PT_SYSTIME has a **FILETIME** structure for its value. Such a property has a **FILETIME** data type for the **Value** member in its definition in an [SPropValue](spropvalue.md) structure. The definition of the **FILETIME** structure is in the _Win32 Programmer's Reference_ and in the MAPI header file Mapidefs.h. MAPI defines the structure conditionally to make sure that it is defined when the Win32 definition is unavailable. Read more on docs.microsoft.com. > Low-order 32 bits of the file time value. > High-order 32 bits of the file time value. 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). The POINTL structure defines the x- and y-coordinates of a point. The POINTL structure is identical to the POINT structure. Specifies the x-coordinate of the point. Specifies the y-coordinate of the point. 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. The SIZE structure defines the width and height of a rectangle. The rectangle dimensions stored in this structure can correspond to viewport extents, window extents, text extents, bitmap dimensions, or the aspect-ratio filter for some extended functions. Specifies the rectangle's width. The units depend on which function uses this structure. Specifies the rectangle's height. The units depend on which function uses this structure. The length of the inline array. Gets a ref to an individual element of the inline array. ⚠ Important ⚠: When this struct is on the stack, do not let the returned reference outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Gets this inline array as a span. ⚠ Important ⚠: When this struct is on the stack, do not let the returned span outlive the stack frame that defines it. Copies the fixed array to a new string up to the specified length regardless of whether there are null terminating characters. Thrown when is less than 0 or greater than . Copies the fixed array to a new string, stopping before the first null terminator character or at the end of the fixed array (whichever is shorter). 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 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. Describes the properties of a file that is being copied by means of the clipboard during a Microsoft ActiveX drag-and-drop operation. (Unicode) If the CFSTR_FILECONTENTS format that corresponds to this structure contains the file as a global memory object, nFileSizeHigh and nFileSizeLow specify the size of the associated memory block. If they are set, they can also be used if a user-interface needs to be displayed. For example, if a file is about to be overwritten, you would typically use information from this structure to display a dialog box containing the size, data, and name of the file. To create a zero-length file, set the FD_FILESIZE flag in the dwFlags, and set nFileSizeHigh and nFileSizeLow to zero. The CFSTR_FILECONTENTS format should represent the file as either a stream or global memory object (TYMED_ISTREAM or TYMED_HGLOBAL). > [!NOTE] > The shlobj_core.h header defines FILEDESCRIPTOR 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: DWORD Type: CLSID The file type identifier. Read more on docs.microsoft.com. Type: SIZEL The width and height of the file icon. Read more on docs.microsoft.com. Type: POINTL The screen coordinates of the file object. Read more on docs.microsoft.com. Type: DWORD File attribute flags. This will be a combination of the FILE_ATTRIBUTE_ values described in GetFileAttributes. Read more on docs.microsoft.com. Type: FILETIME The FILETIME structure that contains the time of file creation. Read more on docs.microsoft.com. Type: FILETIME The FILETIME structure that contains the time that the file was last accessed. Read more on docs.microsoft.com. Type: FILETIME The FILETIME structure that contains the time of the last write operation. Read more on docs.microsoft.com. Type: DWORD The high-order DWORD of the file size, in bytes. Read more on docs.microsoft.com. Type: DWORD The low-order DWORD of the file size, in bytes. Read more on docs.microsoft.com. Type: TCHAR[MAX_PATH] The null-terminated string that contains the name of the file. Read more on docs.microsoft.com. Defines the CF_FILEGROUPDESCRIPTOR clipboard format. (Unicode) > [!NOTE] > The shlobj_core.h header defines FILEGROUPDESCRIPTOR 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 number of elements in fgd. Read more on docs.microsoft.com. Type: FILEDESCRIPTOR[1] An array of FILEDESCRIPTOR structures that contain the file information. Read more on docs.microsoft.com. 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. 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 the dots per inch (dpi) setting for a monitor. All of these settings are affected by the PROCESS_DPI_AWARENESS of your application The effective DPI. This value should be used when determining the correct scale factor for scaling UI elements. This incorporates the scale factor set by the user for this specific display. The angular DPI. This DPI ensures rendering at a compliant angular resolution on the screen. This does not include the scale factor set by the user for this specific display. The raw DPI. This value is the linear DPI of the screen as measured on the screen itself. Use this value when you want to read the pixel density and not the recommended scaling setting. This does not include the scale factor set by the user for this specific display and is not guaranteed to be a supported DPI value. The default DPI setting for a monitor is MDT_EFFECTIVE_DPI. Represents a Win32 handle that can be closed with . 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 . GeneratedInternalTypeHelper CreateInstance GetPropertyValue SetPropertyValue CreateDelegate AddEventHandler