midnadimple
/
zigwin32
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
zigwin32/win32/media/picture_acquisition.zig

1721 lines
96 KiB
Zig
Raw Permalink Blame History

//! NOTE: this file is autogenerated, DO NOT MODIFY
//--------------------------------------------------------------------------------
// Section: Constants (38)
//--------------------------------------------------------------------------------
pub const PKEY_PhotoAcquire_RelativePathname = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 2 };
pub const PKEY_PhotoAcquire_FinalFilename = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 3 };
pub const PKEY_PhotoAcquire_GroupTag = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 4 };
pub const PKEY_PhotoAcquire_TransferResult = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 5 };
pub const PKEY_PhotoAcquire_OriginalFilename = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 6 };
pub const PKEY_PhotoAcquire_CameraSequenceNumber = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 7 };
pub const PKEY_PhotoAcquire_IntermediateFile = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 8 };
pub const PKEY_PhotoAcquire_SkipImport = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 9 };
pub const PKEY_PhotoAcquire_DuplicateDetectionID = PROPERTYKEY { .fmtid = Guid.initString("00f23377-7ac6-4b7a-8443-345e731fa57a"), .pid = 10 };
pub const PROGRESS_INDETERMINATE = @as(i32, -1);
pub const PHOTOACQ_ERROR_RESTART_REQUIRED = @import("../zig.zig").typedConst(HRESULT, @as(i32, -2147180543));
pub const PHOTOACQ_RUN_DEFAULT = @as(u32, 0);
pub const PHOTOACQ_NO_GALLERY_LAUNCH = @as(u32, 1);
pub const PHOTOACQ_DISABLE_AUTO_ROTATE = @as(u32, 2);
pub const PHOTOACQ_DISABLE_PLUGINS = @as(u32, 4);
pub const PHOTOACQ_DISABLE_GROUP_TAG_PROMPT = @as(u32, 8);
pub const PHOTOACQ_DISABLE_DB_INTEGRATION = @as(u32, 16);
pub const PHOTOACQ_DELETE_AFTER_ACQUIRE = @as(u32, 32);
pub const PHOTOACQ_DISABLE_DUPLICATE_DETECTION = @as(u32, 64);
pub const PHOTOACQ_ENABLE_THUMBNAIL_CACHING = @as(u32, 128);
pub const PHOTOACQ_DISABLE_METADATA_WRITE = @as(u32, 256);
pub const PHOTOACQ_DISABLE_THUMBNAIL_PROGRESS = @as(u32, 512);
pub const PHOTOACQ_DISABLE_SETTINGS_LINK = @as(u32, 1024);
pub const PHOTOACQ_ABORT_ON_SETTINGS_UPDATE = @as(u32, 2048);
pub const PHOTOACQ_IMPORT_VIDEO_AS_MULTIPLE_FILES = @as(u32, 4096);
pub const DSF_WPD_DEVICES = @as(u32, 1);
pub const DSF_WIA_CAMERAS = @as(u32, 2);
pub const DSF_WIA_SCANNERS = @as(u32, 4);
pub const DSF_STI_DEVICES = @as(u32, 8);
pub const DSF_TWAIN_DEVICES = @as(u32, 16);
pub const DSF_FS_DEVICES = @as(u32, 32);
pub const DSF_DV_DEVICES = @as(u32, 64);
pub const DSF_ALL_DEVICES = @as(u32, 65535);
pub const DSF_CPL_MODE = @as(u32, 65536);
pub const DSF_SHOW_OFFLINE = @as(u32, 131072);
pub const PAPS_PRESAVE = @as(u32, 0);
pub const PAPS_POSTSAVE = @as(u32, 1);
pub const PAPS_CLEANUP = @as(u32, 2);
//--------------------------------------------------------------------------------
// Section: Types (23)
//--------------------------------------------------------------------------------
const CLSID_PhotoAcquire_Value = Guid.initString("00f26e02-e9f2-4a9f-9fdd-5a962fb26a98");
pub const CLSID_PhotoAcquire = &CLSID_PhotoAcquire_Value;
const CLSID_PhotoAcquireAutoPlayDropTarget_Value = Guid.initString("00f20eb5-8fd6-4d9d-b75e-36801766c8f1");
pub const CLSID_PhotoAcquireAutoPlayDropTarget = &CLSID_PhotoAcquireAutoPlayDropTarget_Value;
const CLSID_PhotoAcquireAutoPlayHWEventHandler_Value = Guid.initString("00f2b433-44e4-4d88-b2b0-2698a0a91dba");
pub const CLSID_PhotoAcquireAutoPlayHWEventHandler = &CLSID_PhotoAcquireAutoPlayHWEventHandler_Value;
const CLSID_PhotoAcquireOptionsDialog_Value = Guid.initString("00f210a1-62f0-438b-9f7e-9618d72a1831");
pub const CLSID_PhotoAcquireOptionsDialog = &CLSID_PhotoAcquireOptionsDialog_Value;
const CLSID_PhotoProgressDialog_Value = Guid.initString("00f24ca0-748f-4e8a-894f-0e0357c6799f");
pub const CLSID_PhotoProgressDialog = &CLSID_PhotoProgressDialog_Value;
const CLSID_PhotoAcquireDeviceSelectionDialog_Value = Guid.initString("00f29a34-b8a1-482c-bcf8-3ac7b0fe8f62");
pub const CLSID_PhotoAcquireDeviceSelectionDialog = &CLSID_PhotoAcquireDeviceSelectionDialog_Value;
const IID_IPhotoAcquireItem_Value = Guid.initString("00f21c97-28bf-4c02-b842-5e4e90139a30");
pub const IID_IPhotoAcquireItem = &IID_IPhotoAcquireItem_Value;
pub const IPhotoAcquireItem = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetItemName: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
pbstrItemName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
pbstrItemName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetThumbnail: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
sizeThumbnail: SIZE,
phbmpThumbnail: ?*?HBITMAP,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
sizeThumbnail: SIZE,
phbmpThumbnail: ?*?HBITMAP,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetProperty: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
key: ?*const PROPERTYKEY,
pv: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
key: ?*const PROPERTYKEY,
pv: ?*PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetProperty: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
key: ?*const PROPERTYKEY,
pv: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
key: ?*const PROPERTYKEY,
pv: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetStream: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
ppStream: ?*?*IStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
ppStream: ?*?*IStream,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
CanDelete: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
pfCanDelete: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
pfCanDelete: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
Delete: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetSubItemCount: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
pnCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
pnCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetSubItemAt: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireItem,
nItemIndex: u32,
ppPhotoAcquireItem: ?*?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireItem,
nItemIndex: u32,
ppPhotoAcquireItem: ?*?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_GetItemName(self: *const T, pbstrItemName: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).GetItemName(@as(*const IPhotoAcquireItem, @ptrCast(self)), pbstrItemName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_GetThumbnail(self: *const T, sizeThumbnail: SIZE, phbmpThumbnail: ?*?HBITMAP) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).GetThumbnail(@as(*const IPhotoAcquireItem, @ptrCast(self)), sizeThumbnail, phbmpThumbnail);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_GetProperty(self: *const T, key: ?*const PROPERTYKEY, pv: ?*PROPVARIANT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IPhotoAcquireItem, @ptrCast(self)), key, pv);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_SetProperty(self: *const T, key: ?*const PROPERTYKEY, pv: ?*const PROPVARIANT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).SetProperty(@as(*const IPhotoAcquireItem, @ptrCast(self)), key, pv);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_GetStream(self: *const T, ppStream: ?*?*IStream) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).GetStream(@as(*const IPhotoAcquireItem, @ptrCast(self)), ppStream);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_CanDelete(self: *const T, pfCanDelete: ?*BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).CanDelete(@as(*const IPhotoAcquireItem, @ptrCast(self)), pfCanDelete);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_Delete(self: *const T) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).Delete(@as(*const IPhotoAcquireItem, @ptrCast(self)));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_GetSubItemCount(self: *const T, pnCount: ?*u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).GetSubItemCount(@as(*const IPhotoAcquireItem, @ptrCast(self)), pnCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireItem_GetSubItemAt(self: *const T, nItemIndex: u32, ppPhotoAcquireItem: ?*?*IPhotoAcquireItem) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireItem.VTable, @ptrCast(self.vtable)).GetSubItemAt(@as(*const IPhotoAcquireItem, @ptrCast(self)), nItemIndex, ppPhotoAcquireItem);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const USER_INPUT_STRING_TYPE = enum(i32) {
DEFAULT = 0,
PATH_ELEMENT = 1,
};
pub const USER_INPUT_DEFAULT = USER_INPUT_STRING_TYPE.DEFAULT;
pub const USER_INPUT_PATH_ELEMENT = USER_INPUT_STRING_TYPE.PATH_ELEMENT;
const IID_IUserInputString_Value = Guid.initString("00f243a1-205b-45ba-ae26-abbc53aa7a6f");
pub const IID_IUserInputString = &IID_IUserInputString_Value;
pub const IUserInputString = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetSubmitButtonText: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
pbstrSubmitButtonText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
pbstrSubmitButtonText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetPrompt: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
pbstrPromptTitle: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
pbstrPromptTitle: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetStringId: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
pbstrStringId: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
pbstrStringId: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetStringType: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
pnStringType: ?*USER_INPUT_STRING_TYPE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
pnStringType: ?*USER_INPUT_STRING_TYPE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetTooltipText: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
pbstrTooltipText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
pbstrTooltipText: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetMaxLength: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
pcchMaxLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
pcchMaxLength: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetDefault: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
pbstrDefault: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
pbstrDefault: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetMruCount: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
pnMruCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
pnMruCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetMruEntryAt: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
nIndex: u32,
pbstrMruEntry: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
nIndex: u32,
pbstrMruEntry: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetImage: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IUserInputString,
nSize: u32,
phBitmap: ?*?HBITMAP,
phIcon: ?*?HICON,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IUserInputString,
nSize: u32,
phBitmap: ?*?HBITMAP,
phIcon: ?*?HICON,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetSubmitButtonText(self: *const T, pbstrSubmitButtonText: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetSubmitButtonText(@as(*const IUserInputString, @ptrCast(self)), pbstrSubmitButtonText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetPrompt(self: *const T, pbstrPromptTitle: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetPrompt(@as(*const IUserInputString, @ptrCast(self)), pbstrPromptTitle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetStringId(self: *const T, pbstrStringId: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetStringId(@as(*const IUserInputString, @ptrCast(self)), pbstrStringId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetStringType(self: *const T, pnStringType: ?*USER_INPUT_STRING_TYPE) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetStringType(@as(*const IUserInputString, @ptrCast(self)), pnStringType);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetTooltipText(self: *const T, pbstrTooltipText: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetTooltipText(@as(*const IUserInputString, @ptrCast(self)), pbstrTooltipText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetMaxLength(self: *const T, pcchMaxLength: ?*u32) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetMaxLength(@as(*const IUserInputString, @ptrCast(self)), pcchMaxLength);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetDefault(self: *const T, pbstrDefault: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetDefault(@as(*const IUserInputString, @ptrCast(self)), pbstrDefault);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetMruCount(self: *const T, pnMruCount: ?*u32) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetMruCount(@as(*const IUserInputString, @ptrCast(self)), pnMruCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetMruEntryAt(self: *const T, nIndex: u32, pbstrMruEntry: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetMruEntryAt(@as(*const IUserInputString, @ptrCast(self)), nIndex, pbstrMruEntry);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IUserInputString_GetImage(self: *const T, nSize: u32, phBitmap: ?*?HBITMAP, phIcon: ?*?HICON) callconv(.Inline) HRESULT {
return @as(*const IUserInputString.VTable, @ptrCast(self.vtable)).GetImage(@as(*const IUserInputString, @ptrCast(self)), nSize, phBitmap, phIcon);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const ERROR_ADVISE_MESSAGE_TYPE = enum(i32) {
SKIPRETRYCANCEL = 0,
RETRYCANCEL = 1,
YESNO = 2,
OK = 3,
};
pub const PHOTOACQUIRE_ERROR_SKIPRETRYCANCEL = ERROR_ADVISE_MESSAGE_TYPE.SKIPRETRYCANCEL;
pub const PHOTOACQUIRE_ERROR_RETRYCANCEL = ERROR_ADVISE_MESSAGE_TYPE.RETRYCANCEL;
pub const PHOTOACQUIRE_ERROR_YESNO = ERROR_ADVISE_MESSAGE_TYPE.YESNO;
pub const PHOTOACQUIRE_ERROR_OK = ERROR_ADVISE_MESSAGE_TYPE.OK;
pub const ERROR_ADVISE_RESULT = enum(i32) {
YES = 0,
NO = 1,
OK = 2,
SKIP = 3,
SKIP_ALL = 4,
RETRY = 5,
ABORT = 6,
};
pub const PHOTOACQUIRE_RESULT_YES = ERROR_ADVISE_RESULT.YES;
pub const PHOTOACQUIRE_RESULT_NO = ERROR_ADVISE_RESULT.NO;
pub const PHOTOACQUIRE_RESULT_OK = ERROR_ADVISE_RESULT.OK;
pub const PHOTOACQUIRE_RESULT_SKIP = ERROR_ADVISE_RESULT.SKIP;
pub const PHOTOACQUIRE_RESULT_SKIP_ALL = ERROR_ADVISE_RESULT.SKIP_ALL;
pub const PHOTOACQUIRE_RESULT_RETRY = ERROR_ADVISE_RESULT.RETRY;
pub const PHOTOACQUIRE_RESULT_ABORT = ERROR_ADVISE_RESULT.ABORT;
const IID_IPhotoAcquireProgressCB_Value = Guid.initString("00f2ce1e-935e-4248-892c-130f32c45cb4");
pub const IID_IPhotoAcquireProgressCB = &IID_IPhotoAcquireProgressCB_Value;
pub const IPhotoAcquireProgressCB = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Cancelled: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
pfCancelled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
pfCancelled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
StartEnumeration: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
FoundItem: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
EndEnumeration: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
StartTransfer: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
StartItemTransfer: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
nItemIndex: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
nItemIndex: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
DirectoryCreated: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
pszDirectory: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
pszDirectory: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
UpdateTransferPercent: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
fOverall: BOOL,
nPercent: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
fOverall: BOOL,
nPercent: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
EndItemTransfer: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
nItemIndex: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
nItemIndex: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
EndTransfer: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
StartDelete: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
StartItemDelete: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
nItemIndex: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
nItemIndex: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
UpdateDeletePercent: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
nPercent: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
nPercent: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
EndItemDelete: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
nItemIndex: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
nItemIndex: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
EndDelete: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
EndSession: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetDeleteAfterAcquire: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
pfDeleteAfterAcquire: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
pfDeleteAfterAcquire: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
ErrorAdvise: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
pszErrorMessage: ?[*:0]const u16,
nMessageType: ERROR_ADVISE_MESSAGE_TYPE,
pnErrorAdviseResult: ?*ERROR_ADVISE_RESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
hr: HRESULT,
pszErrorMessage: ?[*:0]const u16,
nMessageType: ERROR_ADVISE_MESSAGE_TYPE,
pnErrorAdviseResult: ?*ERROR_ADVISE_RESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetUserInput: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireProgressCB,
riidType: ?*const Guid,
pUnknown: ?*IUnknown,
pPropVarResult: ?*PROPVARIANT,
pPropVarDefault: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireProgressCB,
riidType: ?*const Guid,
pUnknown: ?*IUnknown,
pPropVarResult: ?*PROPVARIANT,
pPropVarDefault: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_Cancelled(self: *const T, pfCancelled: ?*BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).Cancelled(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), pfCancelled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_StartEnumeration(self: *const T, pPhotoAcquireSource: ?*IPhotoAcquireSource) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).StartEnumeration(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), pPhotoAcquireSource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_FoundItem(self: *const T, pPhotoAcquireItem: ?*IPhotoAcquireItem) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).FoundItem(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), pPhotoAcquireItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_EndEnumeration(self: *const T, hr: HRESULT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).EndEnumeration(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), hr);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_StartTransfer(self: *const T, pPhotoAcquireSource: ?*IPhotoAcquireSource) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).StartTransfer(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), pPhotoAcquireSource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_StartItemTransfer(self: *const T, nItemIndex: u32, pPhotoAcquireItem: ?*IPhotoAcquireItem) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).StartItemTransfer(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), nItemIndex, pPhotoAcquireItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_DirectoryCreated(self: *const T, pszDirectory: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).DirectoryCreated(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), pszDirectory);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_UpdateTransferPercent(self: *const T, fOverall: BOOL, nPercent: u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).UpdateTransferPercent(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), fOverall, nPercent);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_EndItemTransfer(self: *const T, nItemIndex: u32, pPhotoAcquireItem: ?*IPhotoAcquireItem, hr: HRESULT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).EndItemTransfer(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), nItemIndex, pPhotoAcquireItem, hr);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_EndTransfer(self: *const T, hr: HRESULT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).EndTransfer(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), hr);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_StartDelete(self: *const T, pPhotoAcquireSource: ?*IPhotoAcquireSource) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).StartDelete(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), pPhotoAcquireSource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_StartItemDelete(self: *const T, nItemIndex: u32, pPhotoAcquireItem: ?*IPhotoAcquireItem) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).StartItemDelete(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), nItemIndex, pPhotoAcquireItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_UpdateDeletePercent(self: *const T, nPercent: u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).UpdateDeletePercent(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), nPercent);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_EndItemDelete(self: *const T, nItemIndex: u32, pPhotoAcquireItem: ?*IPhotoAcquireItem, hr: HRESULT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).EndItemDelete(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), nItemIndex, pPhotoAcquireItem, hr);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_EndDelete(self: *const T, hr: HRESULT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).EndDelete(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), hr);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_EndSession(self: *const T, hr: HRESULT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).EndSession(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), hr);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_GetDeleteAfterAcquire(self: *const T, pfDeleteAfterAcquire: ?*BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).GetDeleteAfterAcquire(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), pfDeleteAfterAcquire);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_ErrorAdvise(self: *const T, hr: HRESULT, pszErrorMessage: ?[*:0]const u16, nMessageType: ERROR_ADVISE_MESSAGE_TYPE, pnErrorAdviseResult: ?*ERROR_ADVISE_RESULT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).ErrorAdvise(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), hr, pszErrorMessage, nMessageType, pnErrorAdviseResult);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireProgressCB_GetUserInput(self: *const T, riidType: ?*const Guid, pUnknown: ?*IUnknown, pPropVarResult: ?*PROPVARIANT, pPropVarDefault: ?*const PROPVARIANT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireProgressCB.VTable, @ptrCast(self.vtable)).GetUserInput(@as(*const IPhotoAcquireProgressCB, @ptrCast(self)), riidType, pUnknown, pPropVarResult, pPropVarDefault);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IPhotoProgressActionCB_Value = Guid.initString("00f242d0-b206-4e7d-b4c1-4755bcbb9c9f");
pub const IID_IPhotoProgressActionCB = &IID_IPhotoProgressActionCB_Value;
pub const IPhotoProgressActionCB = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
DoAction: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressActionCB,
hWndParent: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressActionCB,
hWndParent: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressActionCB_DoAction(self: *const T, hWndParent: ?HWND) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressActionCB.VTable, @ptrCast(self.vtable)).DoAction(@as(*const IPhotoProgressActionCB, @ptrCast(self)), hWndParent);
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const PROGRESS_DIALOG_IMAGE_TYPE = enum(i32) {
ICON_SMALL = 0,
ICON_LARGE = 1,
ICON_THUMBNAIL = 2,
BITMAP_THUMBNAIL = 3,
};
pub const PROGRESS_DIALOG_ICON_SMALL = PROGRESS_DIALOG_IMAGE_TYPE.ICON_SMALL;
pub const PROGRESS_DIALOG_ICON_LARGE = PROGRESS_DIALOG_IMAGE_TYPE.ICON_LARGE;
pub const PROGRESS_DIALOG_ICON_THUMBNAIL = PROGRESS_DIALOG_IMAGE_TYPE.ICON_THUMBNAIL;
pub const PROGRESS_DIALOG_BITMAP_THUMBNAIL = PROGRESS_DIALOG_IMAGE_TYPE.BITMAP_THUMBNAIL;
pub const PROGRESS_DIALOG_CHECKBOX_ID = enum(i32) {
T = 0,
};
pub const PROGRESS_DIALOG_CHECKBOX_ID_DEFAULT = PROGRESS_DIALOG_CHECKBOX_ID.T;
const IID_IPhotoProgressDialog_Value = Guid.initString("00f246f9-0750-4f08-9381-2cd8e906a4ae");
pub const IID_IPhotoProgressDialog = &IID_IPhotoProgressDialog_Value;
pub const IPhotoProgressDialog = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Create: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
hwndParent: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
hwndParent: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetWindow: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
phwndProgressDialog: ?*?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
phwndProgressDialog: ?*?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
Destroy: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetTitle: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
pszTitle: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
pszTitle: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
ShowCheckbox: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
fShow: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
fShow: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetCheckboxText: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
pszCheckboxText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
pszCheckboxText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetCheckboxCheck: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
fChecked: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
fChecked: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetCheckboxTooltip: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
pszCheckboxTooltipText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
pszCheckboxTooltipText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
IsCheckboxChecked: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
pfChecked: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID,
pfChecked: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetCaption: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
pszTitle: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
pszTitle: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetImage: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
nImageType: PROGRESS_DIALOG_IMAGE_TYPE,
hIcon: ?HICON,
hBitmap: ?HBITMAP,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
nImageType: PROGRESS_DIALOG_IMAGE_TYPE,
hIcon: ?HICON,
hBitmap: ?HBITMAP,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetPercentComplete: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
nPercent: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
nPercent: i32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetProgressText: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
pszProgressText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
pszProgressText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetActionLinkCallback: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
pPhotoProgressActionCB: ?*IPhotoProgressActionCB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
pPhotoProgressActionCB: ?*IPhotoProgressActionCB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetActionLinkText: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
pszCaption: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
pszCaption: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
ShowActionLink: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
fShow: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
fShow: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
IsCancelled: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
pfCancelled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
pfCancelled: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetUserInput: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoProgressDialog,
riidType: ?*const Guid,
pUnknown: ?*IUnknown,
pPropVarResult: ?*PROPVARIANT,
pPropVarDefault: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoProgressDialog,
riidType: ?*const Guid,
pUnknown: ?*IUnknown,
pPropVarResult: ?*PROPVARIANT,
pPropVarDefault: ?*const PROPVARIANT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_Create(self: *const T, hwndParent: ?HWND) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).Create(@as(*const IPhotoProgressDialog, @ptrCast(self)), hwndParent);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_GetWindow(self: *const T, phwndProgressDialog: ?*?HWND) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).GetWindow(@as(*const IPhotoProgressDialog, @ptrCast(self)), phwndProgressDialog);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_Destroy(self: *const T) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).Destroy(@as(*const IPhotoProgressDialog, @ptrCast(self)));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetTitle(self: *const T, pszTitle: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetTitle(@as(*const IPhotoProgressDialog, @ptrCast(self)), pszTitle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_ShowCheckbox(self: *const T, nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID, fShow: BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).ShowCheckbox(@as(*const IPhotoProgressDialog, @ptrCast(self)), nCheckboxId, fShow);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetCheckboxText(self: *const T, nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID, pszCheckboxText: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetCheckboxText(@as(*const IPhotoProgressDialog, @ptrCast(self)), nCheckboxId, pszCheckboxText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetCheckboxCheck(self: *const T, nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID, fChecked: BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetCheckboxCheck(@as(*const IPhotoProgressDialog, @ptrCast(self)), nCheckboxId, fChecked);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetCheckboxTooltip(self: *const T, nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID, pszCheckboxTooltipText: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetCheckboxTooltip(@as(*const IPhotoProgressDialog, @ptrCast(self)), nCheckboxId, pszCheckboxTooltipText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_IsCheckboxChecked(self: *const T, nCheckboxId: PROGRESS_DIALOG_CHECKBOX_ID, pfChecked: ?*BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).IsCheckboxChecked(@as(*const IPhotoProgressDialog, @ptrCast(self)), nCheckboxId, pfChecked);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetCaption(self: *const T, pszTitle: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetCaption(@as(*const IPhotoProgressDialog, @ptrCast(self)), pszTitle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetImage(self: *const T, nImageType: PROGRESS_DIALOG_IMAGE_TYPE, hIcon: ?HICON, hBitmap: ?HBITMAP) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetImage(@as(*const IPhotoProgressDialog, @ptrCast(self)), nImageType, hIcon, hBitmap);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetPercentComplete(self: *const T, nPercent: i32) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetPercentComplete(@as(*const IPhotoProgressDialog, @ptrCast(self)), nPercent);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetProgressText(self: *const T, pszProgressText: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetProgressText(@as(*const IPhotoProgressDialog, @ptrCast(self)), pszProgressText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetActionLinkCallback(self: *const T, pPhotoProgressActionCB: ?*IPhotoProgressActionCB) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetActionLinkCallback(@as(*const IPhotoProgressDialog, @ptrCast(self)), pPhotoProgressActionCB);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_SetActionLinkText(self: *const T, pszCaption: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).SetActionLinkText(@as(*const IPhotoProgressDialog, @ptrCast(self)), pszCaption);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_ShowActionLink(self: *const T, fShow: BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).ShowActionLink(@as(*const IPhotoProgressDialog, @ptrCast(self)), fShow);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_IsCancelled(self: *const T, pfCancelled: ?*BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).IsCancelled(@as(*const IPhotoProgressDialog, @ptrCast(self)), pfCancelled);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoProgressDialog_GetUserInput(self: *const T, riidType: ?*const Guid, pUnknown: ?*IUnknown, pPropVarResult: ?*PROPVARIANT, pPropVarDefault: ?*const PROPVARIANT) callconv(.Inline) HRESULT {
return @as(*const IPhotoProgressDialog.VTable, @ptrCast(self.vtable)).GetUserInput(@as(*const IPhotoProgressDialog, @ptrCast(self)), riidType, pUnknown, pPropVarResult, pPropVarDefault);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IPhotoAcquireSource_Value = Guid.initString("00f2c703-8613-4282-a53b-6ec59c5883ac");
pub const IID_IPhotoAcquireSource = &IID_IPhotoAcquireSource_Value;
pub const IPhotoAcquireSource = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
GetFriendlyName: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSource,
pbstrFriendlyName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSource,
pbstrFriendlyName: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetDeviceIcons: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSource,
nSize: u32,
phLargeIcon: ?*?HICON,
phSmallIcon: ?*?HICON,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSource,
nSize: u32,
phLargeIcon: ?*?HICON,
phSmallIcon: ?*?HICON,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
InitializeItemList: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSource,
fForceEnumeration: BOOL,
pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB,
pnItemCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSource,
fForceEnumeration: BOOL,
pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB,
pnItemCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetItemCount: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSource,
pnItemCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSource,
pnItemCount: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetItemAt: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSource,
nIndex: u32,
ppPhotoAcquireItem: ?*?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSource,
nIndex: u32,
ppPhotoAcquireItem: ?*?*IPhotoAcquireItem,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetPhotoAcquireSettings: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSource,
ppPhotoAcquireSettings: ?*?*IPhotoAcquireSettings,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSource,
ppPhotoAcquireSettings: ?*?*IPhotoAcquireSettings,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetDeviceId: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSource,
pbstrDeviceId: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSource,
pbstrDeviceId: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
BindToObject: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSource,
riid: ?*const Guid,
ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSource,
riid: ?*const Guid,
ppv: ?*?*anyopaque,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSource_GetFriendlyName(self: *const T, pbstrFriendlyName: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSource.VTable, @ptrCast(self.vtable)).GetFriendlyName(@as(*const IPhotoAcquireSource, @ptrCast(self)), pbstrFriendlyName);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSource_GetDeviceIcons(self: *const T, nSize: u32, phLargeIcon: ?*?HICON, phSmallIcon: ?*?HICON) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSource.VTable, @ptrCast(self.vtable)).GetDeviceIcons(@as(*const IPhotoAcquireSource, @ptrCast(self)), nSize, phLargeIcon, phSmallIcon);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSource_InitializeItemList(self: *const T, fForceEnumeration: BOOL, pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB, pnItemCount: ?*u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSource.VTable, @ptrCast(self.vtable)).InitializeItemList(@as(*const IPhotoAcquireSource, @ptrCast(self)), fForceEnumeration, pPhotoAcquireProgressCB, pnItemCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSource_GetItemCount(self: *const T, pnItemCount: ?*u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSource.VTable, @ptrCast(self.vtable)).GetItemCount(@as(*const IPhotoAcquireSource, @ptrCast(self)), pnItemCount);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSource_GetItemAt(self: *const T, nIndex: u32, ppPhotoAcquireItem: ?*?*IPhotoAcquireItem) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSource.VTable, @ptrCast(self.vtable)).GetItemAt(@as(*const IPhotoAcquireSource, @ptrCast(self)), nIndex, ppPhotoAcquireItem);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSource_GetPhotoAcquireSettings(self: *const T, ppPhotoAcquireSettings: ?*?*IPhotoAcquireSettings) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSource.VTable, @ptrCast(self.vtable)).GetPhotoAcquireSettings(@as(*const IPhotoAcquireSource, @ptrCast(self)), ppPhotoAcquireSettings);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSource_GetDeviceId(self: *const T, pbstrDeviceId: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSource.VTable, @ptrCast(self.vtable)).GetDeviceId(@as(*const IPhotoAcquireSource, @ptrCast(self)), pbstrDeviceId);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSource_BindToObject(self: *const T, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSource.VTable, @ptrCast(self.vtable)).BindToObject(@as(*const IPhotoAcquireSource, @ptrCast(self)), riid, ppv);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IPhotoAcquire_Value = Guid.initString("00f23353-e31b-4955-a8ad-ca5ebf31e2ce");
pub const IID_IPhotoAcquire = &IID_IPhotoAcquire_Value;
pub const IPhotoAcquire = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
CreatePhotoSource: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquire,
pszDevice: ?[*:0]const u16,
ppPhotoAcquireSource: ?*?*IPhotoAcquireSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquire,
pszDevice: ?[*:0]const u16,
ppPhotoAcquireSource: ?*?*IPhotoAcquireSource,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
Acquire: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquire,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
fShowProgress: BOOL,
hWndParent: ?HWND,
pszApplicationName: ?[*:0]const u16,
pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquire,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
fShowProgress: BOOL,
hWndParent: ?HWND,
pszApplicationName: ?[*:0]const u16,
pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
EnumResults: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquire,
ppEnumFilePaths: ?*?*IEnumString,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquire,
ppEnumFilePaths: ?*?*IEnumString,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquire_CreatePhotoSource(self: *const T, pszDevice: ?[*:0]const u16, ppPhotoAcquireSource: ?*?*IPhotoAcquireSource) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquire.VTable, @ptrCast(self.vtable)).CreatePhotoSource(@as(*const IPhotoAcquire, @ptrCast(self)), pszDevice, ppPhotoAcquireSource);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquire_Acquire(self: *const T, pPhotoAcquireSource: ?*IPhotoAcquireSource, fShowProgress: BOOL, hWndParent: ?HWND, pszApplicationName: ?[*:0]const u16, pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquire.VTable, @ptrCast(self.vtable)).Acquire(@as(*const IPhotoAcquire, @ptrCast(self)), pPhotoAcquireSource, fShowProgress, hWndParent, pszApplicationName, pPhotoAcquireProgressCB);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquire_EnumResults(self: *const T, ppEnumFilePaths: ?*?*IEnumString) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquire.VTable, @ptrCast(self.vtable)).EnumResults(@as(*const IPhotoAcquire, @ptrCast(self)), ppEnumFilePaths);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IPhotoAcquireSettings_Value = Guid.initString("00f2b868-dd67-487c-9553-049240767e91");
pub const IID_IPhotoAcquireSettings = &IID_IPhotoAcquireSettings_Value;
pub const IPhotoAcquireSettings = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
InitializeFromRegistry: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pszRegistryKey: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pszRegistryKey: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetFlags: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
dwPhotoAcquireFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
dwPhotoAcquireFlags: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetOutputFilenameTemplate: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pszTemplate: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pszTemplate: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetSequencePaddingWidth: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
dwWidth: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
dwWidth: u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetSequenceZeroPadding: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
fZeroPad: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
fZeroPad: BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetGroupTag: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pszGroupTag: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pszGroupTag: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetAcquisitionTime: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pftAcquisitionTime: ?*const FILETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pftAcquisitionTime: ?*const FILETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetFlags: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pdwPhotoAcquireFlags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pdwPhotoAcquireFlags: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetOutputFilenameTemplate: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pbstrTemplate: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pbstrTemplate: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetSequencePaddingWidth: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pdwWidth: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pdwWidth: ?*u32,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetSequenceZeroPadding: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pfZeroPad: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pfZeroPad: ?*BOOL,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetGroupTag: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pbstrGroupTag: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pbstrGroupTag: ?*?BSTR,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
GetAcquisitionTime: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireSettings,
pftAcquisitionTime: ?*FILETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireSettings,
pftAcquisitionTime: ?*FILETIME,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_InitializeFromRegistry(self: *const T, pszRegistryKey: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).InitializeFromRegistry(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pszRegistryKey);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_SetFlags(self: *const T, dwPhotoAcquireFlags: u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).SetFlags(@as(*const IPhotoAcquireSettings, @ptrCast(self)), dwPhotoAcquireFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_SetOutputFilenameTemplate(self: *const T, pszTemplate: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).SetOutputFilenameTemplate(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pszTemplate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_SetSequencePaddingWidth(self: *const T, dwWidth: u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).SetSequencePaddingWidth(@as(*const IPhotoAcquireSettings, @ptrCast(self)), dwWidth);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_SetSequenceZeroPadding(self: *const T, fZeroPad: BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).SetSequenceZeroPadding(@as(*const IPhotoAcquireSettings, @ptrCast(self)), fZeroPad);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_SetGroupTag(self: *const T, pszGroupTag: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).SetGroupTag(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pszGroupTag);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_SetAcquisitionTime(self: *const T, pftAcquisitionTime: ?*const FILETIME) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).SetAcquisitionTime(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pftAcquisitionTime);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_GetFlags(self: *const T, pdwPhotoAcquireFlags: ?*u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).GetFlags(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pdwPhotoAcquireFlags);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_GetOutputFilenameTemplate(self: *const T, pbstrTemplate: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).GetOutputFilenameTemplate(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pbstrTemplate);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_GetSequencePaddingWidth(self: *const T, pdwWidth: ?*u32) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).GetSequencePaddingWidth(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pdwWidth);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_GetSequenceZeroPadding(self: *const T, pfZeroPad: ?*BOOL) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).GetSequenceZeroPadding(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pfZeroPad);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_GetGroupTag(self: *const T, pbstrGroupTag: ?*?BSTR) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).GetGroupTag(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pbstrGroupTag);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireSettings_GetAcquisitionTime(self: *const T, pftAcquisitionTime: ?*FILETIME) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireSettings.VTable, @ptrCast(self.vtable)).GetAcquisitionTime(@as(*const IPhotoAcquireSettings, @ptrCast(self)), pftAcquisitionTime);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IPhotoAcquireOptionsDialog_Value = Guid.initString("00f2b3ee-bf64-47ee-89f4-4dedd79643f2");
pub const IID_IPhotoAcquireOptionsDialog = &IID_IPhotoAcquireOptionsDialog_Value;
pub const IPhotoAcquireOptionsDialog = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Initialize: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireOptionsDialog,
pszRegistryRoot: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireOptionsDialog,
pszRegistryRoot: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
Create: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireOptionsDialog,
hWndParent: ?HWND,
phWndDialog: ?*?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireOptionsDialog,
hWndParent: ?HWND,
phWndDialog: ?*?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
Destroy: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireOptionsDialog,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireOptionsDialog,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
DoModal: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireOptionsDialog,
hWndParent: ?HWND,
ppnReturnCode: ?*isize,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireOptionsDialog,
hWndParent: ?HWND,
ppnReturnCode: ?*isize,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SaveData: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireOptionsDialog,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireOptionsDialog,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireOptionsDialog_Initialize(self: *const T, pszRegistryRoot: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireOptionsDialog.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IPhotoAcquireOptionsDialog, @ptrCast(self)), pszRegistryRoot);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireOptionsDialog_Create(self: *const T, hWndParent: ?HWND, phWndDialog: ?*?HWND) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireOptionsDialog.VTable, @ptrCast(self.vtable)).Create(@as(*const IPhotoAcquireOptionsDialog, @ptrCast(self)), hWndParent, phWndDialog);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireOptionsDialog_Destroy(self: *const T) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireOptionsDialog.VTable, @ptrCast(self.vtable)).Destroy(@as(*const IPhotoAcquireOptionsDialog, @ptrCast(self)));
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireOptionsDialog_DoModal(self: *const T, hWndParent: ?HWND, ppnReturnCode: ?*isize) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireOptionsDialog.VTable, @ptrCast(self.vtable)).DoModal(@as(*const IPhotoAcquireOptionsDialog, @ptrCast(self)), hWndParent, ppnReturnCode);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireOptionsDialog_SaveData(self: *const T) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireOptionsDialog.VTable, @ptrCast(self.vtable)).SaveData(@as(*const IPhotoAcquireOptionsDialog, @ptrCast(self)));
}
};}
pub usingnamespace MethodMixin(@This());
};
pub const DEVICE_SELECTION_DEVICE_TYPE = enum(i32) {
T_UNKNOWN_DEVICE = 0,
T_WPD_DEVICE = 1,
T_WIA_DEVICE = 2,
T_STI_DEVICE = 3,
F_TWAIN_DEVICE = 4,
T_FS_DEVICE = 5,
T_DV_DEVICE = 6,
};
pub const DST_UNKNOWN_DEVICE = DEVICE_SELECTION_DEVICE_TYPE.T_UNKNOWN_DEVICE;
pub const DST_WPD_DEVICE = DEVICE_SELECTION_DEVICE_TYPE.T_WPD_DEVICE;
pub const DST_WIA_DEVICE = DEVICE_SELECTION_DEVICE_TYPE.T_WIA_DEVICE;
pub const DST_STI_DEVICE = DEVICE_SELECTION_DEVICE_TYPE.T_STI_DEVICE;
pub const DSF_TWAIN_DEVICE = DEVICE_SELECTION_DEVICE_TYPE.F_TWAIN_DEVICE;
pub const DST_FS_DEVICE = DEVICE_SELECTION_DEVICE_TYPE.T_FS_DEVICE;
pub const DST_DV_DEVICE = DEVICE_SELECTION_DEVICE_TYPE.T_DV_DEVICE;
const IID_IPhotoAcquireDeviceSelectionDialog_Value = Guid.initString("00f28837-55dd-4f37-aaf5-6855a9640467");
pub const IID_IPhotoAcquireDeviceSelectionDialog = &IID_IPhotoAcquireDeviceSelectionDialog_Value;
pub const IPhotoAcquireDeviceSelectionDialog = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
SetTitle: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireDeviceSelectionDialog,
pszTitle: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireDeviceSelectionDialog,
pszTitle: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
SetSubmitButtonText: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireDeviceSelectionDialog,
pszSubmitButtonText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireDeviceSelectionDialog,
pszSubmitButtonText: ?[*:0]const u16,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
DoModal: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquireDeviceSelectionDialog,
hWndParent: ?HWND,
dwDeviceFlags: u32,
pbstrDeviceId: ?*?BSTR,
pnDeviceType: ?*DEVICE_SELECTION_DEVICE_TYPE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquireDeviceSelectionDialog,
hWndParent: ?HWND,
dwDeviceFlags: u32,
pbstrDeviceId: ?*?BSTR,
pnDeviceType: ?*DEVICE_SELECTION_DEVICE_TYPE,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireDeviceSelectionDialog_SetTitle(self: *const T, pszTitle: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireDeviceSelectionDialog.VTable, @ptrCast(self.vtable)).SetTitle(@as(*const IPhotoAcquireDeviceSelectionDialog, @ptrCast(self)), pszTitle);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireDeviceSelectionDialog_SetSubmitButtonText(self: *const T, pszSubmitButtonText: ?[*:0]const u16) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireDeviceSelectionDialog.VTable, @ptrCast(self.vtable)).SetSubmitButtonText(@as(*const IPhotoAcquireDeviceSelectionDialog, @ptrCast(self)), pszSubmitButtonText);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquireDeviceSelectionDialog_DoModal(self: *const T, hWndParent: ?HWND, dwDeviceFlags: u32, pbstrDeviceId: ?*?BSTR, pnDeviceType: ?*DEVICE_SELECTION_DEVICE_TYPE) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquireDeviceSelectionDialog.VTable, @ptrCast(self.vtable)).DoModal(@as(*const IPhotoAcquireDeviceSelectionDialog, @ptrCast(self)), hWndParent, dwDeviceFlags, pbstrDeviceId, pnDeviceType);
}
};}
pub usingnamespace MethodMixin(@This());
};
const IID_IPhotoAcquirePlugin_Value = Guid.initString("00f2dceb-ecb8-4f77-8e47-e7a987c83dd0");
pub const IID_IPhotoAcquirePlugin = &IID_IPhotoAcquirePlugin_Value;
pub const IPhotoAcquirePlugin = extern struct {
pub const VTable = extern struct {
base: IUnknown.VTable,
Initialize: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquirePlugin,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquirePlugin,
pPhotoAcquireSource: ?*IPhotoAcquireSource,
pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
ProcessItem: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquirePlugin,
dwAcquireStage: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
pOriginalItemStream: ?*IStream,
pszFinalFilename: ?[*:0]const u16,
pPropertyStore: ?*IPropertyStore,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquirePlugin,
dwAcquireStage: u32,
pPhotoAcquireItem: ?*IPhotoAcquireItem,
pOriginalItemStream: ?*IStream,
pszFinalFilename: ?[*:0]const u16,
pPropertyStore: ?*IPropertyStore,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
TransferComplete: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquirePlugin,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquirePlugin,
hr: HRESULT,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
DisplayConfigureDialog: switch (@import("builtin").zig_backend) {
.stage1 => fn(
self: *const IPhotoAcquirePlugin,
hWndParent: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
else => *const fn(
self: *const IPhotoAcquirePlugin,
hWndParent: ?HWND,
) callconv(@import("std").os.windows.WINAPI) HRESULT,
},
};
vtable: *const VTable,
pub fn MethodMixin(comptime T: type) type { return struct {
pub usingnamespace IUnknown.MethodMixin(T);
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquirePlugin_Initialize(self: *const T, pPhotoAcquireSource: ?*IPhotoAcquireSource, pPhotoAcquireProgressCB: ?*IPhotoAcquireProgressCB) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquirePlugin.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IPhotoAcquirePlugin, @ptrCast(self)), pPhotoAcquireSource, pPhotoAcquireProgressCB);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquirePlugin_ProcessItem(self: *const T, dwAcquireStage: u32, pPhotoAcquireItem: ?*IPhotoAcquireItem, pOriginalItemStream: ?*IStream, pszFinalFilename: ?[*:0]const u16, pPropertyStore: ?*IPropertyStore) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquirePlugin.VTable, @ptrCast(self.vtable)).ProcessItem(@as(*const IPhotoAcquirePlugin, @ptrCast(self)), dwAcquireStage, pPhotoAcquireItem, pOriginalItemStream, pszFinalFilename, pPropertyStore);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquirePlugin_TransferComplete(self: *const T, hr: HRESULT) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquirePlugin.VTable, @ptrCast(self.vtable)).TransferComplete(@as(*const IPhotoAcquirePlugin, @ptrCast(self)), hr);
}
// NOTE: method is namespaced with interface name to avoid conflicts for now
pub fn IPhotoAcquirePlugin_DisplayConfigureDialog(self: *const T, hWndParent: ?HWND) callconv(.Inline) HRESULT {
return @as(*const IPhotoAcquirePlugin.VTable, @ptrCast(self.vtable)).DisplayConfigureDialog(@as(*const IPhotoAcquirePlugin, @ptrCast(self)), hWndParent);
}
};}
pub usingnamespace MethodMixin(@This());
};
//--------------------------------------------------------------------------------
// Section: Functions (0)
//--------------------------------------------------------------------------------
//--------------------------------------------------------------------------------
// Section: Unicode Aliases (0)
//--------------------------------------------------------------------------------
const thismodule = @This();
pub usingnamespace switch (@import("../zig.zig").unicode_mode) {
.ansi => struct {
},
.wide => struct {
},
.unspecified => if (@import("builtin").is_test) struct {
} else struct {
},
};
//--------------------------------------------------------------------------------
// Section: Imports (16)
//--------------------------------------------------------------------------------
const Guid = @import("../zig.zig").Guid;
const BOOL = @import("../foundation.zig").BOOL;
const BSTR = @import("../foundation.zig").BSTR;
const FILETIME = @import("../foundation.zig").FILETIME;
const HBITMAP = @import("../graphics/gdi.zig").HBITMAP;
const HICON = @import("../ui/windows_and_messaging.zig").HICON;
const HRESULT = @import("../foundation.zig").HRESULT;
const HWND = @import("../foundation.zig").HWND;
const IEnumString = @import("../system/com.zig").IEnumString;
const IPropertyStore = @import("../ui/shell/properties_system.zig").IPropertyStore;
const IStream = @import("../system/com.zig").IStream;
const IUnknown = @import("../system/com.zig").IUnknown;
const PROPERTYKEY = @import("../ui/shell/properties_system.zig").PROPERTYKEY;
const PROPVARIANT = @import("../system/com/structured_storage.zig").PROPVARIANT;
const PWSTR = @import("../foundation.zig").PWSTR;
const SIZE = @import("../foundation.zig").SIZE;
test {
@setEvalBranchQuota(
comptime @import("std").meta.declarations(@This()).len * 3
);
// reference all the pub declarations
if (!@import("builtin").is_test) return;
inline for (comptime @import("std").meta.declarations(@This())) |decl| {
_ = @field(@This(), decl.name);
}
}
Reference in New Issue View Git Blame Copy Permalink