mirror of https://github.com/dahall/Vanara.git
2710 lines
133 KiB
C#
2710 lines
133 KiB
C#
#nullable enable
|
||
using System;
|
||
using System.Runtime.InteropServices;
|
||
using System.Runtime.InteropServices.ComTypes;
|
||
using static Vanara.PInvoke.Gdi32;
|
||
using static Vanara.PInvoke.Ole32;
|
||
using static Vanara.PInvoke.PropSys;
|
||
using static Vanara.PInvoke.Shell32;
|
||
using static Vanara.PInvoke.User32;
|
||
using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
|
||
|
||
namespace Vanara.PInvoke;
|
||
|
||
/// <summary>Enums and interfaces from the Windows Photo Acquisition API.</summary>
|
||
public static partial class PhotoAcquisition
|
||
{
|
||
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
|
||
public static readonly HRESULT PAQ_ERR = HRESULT.Make(true, HRESULT.FacilityCode.FACILITY_ITF, 0xA001);
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_CameraSequenceNumber = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 7); // VT_LPWSTR
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_DuplicateDetectionID = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 10); // VT_I4
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_FinalFilename = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 3); // VT_LPWSTR
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_GroupTag = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 4); // VT_LPWSTR
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_IntermediateFile = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 8); // VT_LPWSTR
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_OriginalFilename = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 6); // VT_LPWSTR
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_RelativePathname = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 2); // VT_LPWSTR
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_SkipImport = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 9); // VT_BOOL
|
||
public static readonly PROPERTYKEY PKEY_PhotoAcquire_TransferResult = new(new(0x00f23377, 0x7ac6, 0x4b7a, 0x84, 0x43, 0x34, 0x5e, 0x73, 0x1f, 0xa5, 0x7a), 5); // VT_SCODE
|
||
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
|
||
|
||
/// <summary>The enumeration type indicates the type of a selected device.</summary>
|
||
/// <remarks>This enumeration type is pointed to by the <c>pnDeviceType</c> parameter of IPhotoAcquireDeviceSelectionDialog::DoModal.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/ne-photoacquire-device_selection_device_type typedef enum
|
||
// tagDEVICE_SELECTION_DEVICE_TYPE { DST_UNKNOWN_DEVICE = 0, DST_WPD_DEVICE = 0x1, DST_WIA_DEVICE = 0x2, DST_STI_DEVICE = 0x3,
|
||
// DSF_TWAIN_DEVICE = 0x4, DST_FS_DEVICE = 0x5, DST_DV_DEVICE = 0x6 } DEVICE_SELECTION_DEVICE_TYPE;
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NE:photoacquire.tagDEVICE_SELECTION_DEVICE_TYPE")]
|
||
public enum DEVICE_SELECTION_DEVICE_TYPE
|
||
{
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0</para>
|
||
/// <para>Specifies that the type of the selected device is unknown.</para>
|
||
/// </summary>
|
||
DST_UNKNOWN_DEVICE,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x1</para>
|
||
/// <para>Specifies that the type of the selected device is Windows Portable Devices (WPD).</para>
|
||
/// </summary>
|
||
DST_WPD_DEVICE,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x2</para>
|
||
/// <para>Specifies that the type of the selected device is Windows Image Acquisition (WIA).</para>
|
||
/// </summary>
|
||
DST_WIA_DEVICE,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x3</para>
|
||
/// <para>Specifies that the type of the selected device is Still Image Architecture (STI).</para>
|
||
/// </summary>
|
||
DST_STI_DEVICE,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x4</para>
|
||
/// <para>Not supported.</para>
|
||
/// </summary>
|
||
DSF_TWAIN_DEVICE,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x5</para>
|
||
/// <para>Specifies that the selected device is a removable drive in the file system.</para>
|
||
/// </summary>
|
||
DST_FS_DEVICE,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x6</para>
|
||
/// </summary>
|
||
DST_DV_DEVICE,
|
||
}
|
||
|
||
/// <summary></summary>
|
||
[Flags]
|
||
public enum DSF : uint
|
||
{
|
||
/// <summary>Show devices of type Windows Portable Devices (WPD).</summary>
|
||
DSF_WPD_DEVICES = 0x00000001,
|
||
|
||
/// <summary>Show cameras of type Windows Image Acquisition (WIA).</summary>
|
||
DSF_WIA_CAMERAS = 0x00000002,
|
||
|
||
/// <summary>Show scanners of type Windows Image Acquisition (WIA).</summary>
|
||
DSF_WIA_SCANNERS = 0x00000004,
|
||
|
||
/// <summary>Show devices of type Still Image Architecture (STI).</summary>
|
||
DSF_STI_DEVICES = 0x00000008,
|
||
|
||
/// <summary/>
|
||
DSF_TWAIN_DEVICES = 0x00000010,
|
||
|
||
/// <summary>Show removable storage devices, such as CD drives or card readers.</summary>
|
||
DSF_FS_DEVICES = 0x00000020,
|
||
|
||
/// <summary>Show digital video camera devices.</summary>
|
||
DSF_DV_DEVICES = 0x00000040,
|
||
|
||
/// <summary>Show all devices.</summary>
|
||
DSF_ALL_DEVICES = 0x0000FFFF,
|
||
|
||
/// <summary/>
|
||
DSF_CPL_MODE = 0x00010000,
|
||
|
||
/// <summary>Show devices that are offline. Not supported by all device types.</summary>
|
||
DSF_SHOW_OFFLINE = 0x00020000,
|
||
}
|
||
|
||
/// <summary>The enumeration type indicates the type of error values that can be passed to the <c>nMessageType</c> parameter of IPhotoAcquireProgressCB::ErrorAdvise.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/ne-photoacquire-error_advise_message_type typedef enum
|
||
// tagERROR_ADVISE_MESSAGE_TYPE { PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL = 0, PHOTOACQUIRE_ERROR_RETRYCANCEL = 1, PHOTOACQUIRE_ERROR_YESNO =
|
||
// 2, PHOTOACQUIRE_ERROR_OK = 3 } ERROR_ADVISE_MESSAGE_TYPE;
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NE:photoacquire.tagERROR_ADVISE_MESSAGE_TYPE")]
|
||
public enum ERROR_ADVISE_MESSAGE_TYPE
|
||
{
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0</para>
|
||
/// <para>Specifies that the error that occurred requires a Skip, Retry, or Cancel response. The</para>
|
||
/// <para>pnErrorAdviseResult</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressDialogCB::ErrorAdvise</para>
|
||
/// <para>must be one of the following:</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_SKIP</para>
|
||
/// <para>,</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_SKIP_ALL</para>
|
||
/// <para>,</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_RETRY</para>
|
||
/// <para>, or</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_ABORT</para>
|
||
/// <para>.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>1</para>
|
||
/// <para>Specifies that the error that occurred requires a Retry or Cancel response. The</para>
|
||
/// <para>pnErrorAdviseResult</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressDialogCB::ErrorAdvise</para>
|
||
/// <para>must be one of the following:</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_RETRY</para>
|
||
/// <para>or</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_ABORT</para>
|
||
/// <para>.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_ERROR_RETRYCANCEL,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>2</para>
|
||
/// <para>Specifies that the error that occurred requires a Yes or No response. The</para>
|
||
/// <para>pnErrorAdviseResult</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressDialogCB::ErrorAdvise</para>
|
||
/// <para>must be one of the following:</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_YES</para>
|
||
/// <para>or</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_NO</para>
|
||
/// <para>.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_ERROR_YESNO,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>3</para>
|
||
/// <para>Specifies that the error that occurred requires an OK response. The</para>
|
||
/// <para>pnErrorAdviseResult</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressDialogCB::ErrorAdvise</para>
|
||
/// <para>must be</para>
|
||
/// <para>PHOTOACQUIRE_RESULT_OK</para>
|
||
/// <para>.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_ERROR_OK,
|
||
}
|
||
|
||
/// <summary>
|
||
/// The enumeration type indicates the type of error values that can be assigned to the <c>pnErrorAdviseResult</c> parameter of IPhotoAcquireProgressCB::ErrorAdvise.
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// The type of response allowed is of type ERROR_ADVISE_MESSAGE_TYPE, and indicated by the <c>nMessageType</c> parameter of IPhotoAcquireProgressCB::ErrorAdvise.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/ne-photoacquire-error_advise_result typedef enum
|
||
// tagERROR_ADVISE_RESULT { PHOTOACQUIRE_RESULT_YES = 0, PHOTOACQUIRE_RESULT_NO = 1, PHOTOACQUIRE_RESULT_OK = 2, PHOTOACQUIRE_RESULT_SKIP
|
||
// = 3, PHOTOACQUIRE_RESULT_SKIP_ALL = 4, PHOTOACQUIRE_RESULT_RETRY = 5, PHOTOACQUIRE_RESULT_ABORT = 6 } ERROR_ADVISE_RESULT;
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NE:photoacquire.tagERROR_ADVISE_RESULT")]
|
||
public enum ERROR_ADVISE_RESULT
|
||
{
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0</para>
|
||
/// <para>Specifies a Yes response to an error dialog. Valid only if the</para>
|
||
/// <para>nMessageType</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressCB::ErrorAdvise</para>
|
||
/// <para>is PHOTOACQUIRE_ERROR_YESNO.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_RESULT_YES,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>1</para>
|
||
/// <para>Specifies a No response to an error dialog. Valid only if the</para>
|
||
/// <para>nMessageType</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressCB::ErrorAdvise</para>
|
||
/// <para>is PHOTOACQUIRE_ERROR_YESNO.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_RESULT_NO,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>2</para>
|
||
/// <para>Specifies an OK response to an error dialog. Valid only if the</para>
|
||
/// <para>nMessageType</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressCB::ErrorAdvise</para>
|
||
/// <para>is PHOTOACQUIRE_ERROR_OK.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_RESULT_OK,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>3</para>
|
||
/// <para>Specifies a Skip response to an error dialog. Valid only if the</para>
|
||
/// <para>nMessageType</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressCB::ErrorAdvise</para>
|
||
/// <para>is PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_RESULT_SKIP,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>4</para>
|
||
/// <para>Specifies a Skip All response to an error dialog. Valid only if the</para>
|
||
/// <para>nMessageType</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressCB::ErrorAdvise</para>
|
||
/// <para>is PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_RESULT_SKIP_ALL,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>5</para>
|
||
/// <para>Specifies a Retry response to an error dialog. Valid only if the</para>
|
||
/// <para>nMessageType</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressCB::ErrorAdvise</para>
|
||
/// <para>is PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL or PHOTOACQUIRE_ERROR_RETRYCANCEL.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_RESULT_RETRY,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>6</para>
|
||
/// <para>Specifies a Cancel response to an error dialog. Valid only if the</para>
|
||
/// <para>nMessageType</para>
|
||
/// <para>parameter to</para>
|
||
/// <para>IPhotoAcquireProgressCB::ErrorAdvise</para>
|
||
/// <para>is PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL or PHOTOACQUIRE_ERROR_RETRYCANCEL.</para>
|
||
/// </summary>
|
||
PHOTOACQUIRE_RESULT_ABORT,
|
||
}
|
||
|
||
/// <summary>Specifies a double word value indicating whether this method is being called before or after processing an item.</summary>
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquirePlugin")]
|
||
public enum PAPS : uint
|
||
{
|
||
/// <summary>
|
||
/// Indicates that the method is being called before saving the acquired file. During PAPS_PRESAVE, pPhotoAcquireItem::GetProperty
|
||
/// should be used to retrieve metadata from the original file, while new metadata to be written to the file should be added to pPropertyStore.
|
||
/// </summary>
|
||
PAPS_PRESAVE = 0x00000000,
|
||
|
||
/// <summary>Indicates that the method is being called after saving the acquired file.</summary>
|
||
PAPS_POSTSAVE = 0x00000001,
|
||
|
||
/// <summary>Indicates that the user has canceled the acquire operation and any work done by the plug-in should be cleaned up.</summary>
|
||
PAPS_CLEANUP = 0x00000002,
|
||
}
|
||
|
||
/// <summary>Photo acquire flags.</summary>
|
||
[PInvokeData("photoacquire.h")]
|
||
[Flags]
|
||
public enum PHOTOACQ : uint
|
||
{
|
||
/// <summary/>
|
||
PHOTOACQ_RUN_DEFAULT = 0x00000000,
|
||
|
||
/// <summary>
|
||
/// In versions of Windows that don't include Windows Photo Gallery, PHOTOACQ_NO_GALLERY_LAUNCH suppresses the explorer window
|
||
/// launched after acquisition.
|
||
/// </summary>
|
||
PHOTOACQ_NO_GALLERY_LAUNCH = 0x00000001,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DISABLE_AUTO_ROTATE = 0x00000002,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DISABLE_PLUGINS = 0x00000004,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DISABLE_GROUP_TAG_PROMPT = 0x00000008,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DISABLE_DB_INTEGRATION = 0x00000010,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DELETE_AFTER_ACQUIRE = 0x00000020,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DISABLE_DUPLICATE_DETECTION = 0x00000040,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_ENABLE_THUMBNAIL_CACHING = 0x00000080,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DISABLE_METADATA_WRITE = 0x00000100,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DISABLE_THUMBNAIL_PROGRESS = 0x00000200,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_DISABLE_SETTINGS_LINK = 0x00000400,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_ABORT_ON_SETTINGS_UPDATE = 0x00000800,
|
||
|
||
/// <summary/>
|
||
PHOTOACQ_IMPORT_VIDEO_AS_MULTIPLE_FILES = 0x00001000,
|
||
}
|
||
|
||
/// <summary>The enumeration type indicates the check box on the IPhotoProgressDialog object.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/ne-photoacquire-progress_dialog_checkbox_id typedef enum
|
||
// PROGRESS_DIALOG_CHECKBOX_ID { PROGRESS_DIALOG_CHECKBOX_ID_DEFAULT = 0 } PROGRESS_DIALOG_CHECKBOX_ID;
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NE:photoacquire.PROGRESS_DIALOG_CHECKBOX_ID")]
|
||
public enum PROGRESS_DIALOG_CHECKBOX_ID
|
||
{
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0</para>
|
||
/// <para>Specifies PROGRESS_DIALOG_CHECKBOX_ID_DEFAULT .</para>
|
||
/// </summary>
|
||
PROGRESS_DIALOG_CHECKBOX_ID_DEFAULT,
|
||
}
|
||
|
||
/// <summary>The enumeration type indicates the image type set in IPhotoProgressDialog::SetImage.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/ne-photoacquire-progress_dialog_image_type typedef enum
|
||
// tagPROGRESS_DIALOG_IMAGE_TYPE { PROGRESS_DIALOG_ICON_SMALL = 0, PROGRESS_DIALOG_ICON_LARGE = 0x1, PROGRESS_DIALOG_ICON_THUMBNAIL =
|
||
// 0x2, PROGRESS_DIALOG_BITMAP_THUMBNAIL = 0x3 } PROGRESS_DIALOG_IMAGE_TYPE;
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NE:photoacquire.tagPROGRESS_DIALOG_IMAGE_TYPE")]
|
||
public enum PROGRESS_DIALOG_IMAGE_TYPE
|
||
{
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0</para>
|
||
/// <para>Specifies the small icon used in the title bar (normally 16 x 16 pixels).</para>
|
||
/// </summary>
|
||
PROGRESS_DIALOG_ICON_SMALL,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x1</para>
|
||
/// <para>Specifies the icon used to represent the progress dialog box in ALT+TAB key combination windows (normally 32 x 32 pixels).</para>
|
||
/// </summary>
|
||
PROGRESS_DIALOG_ICON_LARGE,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x2</para>
|
||
/// <para>Specifies an icon used in place of the thumbnail (up to 128 x 128 pixels).</para>
|
||
/// </summary>
|
||
PROGRESS_DIALOG_ICON_THUMBNAIL,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x3</para>
|
||
/// <para>Specifies a bitmap thumbnail (up to 128 x 128 pixels, although it will be scaled to fit if it is too large).</para>
|
||
/// </summary>
|
||
PROGRESS_DIALOG_BITMAP_THUMBNAIL,
|
||
}
|
||
|
||
/// <summary>The enumeration type indicates the type of string to obtain from the user in IPhotoAcquireProgressCB::GetUserInput.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/ne-photoacquire-user_input_string_type typedef enum
|
||
// tagUSER_INPUT_STRING_TYPE { USER_INPUT_DEFAULT = 0, USER_INPUT_PATH_ELEMENT = 0x1 } USER_INPUT_STRING_TYPE;
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NE:photoacquire.tagUSER_INPUT_STRING_TYPE")]
|
||
public enum USER_INPUT_STRING_TYPE
|
||
{
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0</para>
|
||
/// <para>Indicates that any string is allowed.</para>
|
||
/// </summary>
|
||
USER_INPUT_DEFAULT,
|
||
|
||
/// <summary>
|
||
/// <para>Value:</para>
|
||
/// <para>0x1</para>
|
||
/// <para>Indicates that the string will not accept characters that are illegal in file or directory names (such as * or /).</para>
|
||
/// </summary>
|
||
USER_INPUT_PATH_ELEMENT,
|
||
}
|
||
|
||
/// <summary>The interface provides methods for acquiring photos from a device.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoacquire
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquire")]
|
||
[ComImport, Guid("00F23353-E31B-4955-A8AD-CA5EBF31E2CE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown), CoClass(typeof(PhotoAcquire))]
|
||
public interface IPhotoAcquire
|
||
{
|
||
/// <summary>The method initializes an IPhotoAcquireSource object to pass to IPhotoAcquire::Acquire.</summary>
|
||
/// <param name="pszDevice">A string containing the device name.</param>
|
||
/// <returns>Returns the initialized photo source to acquire photos from.</returns>
|
||
/// <remarks>
|
||
/// <para>The IPhotoAcquireSource object created is used as the parameter for the Acquire method.</para>
|
||
/// <para>If an error occurs in , <c>ppPhotoAcquireSource</c> is initialized to <c>NULL</c>.</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquire-createphotosource HRESULT
|
||
// CreatePhotoSource( [in] LPCWSTR pszDevice, [out] IPhotoAcquireSource **ppPhotoAcquireSource );
|
||
IPhotoAcquireSource? CreatePhotoSource([In, MarshalAs(UnmanagedType.LPWStr)] string pszDevice);
|
||
|
||
/// <summary>The method acquires photos from a device.</summary>
|
||
/// <param name="pPhotoAcquireSource">
|
||
/// Pointer to an IPhotoAcquireSource object representing the device from which to acquire photos. Initialize this object by calling CreatePhotoSource.
|
||
/// </param>
|
||
/// <param name="fShowProgress">Flag that, when set to <see langword="true"/>, indicates that a progress dialog will be shown.</param>
|
||
/// <param name="hWndParent">Handle to a parent window.</param>
|
||
/// <param name="pszApplicationName">A string containing the application name.</param>
|
||
/// <param name="pPhotoAcquireProgressCB">Pointer to an optional IPhotoAcquireProgressCB object.</param>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// To initialize the <c>pPhotoAcquireSource</c> parameter passed to , CreatePhotoSource should be called prior to calling .
|
||
/// </para>
|
||
/// <para>
|
||
/// <c>pPhotoAcquireProgressCB</c> provides callback methods that allow you to apply further filtering or control as items are acquired.
|
||
/// </para>
|
||
/// <para>
|
||
/// To verify that there are items in the device before acquisition, or to selectively acquire items from the device, call
|
||
/// IPhotoAcquireSource::InitializeItemList to enumerate the items before calling .
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquire-acquire HRESULT Acquire( [in]
|
||
// IPhotoAcquireSource *pPhotoAcquireSource, [in] BOOL fShowProgress, [in] HWND hWndParent, [in] LPCWSTR pszApplicationName, [in]
|
||
// IPhotoAcquireProgressCB *pPhotoAcquireProgressCB );
|
||
void Acquire([In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireSource pPhotoAcquireSource, [In, MarshalAs(UnmanagedType.Bool)] bool fShowProgress,
|
||
[In, Optional] HWND hWndParent, [In, Optional, MarshalAs(UnmanagedType.LPWStr)] string pszApplicationName, [In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireProgressCB pPhotoAcquireProgressCB);
|
||
|
||
/// <summary>
|
||
/// The method retrieves an enumeration containing the paths of all files successfully transferred during the most recent call to Acquire.
|
||
/// </summary>
|
||
/// <returns>Returns an enumeration containing the paths to all the transferred files.</returns>
|
||
/// <remarks>If the file transfer is aborted before any files are transferred, <c>ppEnumFilePaths</c> will be set to <c>NULL</c>.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquire-enumresults HRESULT EnumResults(
|
||
// [out] IEnumString **ppEnumFilePaths );
|
||
IEnumString? EnumResults();
|
||
}
|
||
|
||
/// <summary>Provides a dialog box for selecting the device to acquire images from.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoacquiredeviceselectiondialog
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquireDeviceSelectionDialog")]
|
||
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("00F28837-55DD-4F37-AAF5-6855A9640467"), CoClass(typeof(PhotoAcquireDeviceSelectionDialog))]
|
||
public interface IPhotoAcquireDeviceSelectionDialog
|
||
{
|
||
/// <summary>The method sets the title of the device selection dialog box.</summary>
|
||
/// <param name="pszTitle">A string containing the title.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiredeviceselectiondialog-settitle
|
||
// HRESULT SetTitle( [in] LPCWSTR pszTitle );
|
||
void SetTitle([In, MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
|
||
|
||
/// <summary>The method sets the text displayed in the dialog box that prompts the user to select a device.</summary>
|
||
/// <param name="pszSubmitButtonText">A string containing the prompt.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiredeviceselectiondialog-setsubmitbuttontext
|
||
// HRESULT SetSubmitButtonText( [in] LPCWSTR pszSubmitButtonText );
|
||
void SetSubmitButtonText([In, MarshalAs(UnmanagedType.LPWStr)] string pszSubmitButtonText);
|
||
|
||
/// <summary>The method displays a device selection dialog box. The function returns when the user selects a device using the modal dialog box.</summary>
|
||
/// <param name="hWndParent">Handle to a parent window.</param>
|
||
/// <param name="dwDeviceFlags">
|
||
/// <para>Double word value containing a combination of device flags that indicate which type of devices to display. The device flags may be a combination of any of the following:</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Flag</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>DSF_WPD_DEVICES</c></term>
|
||
/// <term>Show devices of type Windows Portable Devices (WPD).</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>DSF_WIA_CAMERAS</c></term>
|
||
/// <term>Show cameras of type Windows Image Acquisition (WIA).</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>DSF_WIA_SCANNERS</c></term>
|
||
/// <term>Show scanners of type Windows Image Acquisition (WIA).</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>DSF_STI_DEVICES</c></term>
|
||
/// <term>Show devices of type Still Image Architecture (STI).</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>DSF_FS_DEVICES</c></term>
|
||
/// <term>Show removable storage devices, such as CD drives or card readers.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>DSF_DV_DEVICES</c></term>
|
||
/// <term>Show digital video camera devices.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>DSF_ALL_DEVICES</c></term>
|
||
/// <term>Show all devices.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>DSF_SHOW_OFFLINE</c></term>
|
||
/// <term>Show devices that are offline. Not supported by all device types.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="pbstrDeviceId">Pointer to a string containing the ID of the selected device.</param>
|
||
/// <param name="pnDeviceType">Pointer to the DEVICE_SELECTION_DEVICE_TYPE of the selected device.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiredeviceselectiondialog-domodal
|
||
// HRESULT DoModal( [in] HWND hWndParent, [in] DWORD dwDeviceFlags, [out] BSTR *pbstrDeviceId, [out] DEVICE_SELECTION_DEVICE_TYPE *pnDeviceType );
|
||
[PreserveSig]
|
||
HRESULT DoModal([In] HWND hWndParent, [In] DSF dwDeviceFlags, [MarshalAs(UnmanagedType.BStr)] out string? pbstrDeviceId,
|
||
out DEVICE_SELECTION_DEVICE_TYPE pnDeviceType);
|
||
}
|
||
|
||
/// <summary>The interface provides methods for working with items as they are acquired from a device.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoacquireitem
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquireItem")]
|
||
[ComImport, Guid("00F21C97-28BF-4C02-B842-5E4E90139A30"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||
public interface IPhotoAcquireItem
|
||
{
|
||
/// <summary>The method retrieves the file name for an item.</summary>
|
||
/// <returns>Pointer to a string containing the name of the item.</returns>
|
||
/// <remarks>
|
||
/// The file name consists of the display name and the extension, even if the <c>Hide extensions for known file types</c> setting is
|
||
/// checked in the Windows <c>Folder Options</c> dialog box.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-getitemname HRESULT
|
||
// GetItemName( [out] BSTR *pbstrItemName );
|
||
[return: MarshalAs(UnmanagedType.BStr)]
|
||
string? GetItemName();
|
||
|
||
/// <summary>The method retrieves the thumbnail provided for an item.</summary>
|
||
/// <param name="sizeThumbnail">Specifies the size of the thumbnail.</param>
|
||
/// <returns>Specifies a handle to the thumbnail bitmap.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-getthumbnail HRESULT
|
||
// GetThumbnail( [in] SIZE sizeThumbnail, [out] HBITMAP *phbmpThumbnail );
|
||
SafeHBITMAP? GetThumbnail([In] SIZE sizeThumbnail);
|
||
|
||
/// <summary>The method retrieves the value of a property of an item.</summary>
|
||
/// <param name="key">Specifies a key for the property.</param>
|
||
/// <param name="pv">Pointer to a property variant containing the property value.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// For an item that is a shell object, this method will defer to the <c>IPropertyStore</c> object provided by the item if the
|
||
/// property hasn't been set or updated using SetProperty.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-getproperty HRESULT
|
||
// GetProperty( [in] REFPROPERTYKEY key, [out] PROPVARIANT *pv );
|
||
[PreserveSig]
|
||
HRESULT GetProperty(in PROPERTYKEY key, [Out] PROPVARIANT pv);
|
||
|
||
/// <summary>The method sets a property for an item.</summary>
|
||
/// <param name="key">Specifies a key for the property to set.</param>
|
||
/// <param name="pv">Pointer to a property variant containing the value to set the property to.</param>
|
||
/// <remarks>The property is stored in memory, but is not written to the file.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-setproperty HRESULT
|
||
// SetProperty( [in] REFPROPERTYKEY key, [in] const PROPVARIANT *pv );
|
||
void SetProperty(in PROPERTYKEY key, [In] PROPVARIANT pv);
|
||
|
||
/// <summary>The method retrieves a read-only stream containing the contents of an item.</summary>
|
||
/// <returns>Returns a stream object with the file contents.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-getstream HRESULT GetStream(
|
||
// [out] IStream **ppStream );
|
||
IStream? GetStream();
|
||
|
||
/// <summary>The method indicates whether an item may be deleted.</summary>
|
||
/// <returns>Pointer to a flag that, when set to <see langword="true"/>, indicates that the item can be deleted.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-candelete HRESULT CanDelete(
|
||
// [out] BOOL *pfCanDelete );
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
bool CanDelete();
|
||
|
||
/// <summary>The method deletes an item.</summary>
|
||
/// <remarks>To determine whether an item may be deleted, call CanDelete first.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-delete HRESULT Delete();
|
||
void Delete();
|
||
|
||
/// <summary>The method retrieves the number of subitems contained in an item.</summary>
|
||
/// <returns>Pointer to an integer containing the count of subitems.</returns>
|
||
/// <remarks>If an error occurs, <c>pnCount</c> will be set to <c>NULL</c>.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-getsubitemcount HRESULT
|
||
// GetSubItemCount( [out] UINT *pnCount );
|
||
uint GetSubItemCount();
|
||
|
||
/// <summary>The method retrieves a subitem of an item, given the index of the subitem.</summary>
|
||
/// <param name="nItemIndex">Integer containing the index of the item.</param>
|
||
/// <returns>Returns the IPhotoAcquireItem object at the given index.</returns>
|
||
/// <remarks>If no item is found at the given index, <c>ppPhotoAcquireItem</c> is set to <c>NULL</c>.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireitem-getsubitemat HRESULT
|
||
// GetSubItemAt( [in] UINT nItemIndex, [out] IPhotoAcquireItem **ppPhotoAcquireItem );
|
||
IPhotoAcquireItem? GetSubItemAt([In] uint nItemIndex);
|
||
}
|
||
|
||
/// <summary>The method retrieves the value of a property of an item.</summary>
|
||
/// <param name="item">The <see cref="IPhotoAcquireItem"/> instance.</param>
|
||
/// <param name="key">Specifies a key for the property.</param>
|
||
/// <returns>The property value or <see langword="null"/> on error.</returns>
|
||
/// <remarks>
|
||
/// For an item that is a shell object, this method will defer to the <c>IPropertyStore</c> object provided by the item if the
|
||
/// property hasn't been set or updated using SetProperty.
|
||
/// </remarks>
|
||
public static object? GetProperty(this IPhotoAcquireItem item, in PROPERTYKEY key)
|
||
{
|
||
if (item == null) throw new ArgumentNullException(nameof(item));
|
||
using var pv = new PROPVARIANT();
|
||
return item.GetProperty(key, pv).Succeeded ? pv.Value : null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// The interface is used to display an options dialog box in which the user can select photo acquisition settings such as file name
|
||
/// formats, as well as whether or not to rotate images, to prompt for a tag name, or to erase photos from the camera after importing.
|
||
/// </summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoacquireoptionsdialog
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquireOptionsDialog")]
|
||
[ComImport, Guid("00F2B3EE-BF64-47EE-89F4-4DEDD79643F2"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown), CoClass(typeof(PhotoAcquireOptionsDialog))]
|
||
public interface IPhotoAcquireOptionsDialog
|
||
{
|
||
/// <summary>Initializes the options dialog box and reads any saved options from the registry.</summary>
|
||
/// <param name="pszRegistryRoot">
|
||
/// (optional) A string containing the registry root of a custom location to read the acquisition settings from. If this parameter is
|
||
/// set to <c>NULL</c>, the default location will be used.
|
||
/// </param>
|
||
/// <remarks>
|
||
/// <para>must be called prior to calling Create or DoModal. Failure to do so will cause <c>Create</c> or <c>DoModal</c> to fail.</para>
|
||
/// <para>If is called while the options dialog box is already displayed, an error will be returned.</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireoptionsdialog-initialize HRESULT
|
||
// Initialize( [in] LPCWSTR pszRegistryRoot );
|
||
void Initialize([In, Optional, MarshalAs(UnmanagedType.LPWStr)] string pszRegistryRoot);
|
||
|
||
/// <summary>The method creates and displays a modeless instance of the photo options dialog box, hosted within a parent window.</summary>
|
||
/// <param name="hWndParent">Handle to the parent window.</param>
|
||
/// <returns>Specifies the created dialog box.</returns>
|
||
/// <remarks>
|
||
/// <para>The Initialize method should be called prior to the method.</para>
|
||
/// <para>The parent window indicated by <c>hWndParent</c> provides <c>OK</c> and <c>Cancel</c> buttons to the new dialog box instance.</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireoptionsdialog-create HRESULT Create(
|
||
// [in] HWND hWndParent, [out] HWND *phWndDialog );
|
||
HWND Create([In] HWND hWndParent);
|
||
|
||
/// <summary>The method closes and destroys the modeless dialog box created with the Create method.</summary>
|
||
/// <remarks>If you destroy the parent window, the child window will automatically be destroyed.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireoptionsdialog-destroy HRESULT Destroy();
|
||
void Destroy();
|
||
|
||
/// <summary>The method creates and displays the options dialog box as a modal dialog box.</summary>
|
||
/// <param name="hWndParent">Handle to the dialog's parent window.</param>
|
||
/// <returns>Specifies the code returned when the window is closed.</returns>
|
||
/// <remarks>
|
||
/// The modal dialog displayed by <c>DoModal</c> will have <c>OK</c> and <c>Cancel</c> buttons, whereas the <c>OK</c> and
|
||
/// <c>Cancel</c> buttons of the modeless dialog displayed by Create must be provided by the parent window.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireoptionsdialog-domodal HRESULT
|
||
// DoModal( [in] HWND hWndParent, [out] INT_PTR *ppnReturnCode );
|
||
[return: MarshalAs(UnmanagedType.SysInt)]
|
||
IntPtr DoModal([In] HWND hWndParent);
|
||
|
||
/// <summary>
|
||
/// The method saves acquisition settings from the options dialog box to the registry so that a subsequent instance of the dialog can
|
||
/// be initialized with the same settings.
|
||
/// </summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireoptionsdialog-savedata HRESULT SaveData();
|
||
void SaveData();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Implement the interface when you want to create a plug-in to run alongside the Windows Vista user interface (UI) for image
|
||
/// acquisition. Registry settings are required to enable the plug-in.
|
||
/// </summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoacquireplugin
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquirePlugin")]
|
||
[ComImport, Guid("00f2dceb-ecb8-4f77-8e47-e7a987c83dd0"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||
public interface IPhotoAcquirePlugin
|
||
{
|
||
/// <summary>
|
||
/// The method provides extended functionality when the plug-in is initialized. The application provides the implementation of the method.
|
||
/// </summary>
|
||
/// <param name="pPhotoAcquireSource">Specifies the source from which photos are being acquired.</param>
|
||
/// <param name="pPhotoAcquireProgressCB">Specifies the callback that will provide additional processing during acquisition.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireplugin-initialize HRESULT
|
||
// Initialize( [in] IPhotoAcquireSource *pPhotoAcquireSource, [in] IPhotoAcquireProgressCB *pPhotoAcquireProgressCB );
|
||
[PreserveSig]
|
||
HRESULT Initialize([In, Optional] IPhotoAcquireSource pPhotoAcquireSource, [In, Optional] IPhotoAcquireProgressCB pPhotoAcquireProgressCB);
|
||
|
||
/// <summary>
|
||
/// The method provides additional functionality each time an item is processed. The application provides the implementation of the method.
|
||
/// </summary>
|
||
/// <param name="dwAcquireStage">
|
||
/// <para>
|
||
/// Specifies a double word value indicating whether this method is being called before or after processing an item. Must be one of:
|
||
/// PAPS_PRESAVE, PAPS_POSTSAVE, or PAPS_CLEANUP.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>PAPS_PRESAVE</term>
|
||
/// <term>
|
||
/// Indicates that the method is being called before saving the acquired file. During PAPS_PRESAVE, pPhotoAcquireItem::GetProperty
|
||
/// should be used to retrieve metadata from the original file, while new metadata to be written to the file should be added to <c>pPropertyStore</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAPS_POSTSAVE</term>
|
||
/// <term>Indicates that the method is being called after saving the acquired file.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>PAPS_CLEANUP</term>
|
||
/// <term>Indicates that the user has canceled the acquire operation and any work done by the plug-in should be cleaned up.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="pPhotoAcquireItem">Pointer to an IPhotoAcquireItem object for the item being processed.</param>
|
||
/// <param name="pOriginalItemStream">
|
||
/// Pointer to an <c>IStream</c> object for the original item. <c>NULL</c> if <c>dwAcquireStage</c> is PAPS_POSTSAVE.
|
||
/// </param>
|
||
/// <param name="pszFinalFilename">The file name of the destination of the item. <c>NULL</c> if <c>dwAcquireStage</c> is PAPS_PRESAVE.</param>
|
||
/// <param name="pPropertyStore">The item's property store. <c>NULL</c> if <c>dwAcquireStage</c> is PAPS_POSTSAVE.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireplugin-processitem HRESULT
|
||
// ProcessItem( [in] DWORD dwAcquireStage, [in] IPhotoAcquireItem *pPhotoAcquireItem, [in] IStream *pOriginalItemStream, [in] LPCWSTR
|
||
// pszFinalFilename, [in] IPropertyStore *pPropertyStore );
|
||
[PreserveSig]
|
||
HRESULT ProcessItem(PAPS dwAcquireStage, [In, Optional] IPhotoAcquireItem pPhotoAcquireItem, [In, Optional] IStream pOriginalItemStream,
|
||
string pszFinalFilename, [In, Optional] IPropertyStore pPropertyStore);
|
||
|
||
/// <summary>
|
||
/// Provides extended functionality when a transfer session is completed. The application provides the implementation of the
|
||
/// <c>TransferComplete</c> method.
|
||
/// </summary>
|
||
/// <param name="hr">Specifies the result of the transfer operation.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireplugin-transfercomplete HRESULT
|
||
// TransferComplete( [in] HRESULT hr );
|
||
[PreserveSig]
|
||
HRESULT TransferComplete(HRESULT hr);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality when the configuration dialog is displayed. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="hWndParent">Specifies the handle to the configuration dialog window.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireplugin-displayconfiguredialog
|
||
// HRESULT DisplayConfigureDialog( [in] HWND hWndParent );
|
||
[PreserveSig]
|
||
HRESULT DisplayConfigureDialog([In] HWND hWndParent);
|
||
}
|
||
|
||
/// <summary>The interface may be implemented if you wish to do extra processing at various stages in the acquisition process.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoacquireprogresscb
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquireProgressCB")]
|
||
[ComImport, Guid("00F2CE1E-935E-4248-892C-130F32C45CB4"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||
public interface IPhotoAcquireProgressCB
|
||
{
|
||
/// <summary>
|
||
/// The method provides extended functionality when a cancellation occurs during an acquisition session. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="pfCancelled">Pointer to a flag that, when set to <see langword="true"/>, indicates that the operation was canceled.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-cancelled HRESULT
|
||
// Cancelled( [out] BOOL *pfCancelled );
|
||
[PreserveSig]
|
||
HRESULT Cancelled([MarshalAs(UnmanagedType.Bool)] out bool pfCancelled);
|
||
|
||
/// <summary>
|
||
/// <para>The method provides extended functionality when the enumeration of items to acquire begins.</para>
|
||
/// <para>The application provides the implementation of the method.</para>
|
||
/// </summary>
|
||
/// <param name="pPhotoAcquireSource">Pointer to the IPhotoAcquireSource object that items are being enumerated from.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-startenumeration HRESULT
|
||
// StartEnumeration( [in] IPhotoAcquireSource *pPhotoAcquireSource );
|
||
[PreserveSig]
|
||
HRESULT StartEnumeration([In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireSource pPhotoAcquireSource);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality each time an item is found during enumeration of items from the device. This method
|
||
/// can be used to exclude an item from the list of items to acquire. The application provides the implementation of the method.
|
||
/// </summary>
|
||
/// <param name="pPhotoAcquireItem">Pointer to the found IPhotoAcquireItem object.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>S_FALSE</c></term>
|
||
/// <term>Exclude this item from the list of files to acquire.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// Return S_FALSE to exclude the item from the results of the enumeration. This would allow the caller to exclude videos or camera
|
||
/// raw files, for instance.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-founditem HRESULT
|
||
// FoundItem( [in] IPhotoAcquireItem *pPhotoAcquireItem );
|
||
[PreserveSig]
|
||
HRESULT FoundItem([In, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireItem pPhotoAcquireItem);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality when enumeration of files from the image source is complete. The application provides
|
||
/// the implementation of the method.
|
||
/// </summary>
|
||
/// <param name="hr">Specifies the result of the enumeration operation.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-endenumeration HRESULT
|
||
// EndEnumeration( [in] HRESULT hr );
|
||
[PreserveSig]
|
||
HRESULT EndEnumeration(HRESULT hr);
|
||
|
||
/// <summary>
|
||
/// The method provides additional processing when transfer of items from the device begins. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="pPhotoAcquireSource">Pointer to the IPhotoAcquireSource from which items are being retrieved.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any Failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>Returning an error HRESULT other than E_NOTIMPL will cause acquisition to be aborted.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-starttransfer HRESULT
|
||
// StartTransfer( [in] IPhotoAcquireSource *pPhotoAcquireSource );
|
||
[PreserveSig]
|
||
HRESULT StartTransfer([In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireSource pPhotoAcquireSource);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality each time the transfer of an item begins. The application provides the implementation
|
||
/// of the method.
|
||
/// </summary>
|
||
/// <param name="nItemIndex">Integer value containing the item index in the list of items to transfer.</param>
|
||
/// <param name="pPhotoAcquireItem">Pointer to the IPhotoAcquireItem object that is to be transferred.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-startitemtransfer HRESULT
|
||
// StartItemTransfer( [in] UINT nItemIndex, [in] IPhotoAcquireItem *pPhotoAcquireItem );
|
||
[PreserveSig]
|
||
HRESULT StartItemTransfer([In] uint nItemIndex, [In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireItem pPhotoAcquireItem);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality when a destination directory is created during the acquisition process. The
|
||
/// application provides the implementation of the method.
|
||
/// </summary>
|
||
/// <param name="pszDirectory">A string containing the directory.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-directorycreated HRESULT
|
||
// DirectoryCreated( [in] LPCWSTR pszDirectory );
|
||
[PreserveSig]
|
||
HRESULT DirectoryCreated([In, MarshalAs(UnmanagedType.LPWStr)] string pszDirectory);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality when the percentage of items transferred changes. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="fOverall">
|
||
/// Flag that, when set to <see langword="true"/>, indicates that the value contained in <c>nPercent</c> is a percentage of the
|
||
/// overall transfer progress, rather than a percentage of an individual item's progress.
|
||
/// </param>
|
||
/// <param name="nPercent">Integer value containing the percentage of items transferred.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-updatetransferpercent
|
||
// HRESULT UpdateTransferPercent( [in] BOOL fOverall, [in] UINT nPercent );
|
||
[PreserveSig]
|
||
HRESULT UpdateTransferPercent([MarshalAs(UnmanagedType.Bool)] bool fOverall, [In] uint nPercent);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality each time a file is transferred from the image source. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="nItemIndex">Integer value containing the item index.</param>
|
||
/// <param name="pPhotoAcquireItem">Pointer to a photo acquire item object.</param>
|
||
/// <param name="hr">Specifies the result of the transfer operation.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-enditemtransfer HRESULT
|
||
// EndItemTransfer( [in] UINT nItemIndex, [in] IPhotoAcquireItem *pPhotoAcquireItem, [in] HRESULT hr );
|
||
[PreserveSig]
|
||
HRESULT EndItemTransfer([In] uint nItemIndex, [In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireItem pPhotoAcquireItem, HRESULT hr);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality when the transfer of all files is complete. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="hr">Specifies the result of the transfer.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-endtransfer HRESULT
|
||
// EndTransfer( [in] HRESULT hr );
|
||
[PreserveSig]
|
||
HRESULT EndTransfer(HRESULT hr);
|
||
|
||
/// <summary>
|
||
/// <para>The method provides extended functionality when deletion of items from the device begins.</para>
|
||
/// <para>The implementation of is provided by the application.</para>
|
||
/// </summary>
|
||
/// <param name="pPhotoAcquireSource">Pointer to the IPhotoAcquireSource that items are being deleted from.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-startdelete HRESULT
|
||
// StartDelete( [in] IPhotoAcquireSource *pPhotoAcquireSource );
|
||
[PreserveSig]
|
||
HRESULT StartDelete([In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireSource pPhotoAcquireSource);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality each time the deletion of an individual item from the device begins. The application
|
||
/// provides the implementation of the method.
|
||
/// </summary>
|
||
/// <param name="nItemIndex">Integer value containing the item index in the list of items to delete.</param>
|
||
/// <param name="pPhotoAcquireItem">Pointer to the IPhotoAcquireItem object that is being deleted.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-startitemdelete HRESULT
|
||
// StartItemDelete( [in] UINT nItemIndex, [in] IPhotoAcquireItem *pPhotoAcquireItem );
|
||
[PreserveSig]
|
||
HRESULT StartItemDelete([In] uint nItemIndex, [In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireItem pPhotoAcquireItem);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality when the percentage of items deleted changes. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="nPercent">Integer value containing the percentage of items deleted.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-updatedeletepercent
|
||
// HRESULT UpdateDeletePercent( [in] UINT nPercent );
|
||
[PreserveSig]
|
||
HRESULT UpdateDeletePercent([In] uint nPercent);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality each time a file is deleted from the image source. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="nItemIndex">Integer value containing the item index.</param>
|
||
/// <param name="pPhotoAcquireItem">Pointer to the deleted IPhotoAcquireItem object.</param>
|
||
/// <param name="hr">Specifies the result of the delete operation.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>This method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-enditemdelete HRESULT
|
||
// EndItemDelete( [in] UINT nItemIndex, [in] IPhotoAcquireItem *pPhotoAcquireItem, [in] HRESULT hr );
|
||
[PreserveSig]
|
||
HRESULT EndItemDelete([In] uint nItemIndex, [In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireItem pPhotoAcquireItem, HRESULT hr);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality when deletion of files from the image source is complete. The application provides the
|
||
/// implementation of the method.
|
||
/// </summary>
|
||
/// <param name="hr">Specifies the result of the delete operation.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-enddelete HRESULT
|
||
// EndDelete( [in] HRESULT hr );
|
||
[PreserveSig]
|
||
HRESULT EndDelete(HRESULT hr);
|
||
|
||
/// <summary>
|
||
/// The method provides extended functionality when an acquisition session is completed. The application provides the implementation
|
||
/// of the method.
|
||
/// </summary>
|
||
/// <param name="hr">Specifies the result of the acquisition.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-endsession HRESULT
|
||
// EndSession( [in] HRESULT hr );
|
||
[PreserveSig]
|
||
HRESULT EndSession(HRESULT hr);
|
||
|
||
/// <summary>The method returns a value indicating whether photos should be deleted after acquisition.</summary>
|
||
/// <param name="pfDeleteAfterAcquire">
|
||
/// Pointer to a flag that, when set to <see langword="true"/>, indicates that photos should be deleted after acquisition.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-getdeleteafteracquire
|
||
// HRESULT GetDeleteAfterAcquire( [out] BOOL *pfDeleteAfterAcquire );
|
||
[PreserveSig]
|
||
HRESULT GetDeleteAfterAcquire([MarshalAs(UnmanagedType.Bool)] out bool pfDeleteAfterAcquire);
|
||
|
||
/// <summary>
|
||
/// The method provides custom error handling for errors that occur during acquisition. The application provides the implementation
|
||
/// of the method.
|
||
/// </summary>
|
||
/// <param name="hr">Specifies the error that occurred.</param>
|
||
/// <param name="pszErrorMessage">A string containing the error message.</param>
|
||
/// <param name="nMessageType">
|
||
/// <para>Integer value containing the message type. May be one of the following.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL</c></term>
|
||
/// <term>
|
||
/// Specifies that the error that occurred requires a Skip, Retry, or Cancel response. The <c>pnErrorAdviseResult</c> parameter must
|
||
/// be set to one of the following: <c>PHOTOACQUIRE_RESULT_SKIP</c>, <c>PHOTOACQUIRE_RESULT_SKIP_ALL</c>,
|
||
/// <c>PHOTOACQUIRE_RESULT_RETRY</c>, or <c>PHOTOACQUIRE_RESULT_ABORT</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_ERROR_RETRYCANCEL</c></term>
|
||
/// <term>
|
||
/// Specifies that the error that occurred requires a Retry or Cancel response. The <c>pnErrorAdviseResult</c> parameter must be set
|
||
/// to one of the following: <c>PHOTOACQUIRE_RESULT_RETRY</c> or <c>PHOTOACQUIRE_RESULT_ABORT</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_ERROR_YESNO</c></term>
|
||
/// <term>
|
||
/// Specifies that the error that occurred requires a Yes or No response. The <c>pnErrorAdviseResult</c> parameter must be set to one
|
||
/// of the following: <c>PHOTOACQUIRE_RESULT_YES</c> or <c>PHOTOACQUIRE_RESULT_NO</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_ERROR_OK</c></term>
|
||
/// <term>
|
||
/// Specifies that the error that occurred requires an OK response. The <c>pnErrorAdviseResult</c> parameter must be set to <c>PHOTOACQUIRE_RESULT_OK</c>.
|
||
/// </term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="pnErrorAdviseResult">
|
||
/// <para>
|
||
/// Pointer to an integer value containing the error advise result. The result should be one of the acceptable types indicated by the
|
||
/// <c>nMessageType</c> parameter, and must be one of the following:
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_RESULT_YES</c></term>
|
||
/// <term>Specifies a Yes response. Valid if <c>nMessageType</c> is <c>PHOTOACQUIRE_ERROR_YESNO</c>.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_RESULT_NO</c></term>
|
||
/// <term>Specifies a No response. Valid if <c>nMessageType</c> is <c>PHOTOACQUIRE_ERROR_YESNO</c>.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_RESULT_OK</c></term>
|
||
/// <term>Specifies an OK response. Valid if <c>nMessageType</c> is <c>PHOTOACQUIRE_ERROR_OK</c>.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_RESULT_SKIP</c></term>
|
||
/// <term>Specifies a Skip response. Valid if <c>nMessageType</c> is <c>PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL</c>.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_RESULT_SKIP_ALL</c></term>
|
||
/// <term>Specifies a Skip All response. Valid if <c>nMessageType</c> is <c>PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL</c>.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_RESULT_RETRY</c></term>
|
||
/// <term>Specifies a Retry response. Valid if <c>nMessageType</c> is <c>PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL</c> or <c>PHOTOACQUIRE_ERROR_RETRYCANCEL</c>.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PHOTOACQUIRE_RESULT_ABORT</c></term>
|
||
/// <term>Specifies a Cancel response. Valid if <c>nMessageType</c> is <c>PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL</c> or <c>PHOTOACQUIRE_ERROR_RETRYCANCEL</c>.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>The method is not yet implemented</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// Normally, a message is displayed when an error occurs during image acquisition. If suppression of this message is desired,
|
||
/// implement .
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-erroradvise HRESULT
|
||
// ErrorAdvise( [in] HRESULT hr, [in] LPCWSTR pszErrorMessage, [in] ERROR_ADVISE_MESSAGE_TYPE nMessageType, [out] ERROR_ADVISE_RESULT
|
||
// *pnErrorAdviseResult );
|
||
[PreserveSig]
|
||
HRESULT ErrorAdvise(HRESULT hr, [In, MarshalAs(UnmanagedType.LPWStr)] string pszErrorMessage, [In] ERROR_ADVISE_MESSAGE_TYPE nMessageType,
|
||
out ERROR_ADVISE_RESULT pnErrorAdviseResult);
|
||
|
||
/// <summary>
|
||
/// The method overrides the default functionality that displays a message prompting the user for string input during acquisition.
|
||
/// The application provides the implementation of the method.
|
||
/// </summary>
|
||
/// <param name="riidType">Specifies the interface ID of the prompt type. This may only be IID_IUserInputString.</param>
|
||
/// <param name="pUnknown">Pointer to an object of the prompt class. Currently, this must be an IUserInputString object.</param>
|
||
/// <param name="pPropVarResult">
|
||
/// <para>
|
||
/// Pointer to a property variant object representing the descriptive input to be obtained. Must be freed by the caller using PropVariantClear.
|
||
/// </para>
|
||
/// <para>
|
||
/// If the application's implementation of returns a value other than E_NOTIMPL, the value of <c>pPropVarDefault</c> must be copied
|
||
/// to the <c>pPropVarResult</c> parameter.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="pPropVarDefault">Pointer to a property variant object representing the default value of the input being requested.</param>
|
||
/// <returns>
|
||
/// <para>
|
||
/// The method returns an <c>HRESULT</c>. Your implementation is not limited to the following return values. Any failing HRESULT
|
||
/// other than E_NOTIMPL is fatal and will cause the transfer to abort.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_NOTIMPL</c></term>
|
||
/// <term>Return E_NOTIMPL if the default functionality is desired</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// If this method is implemented, the implementation should copy the value of the <c>pPropVarDefault</c> argument to the
|
||
/// <c>pPropVarResult</c> parameter.
|
||
/// </para>
|
||
/// <para>If this method returns an HRESULT other than E_NOTIMPL, the default dialog box that prompts the user will not be displayed.</para>
|
||
/// <para>
|
||
/// If the progress dialog box is suppressed in IPhotoAcquire::Acquire, this method must be implemented in order to assign a default
|
||
/// value to the <c>pPropVarResult</c> parameter. Normally a value is supplied to <c>pPropVarResult</c> in the course of prompting
|
||
/// the user with the default dialog, but when the dialog is suppressed, the application must copy the value of the
|
||
/// <c>pPropVarDefault</c> argument to the <c>pPropVarResult</c> parameter.
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquireprogresscb-getuserinput HRESULT
|
||
// GetUserInput( [in] REFIID riidType, [in] IUnknown *pUnknown, [out] PROPVARIANT *pPropVarResult, [in] const PROPVARIANT
|
||
// *pPropVarDefault );
|
||
[PreserveSig]
|
||
HRESULT GetUserInput(in Guid riidType, [In, Optional, MarshalAs(UnmanagedType.IUnknown, IidParameterIndex = 0)] object pUnknown,
|
||
[Out] PROPVARIANT pPropVarResult, [In, Optional] PROPVARIANT pPropVarDefault);
|
||
}
|
||
|
||
/// <summary>The interface is used to work with image acquisition settings, such as file name format.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoacquiresettings
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquireSettings")]
|
||
[ComImport, Guid("00F2B868-DD67-487C-9553-049240767E91"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||
public interface IPhotoAcquireSettings
|
||
{
|
||
/// <summary>The method specifies a registry key from which to initialize settings.</summary>
|
||
/// <param name="pszRegistryKey">A string containing the registry key.</param>
|
||
/// <remarks>The structure of the registry has not yet been determined at this point.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-initializefromregistry
|
||
// HRESULT InitializeFromRegistry( [in] LPCWSTR pszRegistryKey );
|
||
void InitializeFromRegistry([In, MarshalAs(UnmanagedType.LPWStr)] string pszRegistryKey);
|
||
|
||
/// <summary>The method sets the photo acquire flags.</summary>
|
||
/// <param name="dwPhotoAcquireFlags">Double word value containing the photo acquire flags.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-setflags HRESULT SetFlags(
|
||
// [in] DWORD dwPhotoAcquireFlags );
|
||
void SetFlags([In] PHOTOACQ dwPhotoAcquireFlags);
|
||
|
||
/// <summary>The method specifies a format string (template) that specifies the format of file names.</summary>
|
||
/// <param name="pszTemplate">A string containing the format string.</param>
|
||
/// <remarks>
|
||
/// <para>Format strings contain a mix of path literals and tokens. A format string looks like the following:</para>
|
||
/// <code language="none">$(MyPicturesFolder)\$(DateAcquired), $(EventName)\$(EventName) $(SequenceNumber).$(OriginalExtension)</code>
|
||
/// <para>The token format looks like the following, where and are suppressed if the replacement for the yields a zero-length string:</para>
|
||
/// <code language="none">$([OptionalPrefix]TokenIdentifier:SubToken[OptionalSuffix]|AlternateString)</code>
|
||
/// <para>The caret ("^") is an escape character, so "^$" would yield "$" in the final path.</para>
|
||
/// <para>
|
||
/// Parentheses and brackets are not allowed as literals within tokens, but can be used outside of tokens. This means you cannot use
|
||
/// "[", "]", "(", or ")" within the sub-token unless they are escaped with a caret ("^").
|
||
/// </para>
|
||
/// <para>There are a few different classes of tokens, including the following:</para>
|
||
/// <para><c>SHGetSpecialFolder</c> variables such as the following. These must be the first token, and can only occur once, at most:</para>
|
||
/// <list type="bullet">
|
||
/// <item><c>MyPicturesFolder</c></item>
|
||
/// <item><c>MyDocumentsFolder</c></item>
|
||
/// </list>
|
||
/// <para>Session variables such as the following:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <c>SequenceNumber</c> (The sequence number is used to avoid filename collisions; if it exists, it must be in the file name
|
||
/// portion of the path.) -
|
||
/// </item>
|
||
/// <item><c>DateAcquired</c></item>
|
||
/// <item><c>EventName</c></item>
|
||
/// <item><c>UserName</c></item>
|
||
/// <item><c>MachineName</c></item>
|
||
/// </list>
|
||
/// <para>File and metadata variables such as the following:</para>
|
||
/// <list type="bullet">
|
||
/// <item><c>DateTaken</c></item>
|
||
/// <item><c>OriginalFilename</c></item>
|
||
/// <item><c>OriginalExtension</c></item>
|
||
/// <item><c>CameraModel</c></item>
|
||
/// <item><c>Width</c></item>
|
||
/// <item><c>Height</c></item>
|
||
/// </list>
|
||
/// <para>
|
||
/// Since these tokens are not intended to be visible to users, they will not be localized. For example, <c>$(DateTaken)</c> will be
|
||
/// the same on all versions of Microsoft Windows, regardless of locale or language settings.
|
||
/// </para>
|
||
/// <para>As an example, suppose <c>EventName</c> is "Meghan's Birthday" and the naming pattern is as follows:</para>
|
||
/// <para>The resulting files would be named as follows:</para>
|
||
/// <code language="none">$(MyPicturesFolder)\$(DateAcquired)$([, ]EventName)\$(EventName[ ])$(SequenceNumber).$(OriginalExtension)</code>
|
||
/// <para>C:\Documents and Settings\shauniv\My Documents\My Pictures\2003-11-14, Meghan's Birthday\Meghan's Birthday 001.jpg</para>
|
||
/// <para>C:\Documents and Settings\shauniv\My Documents\My Pictures\2003-11-14, Meghan's Birthday\Meghan's Birthday 002.jpg</para>
|
||
/// <para>C:\Documents and Settings\shauniv\My Documents\My Pictures\2003-11-14, Meghan's Birthday\Meghan's Birthday 003.jpg</para>
|
||
/// <para>C:\Documents and Settings\shauniv\My Documents\My Pictures\2003-11-14, Meghan's Birthday\Meghan's Birthday 004.jpg</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-setoutputfilenametemplate
|
||
// HRESULT SetOutputFilenameTemplate( [in] LPCWSTR pszTemplate );
|
||
void SetOutputFilenameTemplate([In, MarshalAs(UnmanagedType.LPWStr)] string pszTemplate);
|
||
|
||
/// <summary>The method sets a value indicating how wide sequential fields in filenames will be.</summary>
|
||
/// <param name="dwWidth">Double word value containing the width of sequential fields.</param>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// If the value passed to is nonzero and the format string specified in SetOutputFileNameTemplate contains a sequential token, this
|
||
/// method sets the width allotted for the sequential token. For example, given the template , if padding is set to 0, a file name
|
||
/// might appear as
|
||
/// </para>
|
||
/// <para>If padding is set to 3, the file name may appear as</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-setsequencepaddingwidth
|
||
// HRESULT SetSequencePaddingWidth( [in] DWORD dwWidth );
|
||
void SetSequencePaddingWidth([In] uint dwWidth);
|
||
|
||
/// <summary>The method sets a value indicating whether zeros or spaces are used to pad sequential file names.</summary>
|
||
/// <param name="fZeroPad">Flag that, if set to <see langword="true"/>, indicates that zeros pad sequential file names.</param>
|
||
/// <remarks>
|
||
/// <para>A file name padded with zeros might appear as</para>
|
||
/// <para>The same file name without zero padding might appear as</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-setsequencezeropadding
|
||
// HRESULT SetSequenceZeroPadding( [in] BOOL fZeroPad );
|
||
void SetSequenceZeroPadding([In, MarshalAs(UnmanagedType.Bool)] bool fZeroPad);
|
||
|
||
/// <summary>The method sets the group tag for an acquisition session.</summary>
|
||
/// <param name="pszGroupTag">A string containing the group tag.</param>
|
||
/// <remarks>
|
||
/// The group tag is stored as a keyword in each file's metadata. It is also used in the file name if the token is present in the
|
||
/// format string passed to SetOutputFileNameTemplate.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-setgrouptag HRESULT
|
||
// SetGroupTag( [in] LPCWSTR pszGroupTag );
|
||
void SetGroupTag([In, MarshalAs(UnmanagedType.LPWStr)] string pszGroupTag);
|
||
|
||
/// <summary>The method sets the acquisition time explicitly.</summary>
|
||
/// <param name="pftAcquisitionTime">Specifies the acquisition time.</param>
|
||
/// <remarks>
|
||
/// This method is typically used to force two sessions to show the same acquisition time. If not explicitly set, acquisition time
|
||
/// defaults to the current machine time.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-setacquisitiontime HRESULT
|
||
// SetAcquisitionTime( [in] const FILETIME *pftAcquisitionTime );
|
||
void SetAcquisitionTime(in FILETIME pftAcquisitionTime);
|
||
|
||
/// <summary>The method retrieves the photo acquire flags.</summary>
|
||
/// <returns>Pointer to a double word value containing the photo acquire flags.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-getflags HRESULT GetFlags(
|
||
// [out] DWORD *pdwPhotoAcquireFlags );
|
||
PHOTOACQ GetFlags();
|
||
|
||
/// <summary>The method retrieves a format string (template) that specifies the format of file names.</summary>
|
||
/// <returns>Pointer to a string containing the format string.</returns>
|
||
/// <remarks>Format strings contain a mix of path literals and tokens. A format string looks like the following:</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-getoutputfilenametemplate
|
||
// HRESULT GetOutputFilenameTemplate( [out] BSTR *pbstrTemplate );
|
||
[return: MarshalAs(UnmanagedType.BStr)]
|
||
string? GetOutputFilenameTemplate();
|
||
|
||
/// <summary>The method retrieves a value indicating how wide sequential fields in file names will be.</summary>
|
||
/// <returns>Pointer to a double word value containing the width of sequential fields.</returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// If the format string specified in SetOutputFileNameTemplate contains a sequential token, this method gets the width allotted for
|
||
/// the sequential token.
|
||
/// </para>
|
||
/// <para>If the format string does not contain a sequential token, the value returned by this method is not defined.</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-getsequencepaddingwidth
|
||
// HRESULT GetSequencePaddingWidth( [out] DWORD *pdwWidth );
|
||
uint GetSequencePaddingWidth();
|
||
|
||
/// <summary>The method retrieves a value that indicates whether zeros or spaces will be used to pad sequential file names.</summary>
|
||
/// <returns>Pointer to a flag that, if set to <see langword="true"/>, indicates that zeros will pad sequential file names.</returns>
|
||
/// <remarks>
|
||
/// <para>A file name padded with zeros might appear as</para>
|
||
/// <para>The same file name without zero padding might appear as</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-getsequencezeropadding
|
||
// HRESULT GetSequenceZeroPadding( [out] BOOL *pfZeroPad );
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
bool GetSequenceZeroPadding();
|
||
|
||
/// <summary>The method retrieves a tag string for the group of files being downloaded from the device.</summary>
|
||
/// <returns>Pointer to a string containing the group tag.</returns>
|
||
/// <remarks>
|
||
/// The group tag is stored as a keyword in each file's metadata. It is also used in the file name if the token is present in the
|
||
/// format string passed to SetOutputFileNameTemplate.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-getgrouptag HRESULT
|
||
// GetGroupTag( [out] BSTR *pbstrGroupTag );
|
||
[return: MarshalAs(UnmanagedType.BStr)]
|
||
string? GetGroupTag();
|
||
|
||
/// <summary>The method retrieves the acquisition time of the current session.</summary>
|
||
/// <returns>Specifies acquisition time.</returns>
|
||
/// <remarks>If not set explicitly, the acquisition time defaults to the current machine time.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresettings-getacquisitiontime HRESULT
|
||
// GetAcquisitionTime( [out] FILETIME *pftAcquisitionTime );
|
||
FILETIME GetAcquisitionTime();
|
||
}
|
||
|
||
/// <summary>The interface is used for acquisition of items from a device.</summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoacquiresource
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoAcquireSource")]
|
||
[ComImport, Guid("00F2C703-8613-4282-A53B-6EC59C5883AC"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||
public interface IPhotoAcquireSource
|
||
{
|
||
/// <summary>The method retrieves the name of the device, formatted for display.</summary>
|
||
/// <returns>Pointer to a string containing the friendly name.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresource-getfriendlyname HRESULT
|
||
// GetFriendlyName( [out] BSTR *pbstrFriendlyName );
|
||
[return: MarshalAs(UnmanagedType.BStr)]
|
||
string? GetFriendlyName();
|
||
|
||
/// <summary>The method retrieves the icons that are used to represent the device.</summary>
|
||
/// <param name="nSize">Integer value containing the size of the icon to retrieve.</param>
|
||
/// <param name="phLargeIcon">Specifies the large icon used for the device.</param>
|
||
/// <param name="phSmallIcon">Specifies the small icon used for the device.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresource-getdeviceicons HRESULT
|
||
// GetDeviceIcons( [in] UINT nSize, [out] HICON *phLargeIcon, [out] HICON *phSmallIcon );
|
||
void GetDeviceIcons([In] uint nSize, out SafeHICON? phLargeIcon, out SafeHICON? phSmallIcon);
|
||
|
||
/// <summary>
|
||
/// The InitializeItemList method enumerates transferable items on the device and passes each item to the optional progress callback,
|
||
/// if it is supplied.
|
||
/// </summary>
|
||
/// <param name="fForceEnumeration">
|
||
/// Flag that, if set to <see langword="true"/>, indicates that enumeration will be repeated even if the item list has already been
|
||
/// initialized. If set to <c>FALSE</c>, this flag indicates that repeated calls to after the item list has already been initialized
|
||
/// will not enumerate items again.
|
||
/// </param>
|
||
/// <param name="pPhotoAcquireProgressCB">Optional. Pointer to an IPhotoAcquireProgressCB object.</param>
|
||
/// <param name="pnItemCount">Returns the number of items found.</param>
|
||
/// <remarks>
|
||
/// <para>If IPhotoAcquire::Acquire is called without first calling InitializeItemList, initialization of the item list is done implicitly.</para>
|
||
/// <para>
|
||
/// The first time the item list is initialized<65>either implicitly through IPhotoAcquire::Acquire or explicitly by calling
|
||
/// InitializeItemList<73>each item is enumerated. During enumeration, if an IPhotoAcquireProgressCB object is passed to
|
||
/// InitializeItemList, its implementation of StartEnumeration, FoundItem, and EndEnumeration may be used to apply further filtering
|
||
/// or control to the list of items to be transferred.
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresource-initializeitemlist HRESULT
|
||
// InitializeItemList( [in] BOOL fForceEnumeration, [in] IPhotoAcquireProgressCB *pPhotoAcquireProgressCB, [out] UINT *pnItemCount );
|
||
void InitializeItemList([In, MarshalAs(UnmanagedType.Bool)] bool fForceEnumeration,
|
||
[In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoAcquireProgressCB pPhotoAcquireProgressCB, out uint pnItemCount);
|
||
|
||
/// <summary>The method retrieves the number of items found by the InitializeItemList method.</summary>
|
||
/// <returns>Pointer to an integer value containing the item count.</returns>
|
||
/// <remarks>Before calling this method, call InitializeItemList to initialize the item list.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresource-getitemcount HRESULT
|
||
// GetItemCount( [out] UINT *pnItemCount );
|
||
uint GetItemCount();
|
||
|
||
/// <summary>The method retrieves the IPhotoAcquireItem object at the given index in the list of items.</summary>
|
||
/// <param name="nIndex">Integer value containing the index.</param>
|
||
/// <returns>Pointer to the address of an IPhotoAcquireItem object.</returns>
|
||
/// <remarks>Before calling this method, call InitializeItemList to initialize the item list.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresource-getitemat HRESULT GetItemAt(
|
||
// [in] UINT nIndex, [out] IPhotoAcquireItem **ppPhotoAcquireItem );
|
||
IPhotoAcquireItem? GetItemAt([In] uint nIndex);
|
||
|
||
/// <summary>The method obtains an IPhotoAcquireSettings object for working with acquisition settings.</summary>
|
||
/// <returns>Pointer to the address of a photo acquire settings object.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresource-getphotoacquiresettings
|
||
// HRESULT GetPhotoAcquireSettings( [out] IPhotoAcquireSettings **ppPhotoAcquireSettings );
|
||
IPhotoAcquireSettings? GetPhotoAcquireSettings();
|
||
|
||
/// <summary>The method retrieves the identifier (ID) of the device.</summary>
|
||
/// <returns>Pointer to a string containing the device ID.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoacquiresource-getdeviceid HRESULT
|
||
// GetDeviceId( [out] BSTR *pbstrDeviceId );
|
||
[return: MarshalAs(UnmanagedType.BStr)]
|
||
string? GetDeviceId();
|
||
|
||
/// <summary>Binds to object.</summary>
|
||
/// <param name="riid">The IID of the object to which to bind.</param>
|
||
/// <returns>The interface instance requested.</returns>
|
||
[return: MarshalAs(UnmanagedType.IUnknown, IidParameterIndex = 0)]
|
||
object? BindToObject(in Guid riid);
|
||
}
|
||
|
||
/// <summary>Implement this interface to get process from an <see cref="IPhotoProgressDialog"/>.</summary>
|
||
[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("00F242D0-B206-4E7D-B4C1-4755BCBB9C9F")]
|
||
public interface IPhotoProgressActionCB
|
||
{
|
||
/// <summary>Does the action.</summary>
|
||
/// <param name="hWndParent">The parent window handle.</param>
|
||
/// <returns>S_OK on success.</returns>
|
||
[PreserveSig]
|
||
HRESULT DoAction(HWND hWndParent);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Provides the progress dialog box that may be displayed when enumerating or importing images. The dialog box is modal and runs in its
|
||
/// own thread.
|
||
/// </summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iphotoprogressdialog
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IPhotoProgressDialog")]
|
||
[ComImport, Guid("00F246F9-0750-4F08-9381-2CD8E906A4AE"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown), CoClass(typeof(PhotoProgressDialog))]
|
||
public interface IPhotoProgressDialog
|
||
{
|
||
/// <summary>The method creates and displays a progress dialog box that can be shown during image enumeration and acquisition.</summary>
|
||
/// <param name="hWndParent">Handle of the parent window.</param>
|
||
/// <remarks>
|
||
/// <para>The dialog box that is created is modal, and runs in its own thread.</para>
|
||
/// <para>To close the dialog, call Destroy.</para>
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-create HRESULT Create( [in]
|
||
// HWND hwndParent );
|
||
void Create([In] HWND hWndParent);
|
||
|
||
/// <summary>The method retrieves the handle to the progress dialog box.</summary>
|
||
/// <returns>Specifies the handle to the progress dialog box.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-getwindow HRESULT GetWindow(
|
||
// [out] HWND *phwndProgressDialog );
|
||
HWND GetWindow();
|
||
|
||
/// <summary>The method closes and disposes of the progress dialog box shown during image enumeration and acquisition.</summary>
|
||
/// <remarks>
|
||
/// Calling is the only way to close the progress dialog box. If is not called, the dialog box will remain open. The dialog box is
|
||
/// not automatically closed when the operation in progress completes.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-destroy HRESULT Destroy();
|
||
void Destroy();
|
||
|
||
/// <summary>The method sets the title of the progress dialog box.</summary>
|
||
/// <param name="pszTitle">A string containing the title.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-settitle HRESULT SetTitle(
|
||
// [in] LPCWSTR pszTitle );
|
||
void SetTitle([In, MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
|
||
|
||
/// <summary>
|
||
/// The method indicates whether to show the check box in the progress dialog box indicating whether to delete images after transfer.
|
||
/// </summary>
|
||
/// <param name="nCheckboxId">Integer containing the check box identifier (ID).</param>
|
||
/// <param name="fShow">Flag that, when set to <see langword="true"/>, indicates that the check box will appear.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-showcheckbox HRESULT
|
||
// ShowCheckbox( [in] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId, [in] BOOL fShow );
|
||
void ShowCheckbox([In] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId, [In, MarshalAs(UnmanagedType.Bool)] bool fShow);
|
||
|
||
/// <summary>The method sets the text for the check box in the progress dialog box indicating whether to delete images after transfer.</summary>
|
||
/// <param name="nCheckboxId">Integer containing the check box identifier (ID).</param>
|
||
/// <param name="pszCheckboxText">A string containing the check box text.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-setcheckboxtext HRESULT
|
||
// SetCheckboxText( [in] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId, [in] LPCWSTR pszCheckboxText );
|
||
void SetCheckboxText([In] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId, [In, MarshalAs(UnmanagedType.LPWStr)] string pszCheckboxText);
|
||
|
||
/// <summary>The method sets the text for the check box in the progress dialog box indicating whether to delete images after transfer.</summary>
|
||
/// <param name="nCheckboxId">Integer containing the check box identifier (ID).</param>
|
||
/// <param name="fChecked">Flag that, when set to <see langword="true"/>, indicates that the check box will appear checked.</param>
|
||
void SetCheckboxCheck([In] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId, [In, MarshalAs(UnmanagedType.Bool)] bool fChecked);
|
||
|
||
/// <summary>The method sets the tooltip text for the check box in the progress dialog box.</summary>
|
||
/// <param name="nCheckboxId">Integer containing the check box identifier (ID).</param>
|
||
/// <param name="pszCheckboxTooltipText">A string containing the check box tooltip text.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-setcheckboxtooltip HRESULT
|
||
// SetCheckboxTooltip( [in] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId, [in] LPCWSTR pszCheckboxTooltipText );
|
||
void SetCheckboxTooltip([In] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId, [In, MarshalAs(UnmanagedType.LPWStr)] string pszCheckboxTooltipText);
|
||
|
||
/// <summary>
|
||
/// The method indicates whether the check box in the progress dialog box (typically indicating whether to delete files after
|
||
/// transfer) is selected.
|
||
/// </summary>
|
||
/// <param name="nCheckboxId">Integer value containing the check box identifier (ID).</param>
|
||
/// <returns>Pointer to a flag that, if set to <see langword="true"/>, indicates that the check box is selected.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-ischeckboxchecked HRESULT
|
||
// IsCheckboxChecked( [in] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId, [out] BOOL *pfChecked );
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
bool IsCheckboxChecked([In] PROGRESS_DIALOG_CHECKBOX_ID nCheckboxId);
|
||
|
||
/// <summary>Sets the caption of the progress dialog box.</summary>
|
||
/// <param name="pszTitle">A string containing the title of the progress dialog box.</param>
|
||
/// <remarks>The caption text is displayed above the progress indicator bar in the dialog box.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-setcaption HRESULT
|
||
// SetCaption( [in] LPCWSTR pszTitle );
|
||
void SetCaption([In, MarshalAs(UnmanagedType.LPWStr)] string pszTitle);
|
||
|
||
/// <summary>
|
||
/// Sets either the thumbnail image displayed in the progress dialog box, the icon in the title bar of the progress dialog box, or
|
||
/// the icon in ALT+TAB key combination windows.
|
||
/// </summary>
|
||
/// <param name="nImageType">
|
||
/// <para>
|
||
/// Integer value indicating the image type to set. Only one type of image type may be set at a time. The values passed to this
|
||
/// parameter should not be considered a bit field and may not be combined with bitwise OR.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Meaning</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>PROGRESS_DIALOG_ICON_SMALL</c></term>
|
||
/// <term>The small icon used in the title bar (normally 16 x 16 pixels).</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PROGRESS_DIALOG_ICON_LARGE</c></term>
|
||
/// <term>The icon used to represent the progress dialog box in Alt-Tab windows (normally 32 x 32 pixels).</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PROGRESS_DIALOG_ICON_THUMBNAIL</c></term>
|
||
/// <term>An icon used in place of the thumbnail (up to 128 x 128 pixels).</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>PROGRESS_DIALOG_BITMAP_THUMBNAIL</c></term>
|
||
/// <term>A bitmap thumbnail (up to 128 x 128 pixels, although it will be scaled to fit if it is too large).</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <param name="hIcon">Handle to an icon object.</param>
|
||
/// <param name="hBitmap">Handle to a bitmap object representing the thumbnail image.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-setimage HRESULT SetImage(
|
||
// [in] PROGRESS_DIALOG_IMAGE_TYPE nImageType, [in] HICON hIcon, [in] HBITMAP hBitmap );
|
||
void SetImage([In] PROGRESS_DIALOG_IMAGE_TYPE nImageType, [In, Optional] HICON hIcon, [In, Optional] HBITMAP hBitmap);
|
||
|
||
/// <summary>The method sets a value indicating the completed portion of the current operation.</summary>
|
||
/// <param name="nPercent">
|
||
/// Integer value indicating the percentage of the operation that has completed. This value may be between 0 and 100 only.
|
||
/// </param>
|
||
/// <remarks>
|
||
/// If you pass PROGRESS_INDETERMINATE to , the progress bar will not progress from left to right (from 0 to 100%), but will instead
|
||
/// animate to indicate that an operation with an indeterminate end is taking place.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-setpercentcomplete HRESULT
|
||
// SetPercentComplete( [in] int nPercent );
|
||
void SetPercentComplete([In] int nPercent);
|
||
|
||
/// <summary>The method sets the text for the progress bar in the progress dialog box.</summary>
|
||
/// <param name="pszProgressText">A string containing the progress text.</param>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-setprogresstext HRESULT
|
||
// SetProgressText( [in] LPCWSTR pszProgressText );
|
||
void SetProgressText([In, MarshalAs(UnmanagedType.LPWStr)] string pszProgressText);
|
||
|
||
/// <summary>Sets the action link callback.</summary>
|
||
/// <param name="pPhotoProgressActionCB">
|
||
/// A reference to a <see cref="IPhotoProgressActionCB"/> derived class that responds to the action link click.
|
||
/// </param>
|
||
void SetActionLinkCallback([In, Optional, MarshalAs(UnmanagedType.Interface)] IPhotoProgressActionCB pPhotoProgressActionCB);
|
||
|
||
/// <summary>The method sets the text for the action link in the progress dialog box.</summary>
|
||
/// <param name="pszCaption">A string containing the action link text.</param>
|
||
void SetActionLinkText([In, MarshalAs(UnmanagedType.LPWStr)] string pszCaption);
|
||
|
||
/// <summary>The method indicates whether to show the action link in the progress dialog box.</summary>
|
||
/// <param name="fShow">Flag that, when set to <see langword="true"/>, indicates that the action link will appear.</param>
|
||
void ShowActionLink([In, MarshalAs(UnmanagedType.Bool)] bool fShow);
|
||
|
||
/// <summary>The method indicates whether the operation has been canceled via the progress dialog box.</summary>
|
||
/// <returns>Pointer to a flag that, if set to <see langword="true"/>, indicates the action has been canceled.</returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-iscancelled HRESULT
|
||
// IsCancelled( [out] BOOL *pfCancelled );
|
||
[return: MarshalAs(UnmanagedType.Bool)]
|
||
bool IsCancelled();
|
||
|
||
/// <summary>Retrieves descriptive information entered by the user, such as the tag name of the images to store.</summary>
|
||
/// <param name="riidType">Specifies the interface identifier (ID) of the prompt type. Currently, the only supported value is IID_IUserInputString.</param>
|
||
/// <param name="pUnknown">Pointer to an object of the prompt class. Currently, the only supported type is IUserInputString.</param>
|
||
/// <param name="pPropVarResult">Pointer to a property variant that stores the user input. Must be freed by the caller using <c>ClearPropVariant</c>.</param>
|
||
/// <param name="pPropVarDefault">Pointer to a property variant containing the default value to be used if no input is supplied.</param>
|
||
/// <remarks>
|
||
/// If the progress dialog box has been suppressed in IPhotoAcquire::Acquire, and IPhotoAcquireProgressCB::GetUserInput is either not
|
||
/// implemented, or returns E_NOTIMPL, this method will return S_FALSE, and <c>pPropVarResult</c> will contain the value stored in
|
||
/// the optional <c>pPropVarDefault</c> argument.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-getuserinput HRESULT
|
||
// GetUserInput( [in] REFIID riidType, [in] IUnknown *pUnknown, [out] PROPVARIANT *pPropVarResult, [in] const PROPVARIANT
|
||
// *pPropVarDefault );
|
||
[PreserveSig]
|
||
HRESULT GetUserInput(in Guid riidType, [In, Optional, MarshalAs(UnmanagedType.IUnknown, IidParameterIndex = 0)] object pUnknown,
|
||
[Out] PROPVARIANT pPropVarResult, [In, Optional] PROPVARIANT pPropVarDefault);
|
||
}
|
||
|
||
/// <summary>Retrieves descriptive information entered by the user, such as the tag name of the images to store.</summary>
|
||
/// <param name="dlg">The <see cref="IPhotoProgressDialog"/> instance.</param>
|
||
/// <param name="pUnknown">Pointer to an object of the prompt class. Currently, the only supported type is IUserInputString.</param>
|
||
/// <param name="pPropVarDefault">The default value to be used if no input is supplied.</param>
|
||
/// <returns>The user input value, or <see langword="null"/> on error.</returns>
|
||
/// <exception cref="System.ArgumentNullException">dlg</exception>
|
||
/// <remarks>
|
||
/// If the progress dialog box has been suppressed in IPhotoAcquire::Acquire, and IPhotoAcquireProgressCB::GetUserInput is either not
|
||
/// implemented, or returns E_NOTIMPL, this method will return S_FALSE, and <c>pPropVarResult</c> will contain the value stored in the
|
||
/// optional <c>pPropVarDefault</c> argument.
|
||
/// </remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iphotoprogressdialog-getuserinput HRESULT
|
||
// GetUserInput( [in] REFIID riidType, [in] IUnknown *pUnknown, [out] PROPVARIANT *pPropVarResult, [in] const PROPVARIANT
|
||
// *pPropVarDefault );
|
||
[PreserveSig]
|
||
public static string? GetUserInput(this IPhotoProgressDialog dlg, [In, Optional] IUserInputString pUnknown, [In, Optional] string? pPropVarDefault)
|
||
{
|
||
if (dlg == null) throw new ArgumentNullException(nameof(dlg));
|
||
using PROPVARIANT res = new();
|
||
using PROPVARIANT def = pPropVarDefault is null ? new() : new(pPropVarDefault, VarEnum.VT_BSTR);
|
||
return dlg.GetUserInput(typeof(IUserInputString).GUID, pUnknown, res, def) == HRESULT.S_OK ? res.bstrVal : null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// The <c>IUserInputString</c> interface represents the object created when asking the user for a string<6E>for example, when obtaining the
|
||
/// name of a tag.
|
||
/// </summary>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nn-photoacquire-iuserinputstring
|
||
[PInvokeData("photoacquire.h", MSDNShortId = "NN:photoacquire.IUserInputString")]
|
||
[ComImport, Guid("00f243a1-205b-45ba-ae26-abbc53aa7a6f"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
||
public interface IUserInputString
|
||
{
|
||
/// <summary>The method retrieves the text for the submit button.</summary>
|
||
/// <param name="pbstrSubmitButtonText">Pointer to a string containing the submit button text.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getsubmitbuttontext HRESULT
|
||
// GetSubmitButtonText( [out] BSTR *pbstrSubmitButtonText );
|
||
[PreserveSig]
|
||
HRESULT GetSubmitButtonText([MarshalAs(UnmanagedType.BStr)] out string? pbstrSubmitButtonText);
|
||
|
||
/// <summary>The method retrieves the title of a prompt if the prompt is a modal dialog box.</summary>
|
||
/// <param name="pbstrPromptTitle">Pointer to a string containing the title of the prompt.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getprompt HRESULT GetPrompt(
|
||
// [out] BSTR *pbstrPromptTitle );
|
||
[PreserveSig]
|
||
HRESULT GetPrompt([MarshalAs(UnmanagedType.BStr)] out string? pbstrPromptTitle);
|
||
|
||
/// <summary>
|
||
/// The <c>GetStringId</c> method retrieves the unlocalized canonical name for the requested string. For example, when requesting a
|
||
/// tag name, the canonical name might be "TagName".
|
||
/// </summary>
|
||
/// <param name="pbstrStringId">Pointer to a string containing the string identifier (ID).</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getstringid HRESULT GetStringId(
|
||
// [out] BSTR *pbstrStringId );
|
||
[PreserveSig]
|
||
HRESULT GetStringId([MarshalAs(UnmanagedType.BStr)] out string? pbstrStringId);
|
||
|
||
/// <summary>The method retrieves a value indicating the type of string to obtain from the user.</summary>
|
||
/// <param name="pnStringType">
|
||
/// <para>Pointer to an integer value containing the string type.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Value</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>USER_INPUT_DEFAULT</c></term>
|
||
/// <term>Specifies that any string is allowed.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>USER_INPUT_PATH_ELEMENT</c></term>
|
||
/// <term>Specifies that the string will not accept characters that are illegal in file or directory names (such as * or /).</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getstringtype HRESULT
|
||
// GetStringType( [out] USER_INPUT_STRING_TYPE *pnStringType );
|
||
[PreserveSig]
|
||
HRESULT GetStringType(out USER_INPUT_STRING_TYPE pnStringType);
|
||
|
||
/// <summary>The method retrieves the tooltip text displayed for a control.</summary>
|
||
/// <param name="pbstrTooltipText">Pointer to a string containing the tooltip text.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-gettooltiptext HRESULT
|
||
// GetTooltipText( [out] BSTR *pbstrTooltipText );
|
||
[PreserveSig]
|
||
HRESULT GetTooltipText([MarshalAs(UnmanagedType.BStr)] out string? pbstrTooltipText);
|
||
|
||
/// <summary>The method retrieves the maximum string length the user interface (UI) should allow.</summary>
|
||
/// <param name="pcchMaxLength">Pointer to the size of the maximum string length in characters.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getmaxlength HRESULT
|
||
// GetMaxLength( [out] UINT *pcchMaxLength );
|
||
[PreserveSig]
|
||
HRESULT GetMaxLength(out uint pcchMaxLength);
|
||
|
||
/// <summary>The method retrieves the default string used to initialize an edit control (or equivalent).</summary>
|
||
/// <param name="pbstrDefault">Pointer to a string containing the default value used to initialize the edit control.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>The pointer passed was <c>NULL</c>.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getdefault HRESULT GetDefault(
|
||
// [out] BSTR *pbstrDefault );
|
||
[PreserveSig]
|
||
HRESULT GetDefault([MarshalAs(UnmanagedType.BStr)] out string? pbstrDefault);
|
||
|
||
/// <summary>The method retrieves the number of items in the list of most recently used items.</summary>
|
||
/// <param name="pnMruCount">Pointer to an integer value containing the number of items in the list of most recently used items.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>If an error occurs, <c>pnMruCount</c> will be set to 0.</remarks>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getmrucount HRESULT GetMruCount(
|
||
// [out] UINT *pnMruCount );
|
||
[PreserveSig]
|
||
HRESULT GetMruCount(out uint pnMruCount);
|
||
|
||
/// <summary>The method retrieves the entry at the given index in the most recently used list.</summary>
|
||
/// <param name="nIndex">Integer containing the index at which to retrieve the entry.</param>
|
||
/// <param name="pbstrMruEntry">Pointer to a string containing the most recently used entry.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getmruentryat HRESULT
|
||
// GetMruEntryAt( [in] UINT nIndex, [out] BSTR *pbstrMruEntry );
|
||
[PreserveSig]
|
||
HRESULT GetMruEntryAt(uint nIndex, [MarshalAs(UnmanagedType.BStr)] out string? pbstrMruEntry);
|
||
|
||
/// <summary>The method retrieves the default image used to initialize an edit control.</summary>
|
||
/// <param name="nSize">Integer containing the size of the image.</param>
|
||
/// <param name="phBitmap">Pointer to the handle that specifies the image bitmap.</param>
|
||
/// <param name="phIcon">Pointer to the handle that specifies the image icon.</param>
|
||
/// <returns>
|
||
/// <para>The method returns an <c>HRESULT</c>. Possible values include, but are not limited to, those in the following table.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term><c>S_OK</c></term>
|
||
/// <term>The method succeeded.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term><c>E_POINTER</c></term>
|
||
/// <term>A <c>NULL</c> pointer was passed where a non- <c>NULL</c> pointer is expected.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
// https://learn.microsoft.com/en-us/windows/win32/api/photoacquire/nf-photoacquire-iuserinputstring-getimage HRESULT GetImage( [in]
|
||
// UINT nSize, [out] HBITMAP *phBitmap, [out] HICON *phIcon );
|
||
[PreserveSig]
|
||
HRESULT GetImage(uint nSize, out SafeHBITMAP? phBitmap, out SafeHICON? phIcon);
|
||
}
|
||
|
||
/// <summary>CLSID_PhotoAcquire</summary>
|
||
[ComImport, ClassInterface(ClassInterfaceType.None), Guid("00F26E02-E9F2-4A9F-9FDD-5A962FB26A98")]
|
||
public class PhotoAcquire { }
|
||
|
||
/// <summary>CLSID_PhotoAcquireAutoPlayDropTarget</summary>
|
||
[ComImport, ClassInterface(ClassInterfaceType.None), Guid("00F20EB5-8FD6-4D9D-B75E-36801766C8F1")]
|
||
public class PhotoAcquireAutoPlayDropTarget : IDropTarget
|
||
{
|
||
/// <summary>Indicates whether a drop can be accepted, and, if so, the effect of the drop.</summary>
|
||
/// <param name="pDataObj">
|
||
/// A pointer to the IDataObject interface on the data object. This data object contains the data being transferred in the
|
||
/// drag-and-drop operation. If the drop occurs, this data object will be incorporated into the target.
|
||
/// </param>
|
||
/// <param name="grfKeyState">
|
||
/// The current state of the keyboard modifier keys on the keyboard. Possible values can be a combination of any of the flags
|
||
/// MK_CONTROL, MK_SHIFT, MK_ALT, MK_BUTTON, MK_LBUTTON, MK_MBUTTON, and MK_RBUTTON.
|
||
/// </param>
|
||
/// <param name="pt">A POINTL structure containing the current cursor coordinates in screen coordinates.</param>
|
||
/// <param name="pdwEffect">
|
||
/// On input, pointer to the value of the pdwEffect parameter of the DoDragDrop function. On return, must contain one of the
|
||
/// DROPEFFECT flags, which indicates what the result of the drop operation would be.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>This method returns S_OK on success. Other possible values include the following.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>E_UNEXPECTED</term>
|
||
/// <term>An unexpected error has occurred.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>E_INVALIDARG</term>
|
||
/// <term>The pdwEffect parameter is NULL on input.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>E_OUTOFMEMORY</term>
|
||
/// <term>There was insufficient memory available for this operation.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// You do not call <c>DragEnter</c> directly; instead the DoDragDrop function calls it to determine the effect of a drop the first
|
||
/// time the user drags the mouse into the registered window of a drop target.
|
||
/// </para>
|
||
/// <para>
|
||
/// To implement <c>DragEnter</c>, you must determine whether the target can use the data in the source data object by checking three things:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>The format and medium specified by the data object</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>The input value of pdwEffect</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>The state of the modifier keys</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>
|
||
/// To check the format and medium, use the IDataObject pointer passed in the pDataObject parameter to call
|
||
/// IDataObject::EnumFormatEtc so you can enumerate the FORMATETC structures the source data object supports. Then call
|
||
/// IDataObject::QueryGetData to determine whether the data object can render the data on the target by examining the formats and
|
||
/// medium specified for the data object.
|
||
/// </para>
|
||
/// <para>
|
||
/// On entry to <c>IDropTarget::DragEnter</c>, the pdwEffect parameter is set to the effects given to the pdwOkEffect parameter of
|
||
/// the DoDragDrop function. The <c>IDropTarget::DragEnter</c> method must choose one of these effects or disable the drop.
|
||
/// </para>
|
||
/// <para>The following modifier keys affect the result of the drop.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Key Combination</term>
|
||
/// <term>User-Visible Feedback</term>
|
||
/// <term>Drop Effect</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>CTRL + SHIFT</term>
|
||
/// <term>=</term>
|
||
/// <term>DROPEFFECT_LINK</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>CTRL</term>
|
||
/// <term>+</term>
|
||
/// <term>DROPEFFECT_COPY</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>No keys or SHIFT</term>
|
||
/// <term>None</term>
|
||
/// <term>DROPEFFECT_MOVE</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>
|
||
/// On return, the method must write the effect, one of the DROPEFFECT flags, to the pdwEffect parameter. DoDragDrop then takes this
|
||
/// parameter and writes it to its pdwEffect parameter. You communicate the effect of the drop back to the source through
|
||
/// <c>DoDragDrop</c> in the pdwEffect parameter. The <c>DoDragDrop</c> function then calls IDropSource::GiveFeedback so that the
|
||
/// source application can display the appropriate visual feedback to the user through the target window.
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/oleidl/nf-oleidl-idroptarget-dragenter HRESULT DragEnter( IDataObject
|
||
// *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect );
|
||
[PreserveSig]
|
||
public virtual extern HRESULT DragEnter([In] IDataObject pDataObj, [In] MouseButtonState grfKeyState, [In] POINT pt, [In, Out] ref DROPEFFECT pdwEffect);
|
||
|
||
/// <summary>
|
||
/// Provides target feedback to the user and communicates the drop's effect to the DoDragDrop function so it can communicate the
|
||
/// effect of the drop back to the source.
|
||
/// </summary>
|
||
/// <param name="grfKeyState">
|
||
/// The current state of the keyboard modifier keys on the keyboard. Valid values can be a combination of any of the flags
|
||
/// MK_CONTROL, MK_SHIFT, MK_ALT, MK_BUTTON, MK_LBUTTON, MK_MBUTTON, and MK_RBUTTON.
|
||
/// </param>
|
||
/// <param name="pt">A POINTL structure containing the current cursor coordinates in screen coordinates.</param>
|
||
/// <param name="pdwEffect">
|
||
/// On input, pointer to the value of the pdwEffect parameter of the DoDragDrop function. On return, must contain one of the
|
||
/// DROPEFFECT flags, which indicates what the result of the drop operation would be.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>This method returns S_OK on success. Other possible values include the following.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>E_UNEXPECTED</term>
|
||
/// <term>An unexpected error has occurred.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>E_INVALIDARG</term>
|
||
/// <term>The pdwEffect value is not valid.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>E_OUTOFMEMORY</term>
|
||
/// <term>There was insufficient memory available for this operation.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// You do not call <c>DragOver</c> directly. The DoDragDrop function calls this method each time the user moves the mouse across a
|
||
/// given target window. <c>DoDragDrop</c> exits the loop if the drag-and-drop operation is canceled, if the user drags the mouse out
|
||
/// of the target window, or if the drop is completed.
|
||
/// </para>
|
||
/// <para>
|
||
/// In implementing <c>IDropTarget::DragOver</c>, you must provide features similar to those in IDropTarget::DragEnter. You must
|
||
/// determine the effect of dropping the data on the target by examining the FORMATETC defining the data object's formats and medium,
|
||
/// along with the state of the modifier keys. The mouse position may also play a role in determining the effect of a drop. The
|
||
/// following modifier keys affect the result of the drop.
|
||
/// </para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Key Combination</term>
|
||
/// <term>User-Visible Feedback</term>
|
||
/// <term>Drop Effect</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>CTRL + SHIFT</term>
|
||
/// <term>=</term>
|
||
/// <term>DROPEFFECT_LINK</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>CTRL</term>
|
||
/// <term>+</term>
|
||
/// <term>DROPEFFECT_COPY</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>No keys or SHIFT</term>
|
||
/// <term>None</term>
|
||
/// <term>DROPEFFECT_MOVE</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>
|
||
/// You communicate the effect of the drop back to the source through DoDragDrop in pdwEffect. The <c>DoDragDrop</c> function then
|
||
/// calls IDropSource::GiveFeedback so the source application can display the appropriate visual feedback to the user.
|
||
/// </para>
|
||
/// <para>
|
||
/// On entry to <c>IDropTarget::DragOver</c>, the pdwEffect parameter must be set to the allowed effects passed to the pdwOkEffect
|
||
/// parameter of the DoDragDrop function. The <c>IDropTarget::DragOver</c> method must be able to choose one of these effects or
|
||
/// disable the drop.
|
||
/// </para>
|
||
/// <para>
|
||
/// Upon return, pdwEffect is set to one of the DROPEFFECT flags. This value is then passed to the pdwEffect parameter of DoDragDrop.
|
||
/// Reasonable values are DROPEFFECT_COPY to copy the dragged data to the target, DROPEFFECT_LINK to create a link to the source
|
||
/// data, or DROPEFFECT_MOVE to allow the dragged data to be permanently moved from the source application to the target.
|
||
/// </para>
|
||
/// <para>
|
||
/// You may also wish to provide appropriate visual feedback in the target window. There may be some target feedback already
|
||
/// displayed from a previous call to <c>IDropTarget::DragOver</c> or from the initial IDropTarget::DragEnter. If this feedback is no
|
||
/// longer appropriate, you should remove it.
|
||
/// </para>
|
||
/// <para>
|
||
/// For efficiency reasons, a data object is not passed in <c>IDropTarget::DragOver</c>. The data object passed in the most recent
|
||
/// call to IDropTarget::DragEnter is available and can be used.
|
||
/// </para>
|
||
/// <para>
|
||
/// When <c>IDropTarget::DragOver</c> has completed its operation, the DoDragDrop function calls IDropSource::GiveFeedback so the
|
||
/// source application can display the appropriate visual feedback to the user.
|
||
/// </para>
|
||
/// <para>Notes to Implementers</para>
|
||
/// <para>
|
||
/// This function is called frequently during the DoDragDrop loop so it makes sense to optimize your implementation of the
|
||
/// <c>DragOver</c> method as much as possible.
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/oleidl/nf-oleidl-idroptarget-dragover HRESULT DragOver( DWORD grfKeyState,
|
||
// POINTL pt, DWORD *pdwEffect );
|
||
[PreserveSig]
|
||
public virtual extern HRESULT DragOver([In] MouseButtonState grfKeyState, [In] POINT pt, [In, Out] ref DROPEFFECT pdwEffect);
|
||
|
||
/// <summary>Removes target feedback and releases the data object.</summary>
|
||
/// <returns>
|
||
/// <para>This method returns S_OK on success. Other possible values include the following.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>E_OUTOFMEMORY</term>
|
||
/// <term>There is insufficient memory available for this operation.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>You do not call this method directly. The DoDragDrop function calls this method in either of the following cases:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>When the user drags the cursor out of a given target window.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>When the user cancels the current drag-and-drop operation.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>
|
||
/// To implement <c>IDropTarget::DragLeave</c>, you must remove any target feedback that is currently displayed. You must also
|
||
/// release any references you hold to the data transfer object.
|
||
/// </para>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/oleidl/nf-oleidl-idroptarget-dragleave HRESULT DragLeave( );
|
||
[PreserveSig]
|
||
public virtual extern HRESULT DragLeave();
|
||
|
||
/// <summary>Incorporates the source data into the target window, removes target feedback, and releases the data object.</summary>
|
||
/// <param name="pDataObj">A pointer to the IDataObject interface on the data object being transferred in the drag-and-drop operation.</param>
|
||
/// <param name="grfKeyState">
|
||
/// The current state of the keyboard modifier keys on the keyboard. Possible values can be a combination of any of the flags
|
||
/// MK_CONTROL, MK_SHIFT, MK_ALT, MK_BUTTON, MK_LBUTTON, MK_MBUTTON, and MK_RBUTTON.
|
||
/// </param>
|
||
/// <param name="pt">A POINTL structure containing the current cursor coordinates in screen coordinates.</param>
|
||
/// <param name="pdwEffect">
|
||
/// On input, pointer to the value of the pdwEffect parameter of the DoDragDrop function. On return, must contain one of the
|
||
/// DROPEFFECT flags, which indicates what the result of the drop operation would be.
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>This method returns S_OK on success. Other possible values include the following.</para>
|
||
/// <list type="table">
|
||
/// <listheader>
|
||
/// <term>Return code</term>
|
||
/// <term>Description</term>
|
||
/// </listheader>
|
||
/// <item>
|
||
/// <term>E_UNEXPECTED</term>
|
||
/// <term>An unexpected error has occurred.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>E_INVALIDARG</term>
|
||
/// <term>The pdwEffect parameter is not valid.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>E_OUTOFMEMORY</term>
|
||
/// <term>There is insufficient memory available for this operation.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </returns>
|
||
/// <remarks>
|
||
/// <para>
|
||
/// You do not call this method directly. The DoDragDrop function calls this method when the user completes the drag-and-drop operation.
|
||
/// </para>
|
||
/// <para>
|
||
/// In implementing <c>Drop</c>, you must incorporate the data object into the target. Use the formats available in IDataObject,
|
||
/// available through pDataObj, along with the current state of the modifier keys to determine how the data is to be incorporated,
|
||
/// such as linking or embedding.
|
||
/// </para>
|
||
/// <para>In addition to incorporating the data, you must also clean up as you do in the IDropTarget::DragLeave method:</para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>Remove any target feedback that is currently displayed.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Release any references to the data object.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// <para>
|
||
/// You also pass the effect of this operation back to the source application through DoDragDrop, so the source application can clean
|
||
/// up after the drag-and-drop operation is complete:
|
||
/// </para>
|
||
/// <list type="bullet">
|
||
/// <item>
|
||
/// <term>Remove any source feedback that is being displayed.</term>
|
||
/// </item>
|
||
/// <item>
|
||
/// <term>Make any necessary changes to the data, such as removing the data if the operation was a move.</term>
|
||
/// </item>
|
||
/// </list>
|
||
/// </remarks>
|
||
// https://docs.microsoft.com/en-us/windows/desktop/api/oleidl/nf-oleidl-idroptarget-drop HRESULT Drop( IDataObject *pDataObj, DWORD
|
||
// grfKeyState, POINTL pt, DWORD *pdwEffect );
|
||
[PreserveSig]
|
||
public virtual extern HRESULT Drop([In] IDataObject pDataObj, [In] MouseButtonState grfKeyState, [In] POINT pt, [In, Out] ref DROPEFFECT pdwEffect);
|
||
}
|
||
|
||
/// <summary>CLSID_PhotoAcquireAutoPlayHWEventHandler</summary>
|
||
[ComImport, ClassInterface(ClassInterfaceType.None), Guid("00F2B433-44E4-4D88-B2B0-2698A0A91DBA")]
|
||
public class PhotoAcquireAutoPlayHWEventHandler : IHWEventHandler
|
||
{
|
||
/// <summary>Initializes an object that contains an implementation of the IHWEventHandler interface.</summary>
|
||
/// <param name="pszParams">
|
||
/// <para>Type: <c>LPCWSTR</c></para>
|
||
/// <para>A pointer to a string buffer that contains the string from the following registry value.</para>
|
||
/// <para>
|
||
/// <c>HKEY_LOCAL_MACHINE</c><c>Software</c><c>Microsoft</c><c>Windows</c><c>CurrentVersion</c><c>Explorer</c><c>AutoPlayHandlers</c><c>Handlers</c>
|
||
/// HandlerName <c>InitCmdLine</c> = string
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>Type: <c>HRESULT</c></para>
|
||
/// <para>If this method succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
|
||
/// </returns>
|
||
/// <remarks>This method receives the registry string stored in the InitCmdLine value under the</remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/shobjidl/nf-shobjidl-ihweventhandler-initialize HRESULT Initialize( LPCWSTR
|
||
// pszParams );
|
||
[PreserveSig]
|
||
public virtual extern HRESULT Initialize([MarshalAs(UnmanagedType.LPWStr)] string pszParams);
|
||
|
||
/// <summary>Handles AutoPlay device events for which there is no content of the type the application is registered to handle.</summary>
|
||
/// <param name="pszDeviceID">
|
||
/// <para>Type: <c>LPCWSTR</c></para>
|
||
/// <para>A pointer to a string buffer that contains the device ID.</para>
|
||
/// </param>
|
||
/// <param name="pszAltDeviceID">
|
||
/// <para>Type: <c>LPCWSTR</c></para>
|
||
/// <para>
|
||
/// A pointer to a string buffer that contains the alternate device ID. The alternate device ID is more human-readable than the
|
||
/// primary device ID.
|
||
/// </para>
|
||
/// </param>
|
||
/// <param name="pszEventType">
|
||
/// <para>Type: <c>LPCWSTR</c></para>
|
||
/// <para>
|
||
/// A pointer to a string buffer that contains the event type. The event types include DeviceArrival, DeviceRemoval, MediaArrival,
|
||
/// and MediaRemoval.
|
||
/// </para>
|
||
/// </param>
|
||
/// <returns>
|
||
/// <para>Type: <c>HRESULT</c></para>
|
||
/// <para>If this method succeeds, it returns <c>S_OK</c>. Otherwise, it returns an <c>HRESULT</c> error code.</para>
|
||
/// </returns>
|
||
/// <remarks>The event types are not C/C++ language constants; they are literal text strings.</remarks>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/shobjidl/nf-shobjidl-ihweventhandler-handleevent HRESULT HandleEvent( LPCWSTR
|
||
// pszDeviceID, LPCWSTR pszAltDeviceID, LPCWSTR pszEventType );
|
||
[PreserveSig]
|
||
public virtual extern HRESULT HandleEvent([MarshalAs(UnmanagedType.LPWStr)] string pszDeviceID,
|
||
[MarshalAs(UnmanagedType.LPWStr)] string pszAltDeviceID, [MarshalAs(UnmanagedType.LPWStr)] string pszEventType);
|
||
|
||
/// <summary>Not implemented.</summary>
|
||
/// <param name="pszDeviceID">This parameter is unused.</param>
|
||
/// <param name="pszAltDeviceID">This parameter is unused.</param>
|
||
/// <param name="pszEventType">This parameter is unused.</param>
|
||
/// <param name="pszContentTypeHandler">This parameter is unused.</param>
|
||
/// <param name="pdataobject">This parameter is unused.</param>
|
||
/// <returns>This method does not return a value.</returns>
|
||
// https://docs.microsoft.com/en-us/windows/win32/api/shobjidl/nf-shobjidl-ihweventhandler-handleeventwithcontent HRESULT
|
||
// HandleEventWithContent( LPCWSTR pszDeviceID, LPCWSTR pszAltDeviceID, LPCWSTR pszEventType, LPCWSTR pszContentTypeHandler,
|
||
// IDataObject *pdataobject );
|
||
[PreserveSig]
|
||
public virtual extern HRESULT HandleEventWithContent([MarshalAs(UnmanagedType.LPWStr)] string pszDeviceID,
|
||
[MarshalAs(UnmanagedType.LPWStr)] string pszAltDeviceID, [MarshalAs(UnmanagedType.LPWStr)] string pszEventType,
|
||
[MarshalAs(UnmanagedType.LPWStr)] string pszContentTypeHandler, IDataObject pdataobject);
|
||
}
|
||
|
||
/// <summary>CLSID_PhotoAcquireDeviceSelectionDialog</summary>
|
||
[ComImport, ClassInterface(ClassInterfaceType.None), Guid("00F29A34-B8A1-482C-BCF8-3AC7B0FE8F62")]
|
||
public class PhotoAcquireDeviceSelectionDialog { }
|
||
|
||
/// <summary>CLSID_PhotoAcquireOptionsDialog</summary>
|
||
[ComImport, Guid("00F210A1-62F0-438B-9F7E-9618D72A1831"), ClassInterface(ClassInterfaceType.None)]
|
||
public class PhotoAcquireOptionsDialog { }
|
||
|
||
/// <summary>CLSID_PhotoProgressDialog</summary>
|
||
[ComImport, Guid("00F24CA0-748F-4E8A-894F-0E0357C6799F"), ClassInterface(ClassInterfaceType.None)]
|
||
public class PhotoProgressDialog { }
|
||
} |