11375 lines
598 KiB
Zig
11375 lines
598 KiB
Zig
//! NOTE: this file is autogenerated, DO NOT MODIFY
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Constants (11)
|
|
//--------------------------------------------------------------------------------
|
|
pub const TRACKER_STARTSTOP_EVENT = "Global\\COM+ Tracker Push Event";
|
|
pub const TRACKER_INIT_EVENT = "Global\\COM+ Tracker Init Event";
|
|
pub const GUID_STRING_SIZE = @as(u32, 40);
|
|
pub const DATA_NOT_AVAILABLE = @as(u32, 4294967295);
|
|
pub const MTXDM_E_ENLISTRESOURCEFAILED = @as(u32, 2147803392);
|
|
pub const CRR_NO_REASON_SUPPLIED = @as(u32, 0);
|
|
pub const CRR_LIFETIME_LIMIT = @as(u32, 4294967295);
|
|
pub const CRR_ACTIVATION_LIMIT = @as(u32, 4294967294);
|
|
pub const CRR_CALL_LIMIT = @as(u32, 4294967293);
|
|
pub const CRR_MEMORY_LIMIT = @as(u32, 4294967292);
|
|
pub const CRR_RECYCLED_FROM_UI = @as(u32, 4294967291);
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Types (211)
|
|
//--------------------------------------------------------------------------------
|
|
const CLSID_SecurityIdentity_Value = Guid.initString("ecabb0a5-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_SecurityIdentity = &CLSID_SecurityIdentity_Value;
|
|
|
|
const CLSID_SecurityCallers_Value = Guid.initString("ecabb0a6-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_SecurityCallers = &CLSID_SecurityCallers_Value;
|
|
|
|
const CLSID_SecurityCallContext_Value = Guid.initString("ecabb0a7-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_SecurityCallContext = &CLSID_SecurityCallContext_Value;
|
|
|
|
const CLSID_GetSecurityCallContextAppObject_Value = Guid.initString("ecabb0a8-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_GetSecurityCallContextAppObject = &CLSID_GetSecurityCallContextAppObject_Value;
|
|
|
|
const CLSID_Dummy30040732_Value = Guid.initString("ecabb0a9-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_Dummy30040732 = &CLSID_Dummy30040732_Value;
|
|
|
|
const CLSID_TransactionContext_Value = Guid.initString("7999fc25-d3c6-11cf-acab-00a024a55aef");
|
|
pub const CLSID_TransactionContext = &CLSID_TransactionContext_Value;
|
|
|
|
const CLSID_TransactionContextEx_Value = Guid.initString("5cb66670-d3d4-11cf-acab-00a024a55aef");
|
|
pub const CLSID_TransactionContextEx = &CLSID_TransactionContextEx_Value;
|
|
|
|
const CLSID_ByotServerEx_Value = Guid.initString("ecabb0aa-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_ByotServerEx = &CLSID_ByotServerEx_Value;
|
|
|
|
const CLSID_CServiceConfig_Value = Guid.initString("ecabb0c8-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_CServiceConfig = &CLSID_CServiceConfig_Value;
|
|
|
|
const CLSID_ServicePool_Value = Guid.initString("ecabb0c9-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_ServicePool = &CLSID_ServicePool_Value;
|
|
|
|
const CLSID_ServicePoolConfig_Value = Guid.initString("ecabb0ca-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_ServicePoolConfig = &CLSID_ServicePoolConfig_Value;
|
|
|
|
const CLSID_SharedProperty_Value = Guid.initString("2a005c05-a5de-11cf-9e66-00aa00a3f464");
|
|
pub const CLSID_SharedProperty = &CLSID_SharedProperty_Value;
|
|
|
|
const CLSID_SharedPropertyGroup_Value = Guid.initString("2a005c0b-a5de-11cf-9e66-00aa00a3f464");
|
|
pub const CLSID_SharedPropertyGroup = &CLSID_SharedPropertyGroup_Value;
|
|
|
|
const CLSID_SharedPropertyGroupManager_Value = Guid.initString("2a005c11-a5de-11cf-9e66-00aa00a3f464");
|
|
pub const CLSID_SharedPropertyGroupManager = &CLSID_SharedPropertyGroupManager_Value;
|
|
|
|
const CLSID_COMEvents_Value = Guid.initString("ecabb0ab-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_COMEvents = &CLSID_COMEvents_Value;
|
|
|
|
const CLSID_CoMTSLocator_Value = Guid.initString("ecabb0ac-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_CoMTSLocator = &CLSID_CoMTSLocator_Value;
|
|
|
|
const CLSID_MtsGrp_Value = Guid.initString("4b2e958d-0393-11d1-b1ab-00aa00ba3258");
|
|
pub const CLSID_MtsGrp = &CLSID_MtsGrp_Value;
|
|
|
|
const CLSID_ComServiceEvents_Value = Guid.initString("ecabb0c3-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_ComServiceEvents = &CLSID_ComServiceEvents_Value;
|
|
|
|
const CLSID_ComSystemAppEventData_Value = Guid.initString("ecabb0c6-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_ComSystemAppEventData = &CLSID_ComSystemAppEventData_Value;
|
|
|
|
const CLSID_CRMClerk_Value = Guid.initString("ecabb0bd-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_CRMClerk = &CLSID_CRMClerk_Value;
|
|
|
|
const CLSID_CRMRecoveryClerk_Value = Guid.initString("ecabb0be-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_CRMRecoveryClerk = &CLSID_CRMRecoveryClerk_Value;
|
|
|
|
const CLSID_LBEvents_Value = Guid.initString("ecabb0c1-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_LBEvents = &CLSID_LBEvents_Value;
|
|
|
|
const CLSID_MessageMover_Value = Guid.initString("ecabb0bf-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_MessageMover = &CLSID_MessageMover_Value;
|
|
|
|
const CLSID_DispenserManager_Value = Guid.initString("ecabb0c0-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_DispenserManager = &CLSID_DispenserManager_Value;
|
|
|
|
const CLSID_PoolMgr_Value = Guid.initString("ecabafb5-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_PoolMgr = &CLSID_PoolMgr_Value;
|
|
|
|
const CLSID_EventServer_Value = Guid.initString("ecabafbc-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_EventServer = &CLSID_EventServer_Value;
|
|
|
|
const CLSID_TrackerServer_Value = Guid.initString("ecabafb9-7f19-11d2-978e-0000f8757e2a");
|
|
pub const CLSID_TrackerServer = &CLSID_TrackerServer_Value;
|
|
|
|
const CLSID_AppDomainHelper_Value = Guid.initString("ef24f689-14f8-4d92-b4af-d7b1f0e70fd4");
|
|
pub const CLSID_AppDomainHelper = &CLSID_AppDomainHelper_Value;
|
|
|
|
const CLSID_ClrAssemblyLocator_Value = Guid.initString("458aa3b5-265a-4b75-bc05-9bea4630cf18");
|
|
pub const CLSID_ClrAssemblyLocator = &CLSID_ClrAssemblyLocator_Value;
|
|
|
|
const CLSID_COMAdminCatalog_Value = Guid.initString("f618c514-dfb8-11d1-a2cf-00805fc79235");
|
|
pub const CLSID_COMAdminCatalog = &CLSID_COMAdminCatalog_Value;
|
|
|
|
const CLSID_COMAdminCatalogObject_Value = Guid.initString("f618c515-dfb8-11d1-a2cf-00805fc79235");
|
|
pub const CLSID_COMAdminCatalogObject = &CLSID_COMAdminCatalogObject_Value;
|
|
|
|
const CLSID_COMAdminCatalogCollection_Value = Guid.initString("f618c516-dfb8-11d1-a2cf-00805fc79235");
|
|
pub const CLSID_COMAdminCatalogCollection = &CLSID_COMAdminCatalogCollection_Value;
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICOMAdminCatalog_Value = Guid.initString("dd662187-dfc2-11d1-a2cf-00805fc79235");
|
|
pub const IID_ICOMAdminCatalog = &IID_ICOMAdminCatalog_Value;
|
|
pub const ICOMAdminCatalog = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
GetCollection: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrCollName: ?BSTR,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrCollName: ?BSTR,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Connect: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrCatalogServerName: ?BSTR,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrCatalogServerName: ?BSTR,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_MajorVersion: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
plMajorVersion: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
plMajorVersion: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_MinorVersion: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
plMinorVersion: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
plMinorVersion: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetCollectionByQuery: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrCollName: ?BSTR,
|
|
ppsaVarQuery: ?*?*SAFEARRAY,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrCollName: ?BSTR,
|
|
ppsaVarQuery: ?*?*SAFEARRAY,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ImportComponent: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
bstrCLSIDOrProgID: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
bstrCLSIDOrProgID: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
InstallComponent: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
bstrDLL: ?BSTR,
|
|
bstrTLB: ?BSTR,
|
|
bstrPSDLL: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
bstrDLL: ?BSTR,
|
|
bstrTLB: ?BSTR,
|
|
bstrPSDLL: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ShutdownApplication: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ExportApplication: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
bstrApplicationFile: ?BSTR,
|
|
lOptions: COMAdminApplicationExportOptions,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
bstrApplicationFile: ?BSTR,
|
|
lOptions: COMAdminApplicationExportOptions,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
InstallApplication: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplicationFile: ?BSTR,
|
|
bstrDestinationDirectory: ?BSTR,
|
|
lOptions: COMAdminApplicationInstallOptions,
|
|
bstrUserId: ?BSTR,
|
|
bstrPassword: ?BSTR,
|
|
bstrRSN: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplicationFile: ?BSTR,
|
|
bstrDestinationDirectory: ?BSTR,
|
|
lOptions: COMAdminApplicationInstallOptions,
|
|
bstrUserId: ?BSTR,
|
|
bstrPassword: ?BSTR,
|
|
bstrRSN: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
StopRouter: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RefreshRouter: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
StartRouter: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reserved1: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reserved2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
InstallMultipleComponents: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
ppsaVarFileNames: ?*?*SAFEARRAY,
|
|
ppsaVarCLSIDs: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIDOrName: ?BSTR,
|
|
ppsaVarFileNames: ?*?*SAFEARRAY,
|
|
ppsaVarCLSIDs: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetMultipleComponentsInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIdOrName: ?BSTR,
|
|
ppsaVarFileNames: ?*?*SAFEARRAY,
|
|
ppsaVarCLSIDs: ?*?*SAFEARRAY,
|
|
ppsaVarClassNames: ?*?*SAFEARRAY,
|
|
ppsaVarFileFlags: ?*?*SAFEARRAY,
|
|
ppsaVarComponentFlags: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIdOrName: ?BSTR,
|
|
ppsaVarFileNames: ?*?*SAFEARRAY,
|
|
ppsaVarCLSIDs: ?*?*SAFEARRAY,
|
|
ppsaVarClassNames: ?*?*SAFEARRAY,
|
|
ppsaVarFileFlags: ?*?*SAFEARRAY,
|
|
ppsaVarComponentFlags: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RefreshComponents: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BackupREGDB: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrBackupFilePath: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrBackupFilePath: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RestoreREGDB: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrBackupFilePath: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrBackupFilePath: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
QueryApplicationFile: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplicationFile: ?BSTR,
|
|
pbstrApplicationName: ?*?BSTR,
|
|
pbstrApplicationDescription: ?*?BSTR,
|
|
pbHasUsers: ?*i16,
|
|
pbIsProxy: ?*i16,
|
|
ppsaVarFileNames: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplicationFile: ?BSTR,
|
|
pbstrApplicationName: ?*?BSTR,
|
|
pbstrApplicationDescription: ?*?BSTR,
|
|
pbHasUsers: ?*i16,
|
|
pbIsProxy: ?*i16,
|
|
ppsaVarFileNames: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
StartApplication: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIdOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIdOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ServiceCheck: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
lService: i32,
|
|
plStatus: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
lService: i32,
|
|
plStatus: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
InstallMultipleEventClasses: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIdOrName: ?BSTR,
|
|
ppsaVarFileNames: ?*?*SAFEARRAY,
|
|
ppsaVarCLSIDS: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIdOrName: ?BSTR,
|
|
ppsaVarFileNames: ?*?*SAFEARRAY,
|
|
ppsaVarCLSIDS: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
InstallEventClass: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIdOrName: ?BSTR,
|
|
bstrDLL: ?BSTR,
|
|
bstrTLB: ?BSTR,
|
|
bstrPSDLL: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrApplIdOrName: ?BSTR,
|
|
bstrDLL: ?BSTR,
|
|
bstrTLB: ?BSTR,
|
|
bstrPSDLL: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetEventClassesForIID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrIID: ?BSTR,
|
|
ppsaVarCLSIDs: ?*?*SAFEARRAY,
|
|
ppsaVarProgIDs: ?*?*SAFEARRAY,
|
|
ppsaVarDescriptions: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog,
|
|
bstrIID: ?BSTR,
|
|
ppsaVarCLSIDs: ?*?*SAFEARRAY,
|
|
ppsaVarProgIDs: ?*?*SAFEARRAY,
|
|
ppsaVarDescriptions: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_GetCollection(self: *const T, bstrCollName: ?BSTR, ppCatalogCollection: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).GetCollection(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrCollName, ppCatalogCollection);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_Connect(self: *const T, bstrCatalogServerName: ?BSTR, ppCatalogCollection: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).Connect(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrCatalogServerName, ppCatalogCollection);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_get_MajorVersion(self: *const T, plMajorVersion: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).get_MajorVersion(@as(*const ICOMAdminCatalog, @ptrCast(self)), plMajorVersion);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_get_MinorVersion(self: *const T, plMinorVersion: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).get_MinorVersion(@as(*const ICOMAdminCatalog, @ptrCast(self)), plMinorVersion);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_GetCollectionByQuery(self: *const T, bstrCollName: ?BSTR, ppsaVarQuery: ?*?*SAFEARRAY, ppCatalogCollection: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).GetCollectionByQuery(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrCollName, ppsaVarQuery, ppCatalogCollection);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_ImportComponent(self: *const T, bstrApplIDOrName: ?BSTR, bstrCLSIDOrProgID: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).ImportComponent(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName, bstrCLSIDOrProgID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_InstallComponent(self: *const T, bstrApplIDOrName: ?BSTR, bstrDLL: ?BSTR, bstrTLB: ?BSTR, bstrPSDLL: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallComponent(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName, bstrDLL, bstrTLB, bstrPSDLL);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_ShutdownApplication(self: *const T, bstrApplIDOrName: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).ShutdownApplication(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_ExportApplication(self: *const T, bstrApplIDOrName: ?BSTR, bstrApplicationFile: ?BSTR, lOptions: COMAdminApplicationExportOptions) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).ExportApplication(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName, bstrApplicationFile, lOptions);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_InstallApplication(self: *const T, bstrApplicationFile: ?BSTR, bstrDestinationDirectory: ?BSTR, lOptions: COMAdminApplicationInstallOptions, bstrUserId: ?BSTR, bstrPassword: ?BSTR, bstrRSN: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallApplication(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplicationFile, bstrDestinationDirectory, lOptions, bstrUserId, bstrPassword, bstrRSN);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_StopRouter(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).StopRouter(@as(*const ICOMAdminCatalog, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_RefreshRouter(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).RefreshRouter(@as(*const ICOMAdminCatalog, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_StartRouter(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).StartRouter(@as(*const ICOMAdminCatalog, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_Reserved1(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).Reserved1(@as(*const ICOMAdminCatalog, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_Reserved2(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).Reserved2(@as(*const ICOMAdminCatalog, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_InstallMultipleComponents(self: *const T, bstrApplIDOrName: ?BSTR, ppsaVarFileNames: ?*?*SAFEARRAY, ppsaVarCLSIDs: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallMultipleComponents(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIDOrName, ppsaVarFileNames, ppsaVarCLSIDs);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_GetMultipleComponentsInfo(self: *const T, bstrApplIdOrName: ?BSTR, ppsaVarFileNames: ?*?*SAFEARRAY, ppsaVarCLSIDs: ?*?*SAFEARRAY, ppsaVarClassNames: ?*?*SAFEARRAY, ppsaVarFileFlags: ?*?*SAFEARRAY, ppsaVarComponentFlags: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).GetMultipleComponentsInfo(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIdOrName, ppsaVarFileNames, ppsaVarCLSIDs, ppsaVarClassNames, ppsaVarFileFlags, ppsaVarComponentFlags);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_RefreshComponents(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).RefreshComponents(@as(*const ICOMAdminCatalog, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_BackupREGDB(self: *const T, bstrBackupFilePath: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).BackupREGDB(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrBackupFilePath);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_RestoreREGDB(self: *const T, bstrBackupFilePath: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).RestoreREGDB(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrBackupFilePath);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_QueryApplicationFile(self: *const T, bstrApplicationFile: ?BSTR, pbstrApplicationName: ?*?BSTR, pbstrApplicationDescription: ?*?BSTR, pbHasUsers: ?*i16, pbIsProxy: ?*i16, ppsaVarFileNames: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).QueryApplicationFile(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplicationFile, pbstrApplicationName, pbstrApplicationDescription, pbHasUsers, pbIsProxy, ppsaVarFileNames);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_StartApplication(self: *const T, bstrApplIdOrName: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).StartApplication(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIdOrName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_ServiceCheck(self: *const T, lService: i32, plStatus: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).ServiceCheck(@as(*const ICOMAdminCatalog, @ptrCast(self)), lService, plStatus);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_InstallMultipleEventClasses(self: *const T, bstrApplIdOrName: ?BSTR, ppsaVarFileNames: ?*?*SAFEARRAY, ppsaVarCLSIDS: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallMultipleEventClasses(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIdOrName, ppsaVarFileNames, ppsaVarCLSIDS);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_InstallEventClass(self: *const T, bstrApplIdOrName: ?BSTR, bstrDLL: ?BSTR, bstrTLB: ?BSTR, bstrPSDLL: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).InstallEventClass(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrApplIdOrName, bstrDLL, bstrTLB, bstrPSDLL);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog_GetEventClassesForIID(self: *const T, bstrIID: ?BSTR, ppsaVarCLSIDs: ?*?*SAFEARRAY, ppsaVarProgIDs: ?*?*SAFEARRAY, ppsaVarDescriptions: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog.VTable, @ptrCast(self.vtable)).GetEventClassesForIID(@as(*const ICOMAdminCatalog, @ptrCast(self)), bstrIID, ppsaVarCLSIDs, ppsaVarProgIDs, ppsaVarDescriptions);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const COMAdminInUse = enum(i32) {
|
|
NotInUse = 0,
|
|
InUseByCatalog = 1,
|
|
InUseByRegistryUnknown = 2,
|
|
InUseByRegistryProxyStub = 3,
|
|
InUseByRegistryTypeLib = 4,
|
|
InUseByRegistryClsid = 5,
|
|
};
|
|
pub const COMAdminNotInUse = COMAdminInUse.NotInUse;
|
|
pub const COMAdminInUseByCatalog = COMAdminInUse.InUseByCatalog;
|
|
pub const COMAdminInUseByRegistryUnknown = COMAdminInUse.InUseByRegistryUnknown;
|
|
pub const COMAdminInUseByRegistryProxyStub = COMAdminInUse.InUseByRegistryProxyStub;
|
|
pub const COMAdminInUseByRegistryTypeLib = COMAdminInUse.InUseByRegistryTypeLib;
|
|
pub const COMAdminInUseByRegistryClsid = COMAdminInUse.InUseByRegistryClsid;
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_ICOMAdminCatalog2_Value = Guid.initString("790c6e0b-9194-4cc9-9426-a48a63185696");
|
|
pub const IID_ICOMAdminCatalog2 = &IID_ICOMAdminCatalog2_Value;
|
|
pub const ICOMAdminCatalog2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: ICOMAdminCatalog.VTable,
|
|
GetCollectionByQuery2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrCollectionName: ?BSTR,
|
|
pVarQueryStrings: ?*VARIANT,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrCollectionName: ?BSTR,
|
|
pVarQueryStrings: ?*VARIANT,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetApplicationInstanceIDFromProcessID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
lProcessID: i32,
|
|
pbstrApplicationInstanceID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
lProcessID: i32,
|
|
pbstrApplicationInstanceID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ShutdownApplicationInstances: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PauseApplicationInstances: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ResumeApplicationInstances: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RecycleApplicationInstances: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
lReasonCode: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
lReasonCode: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AreApplicationInstancesPaused: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
pVarBoolPaused: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarApplicationInstanceID: ?*VARIANT,
|
|
pVarBoolPaused: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DumpApplicationInstance: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationInstanceID: ?BSTR,
|
|
bstrDirectory: ?BSTR,
|
|
lMaxImages: i32,
|
|
pbstrDumpFile: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationInstanceID: ?BSTR,
|
|
bstrDirectory: ?BSTR,
|
|
lMaxImages: i32,
|
|
pbstrDumpFile: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_IsApplicationInstanceDumpSupported: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarBoolDumpSupported: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pVarBoolDumpSupported: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateServiceForApplication: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
bstrServiceName: ?BSTR,
|
|
bstrStartType: ?BSTR,
|
|
bstrErrorControl: ?BSTR,
|
|
bstrDependencies: ?BSTR,
|
|
bstrRunAs: ?BSTR,
|
|
bstrPassword: ?BSTR,
|
|
bDesktopOk: i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
bstrServiceName: ?BSTR,
|
|
bstrStartType: ?BSTR,
|
|
bstrErrorControl: ?BSTR,
|
|
bstrDependencies: ?BSTR,
|
|
bstrRunAs: ?BSTR,
|
|
bstrPassword: ?BSTR,
|
|
bDesktopOk: i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DeleteServiceForApplication: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetPartitionID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pbstrPartitionID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pbstrPartitionID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetPartitionName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pbstrPartitionName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pbstrPartitionName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_CurrentPartition: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrPartitionIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrPartitionIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_CurrentPartitionID: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pbstrPartitionID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pbstrPartitionID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_CurrentPartitionName: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pbstrPartitionName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pbstrPartitionName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_GlobalPartitionID: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pbstrGlobalPartitionID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pbstrGlobalPartitionID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
FlushPartitionCache: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CopyApplications: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrSourcePartitionIDOrName: ?BSTR,
|
|
pVarApplicationID: ?*VARIANT,
|
|
bstrDestinationPartitionIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrSourcePartitionIDOrName: ?BSTR,
|
|
pVarApplicationID: ?*VARIANT,
|
|
bstrDestinationPartitionIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CopyComponents: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrSourceApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
bstrDestinationApplicationIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrSourceApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
bstrDestinationApplicationIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
MoveComponents: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrSourceApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
bstrDestinationApplicationIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrSourceApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
bstrDestinationApplicationIDOrName: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AliasComponent: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrSrcApplicationIDOrName: ?BSTR,
|
|
bstrCLSIDOrProgID: ?BSTR,
|
|
bstrDestApplicationIDOrName: ?BSTR,
|
|
bstrNewProgId: ?BSTR,
|
|
bstrNewClsid: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrSrcApplicationIDOrName: ?BSTR,
|
|
bstrCLSIDOrProgID: ?BSTR,
|
|
bstrDestApplicationIDOrName: ?BSTR,
|
|
bstrNewProgId: ?BSTR,
|
|
bstrNewClsid: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsSafeToDelete: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrDllName: ?BSTR,
|
|
pCOMAdminInUse: ?*COMAdminInUse,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrDllName: ?BSTR,
|
|
pCOMAdminInUse: ?*COMAdminInUse,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ImportUnconfiguredComponents: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
pVarComponentType: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
pVarComponentType: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PromoteUnconfiguredComponents: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
pVarComponentType: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
pVarComponentType: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ImportComponents: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
pVarComponentType: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationIDOrName: ?BSTR,
|
|
pVarCLSIDOrProgID: ?*VARIANT,
|
|
pVarComponentType: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Is64BitCatalogServer: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pbIs64Bit: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
pbIs64Bit: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ExportPartition: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrPartitionIDOrName: ?BSTR,
|
|
bstrPartitionFileName: ?BSTR,
|
|
lOptions: COMAdminApplicationExportOptions,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrPartitionIDOrName: ?BSTR,
|
|
bstrPartitionFileName: ?BSTR,
|
|
lOptions: COMAdminApplicationExportOptions,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
InstallPartition: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrFileName: ?BSTR,
|
|
bstrDestDirectory: ?BSTR,
|
|
lOptions: COMAdminApplicationInstallOptions,
|
|
bstrUserID: ?BSTR,
|
|
bstrPassword: ?BSTR,
|
|
bstrRSN: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrFileName: ?BSTR,
|
|
bstrDestDirectory: ?BSTR,
|
|
lOptions: COMAdminApplicationInstallOptions,
|
|
bstrUserID: ?BSTR,
|
|
bstrPassword: ?BSTR,
|
|
bstrRSN: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
QueryApplicationFile2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationFile: ?BSTR,
|
|
ppFilesForImport: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrApplicationFile: ?BSTR,
|
|
ppFilesForImport: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetComponentVersionCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrCLSIDOrProgID: ?BSTR,
|
|
plVersionCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMAdminCatalog2,
|
|
bstrCLSIDOrProgID: ?BSTR,
|
|
plVersionCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace ICOMAdminCatalog.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_GetCollectionByQuery2(self: *const T, bstrCollectionName: ?BSTR, pVarQueryStrings: ?*VARIANT, ppCatalogCollection: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetCollectionByQuery2(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrCollectionName, pVarQueryStrings, ppCatalogCollection);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_GetApplicationInstanceIDFromProcessID(self: *const T, lProcessID: i32, pbstrApplicationInstanceID: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetApplicationInstanceIDFromProcessID(@as(*const ICOMAdminCatalog2, @ptrCast(self)), lProcessID, pbstrApplicationInstanceID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_ShutdownApplicationInstances(self: *const T, pVarApplicationInstanceID: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ShutdownApplicationInstances(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_PauseApplicationInstances(self: *const T, pVarApplicationInstanceID: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).PauseApplicationInstances(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_ResumeApplicationInstances(self: *const T, pVarApplicationInstanceID: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ResumeApplicationInstances(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_RecycleApplicationInstances(self: *const T, pVarApplicationInstanceID: ?*VARIANT, lReasonCode: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).RecycleApplicationInstances(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID, lReasonCode);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_AreApplicationInstancesPaused(self: *const T, pVarApplicationInstanceID: ?*VARIANT, pVarBoolPaused: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).AreApplicationInstancesPaused(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarApplicationInstanceID, pVarBoolPaused);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_DumpApplicationInstance(self: *const T, bstrApplicationInstanceID: ?BSTR, bstrDirectory: ?BSTR, lMaxImages: i32, pbstrDumpFile: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).DumpApplicationInstance(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationInstanceID, bstrDirectory, lMaxImages, pbstrDumpFile);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_get_IsApplicationInstanceDumpSupported(self: *const T, pVarBoolDumpSupported: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_IsApplicationInstanceDumpSupported(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pVarBoolDumpSupported);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_CreateServiceForApplication(self: *const T, bstrApplicationIDOrName: ?BSTR, bstrServiceName: ?BSTR, bstrStartType: ?BSTR, bstrErrorControl: ?BSTR, bstrDependencies: ?BSTR, bstrRunAs: ?BSTR, bstrPassword: ?BSTR, bDesktopOk: i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).CreateServiceForApplication(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, bstrServiceName, bstrStartType, bstrErrorControl, bstrDependencies, bstrRunAs, bstrPassword, bDesktopOk);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_DeleteServiceForApplication(self: *const T, bstrApplicationIDOrName: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).DeleteServiceForApplication(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_GetPartitionID(self: *const T, bstrApplicationIDOrName: ?BSTR, pbstrPartitionID: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetPartitionID(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pbstrPartitionID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_GetPartitionName(self: *const T, bstrApplicationIDOrName: ?BSTR, pbstrPartitionName: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetPartitionName(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pbstrPartitionName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_put_CurrentPartition(self: *const T, bstrPartitionIDOrName: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).put_CurrentPartition(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrPartitionIDOrName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_get_CurrentPartitionID(self: *const T, pbstrPartitionID: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_CurrentPartitionID(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pbstrPartitionID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_get_CurrentPartitionName(self: *const T, pbstrPartitionName: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_CurrentPartitionName(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pbstrPartitionName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_get_GlobalPartitionID(self: *const T, pbstrGlobalPartitionID: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_GlobalPartitionID(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pbstrGlobalPartitionID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_FlushPartitionCache(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).FlushPartitionCache(@as(*const ICOMAdminCatalog2, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_CopyApplications(self: *const T, bstrSourcePartitionIDOrName: ?BSTR, pVarApplicationID: ?*VARIANT, bstrDestinationPartitionIDOrName: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).CopyApplications(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrSourcePartitionIDOrName, pVarApplicationID, bstrDestinationPartitionIDOrName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_CopyComponents(self: *const T, bstrSourceApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, bstrDestinationApplicationIDOrName: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).CopyComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrSourceApplicationIDOrName, pVarCLSIDOrProgID, bstrDestinationApplicationIDOrName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_MoveComponents(self: *const T, bstrSourceApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, bstrDestinationApplicationIDOrName: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).MoveComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrSourceApplicationIDOrName, pVarCLSIDOrProgID, bstrDestinationApplicationIDOrName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_AliasComponent(self: *const T, bstrSrcApplicationIDOrName: ?BSTR, bstrCLSIDOrProgID: ?BSTR, bstrDestApplicationIDOrName: ?BSTR, bstrNewProgId: ?BSTR, bstrNewClsid: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).AliasComponent(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrSrcApplicationIDOrName, bstrCLSIDOrProgID, bstrDestApplicationIDOrName, bstrNewProgId, bstrNewClsid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_IsSafeToDelete(self: *const T, bstrDllName: ?BSTR, pCOMAdminInUse: ?*COMAdminInUse) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).IsSafeToDelete(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrDllName, pCOMAdminInUse);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_ImportUnconfiguredComponents(self: *const T, bstrApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, pVarComponentType: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ImportUnconfiguredComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pVarCLSIDOrProgID, pVarComponentType);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_PromoteUnconfiguredComponents(self: *const T, bstrApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, pVarComponentType: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).PromoteUnconfiguredComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pVarCLSIDOrProgID, pVarComponentType);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_ImportComponents(self: *const T, bstrApplicationIDOrName: ?BSTR, pVarCLSIDOrProgID: ?*VARIANT, pVarComponentType: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ImportComponents(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationIDOrName, pVarCLSIDOrProgID, pVarComponentType);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_get_Is64BitCatalogServer(self: *const T, pbIs64Bit: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).get_Is64BitCatalogServer(@as(*const ICOMAdminCatalog2, @ptrCast(self)), pbIs64Bit);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_ExportPartition(self: *const T, bstrPartitionIDOrName: ?BSTR, bstrPartitionFileName: ?BSTR, lOptions: COMAdminApplicationExportOptions) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).ExportPartition(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrPartitionIDOrName, bstrPartitionFileName, lOptions);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_InstallPartition(self: *const T, bstrFileName: ?BSTR, bstrDestDirectory: ?BSTR, lOptions: COMAdminApplicationInstallOptions, bstrUserID: ?BSTR, bstrPassword: ?BSTR, bstrRSN: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).InstallPartition(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrFileName, bstrDestDirectory, lOptions, bstrUserID, bstrPassword, bstrRSN);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_QueryApplicationFile2(self: *const T, bstrApplicationFile: ?BSTR, ppFilesForImport: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).QueryApplicationFile2(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrApplicationFile, ppFilesForImport);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMAdminCatalog2_GetComponentVersionCount(self: *const T, bstrCLSIDOrProgID: ?BSTR, plVersionCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMAdminCatalog2.VTable, @ptrCast(self.vtable)).GetComponentVersionCount(@as(*const ICOMAdminCatalog2, @ptrCast(self)), bstrCLSIDOrProgID, plVersionCount);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICatalogObject_Value = Guid.initString("6eb22871-8a19-11d0-81b6-00a0c9231c29");
|
|
pub const IID_ICatalogObject = &IID_ICatalogObject_Value;
|
|
pub const ICatalogObject = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Value: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogObject,
|
|
bstrPropName: ?BSTR,
|
|
pvarRetVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogObject,
|
|
bstrPropName: ?BSTR,
|
|
pvarRetVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_Value: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogObject,
|
|
bstrPropName: ?BSTR,
|
|
val: VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogObject,
|
|
bstrPropName: ?BSTR,
|
|
val: VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Key: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogObject,
|
|
pvarRetVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogObject,
|
|
pvarRetVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Name: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogObject,
|
|
pvarRetVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogObject,
|
|
pvarRetVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsPropertyReadOnly: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogObject,
|
|
bstrPropName: ?BSTR,
|
|
pbRetVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogObject,
|
|
bstrPropName: ?BSTR,
|
|
pbRetVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Valid: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogObject,
|
|
pbRetVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogObject,
|
|
pbRetVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsPropertyWriteOnly: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogObject,
|
|
bstrPropName: ?BSTR,
|
|
pbRetVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogObject,
|
|
bstrPropName: ?BSTR,
|
|
pbRetVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogObject_get_Value(self: *const T, bstrPropName: ?BSTR, pvarRetVal: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).get_Value(@as(*const ICatalogObject, @ptrCast(self)), bstrPropName, pvarRetVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogObject_put_Value(self: *const T, bstrPropName: ?BSTR, val: VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).put_Value(@as(*const ICatalogObject, @ptrCast(self)), bstrPropName, val);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogObject_get_Key(self: *const T, pvarRetVal: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).get_Key(@as(*const ICatalogObject, @ptrCast(self)), pvarRetVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogObject_get_Name(self: *const T, pvarRetVal: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).get_Name(@as(*const ICatalogObject, @ptrCast(self)), pvarRetVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogObject_IsPropertyReadOnly(self: *const T, bstrPropName: ?BSTR, pbRetVal: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).IsPropertyReadOnly(@as(*const ICatalogObject, @ptrCast(self)), bstrPropName, pbRetVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogObject_get_Valid(self: *const T, pbRetVal: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).get_Valid(@as(*const ICatalogObject, @ptrCast(self)), pbRetVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogObject_IsPropertyWriteOnly(self: *const T, bstrPropName: ?BSTR, pbRetVal: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogObject.VTable, @ptrCast(self.vtable)).IsPropertyWriteOnly(@as(*const ICatalogObject, @ptrCast(self)), bstrPropName, pbRetVal);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICatalogCollection_Value = Guid.initString("6eb22872-8a19-11d0-81b6-00a0c9231c29");
|
|
pub const IID_ICatalogCollection = &IID_ICatalogCollection_Value;
|
|
pub const ICatalogCollection = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get__NewEnum: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
ppEnumVariant: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
ppEnumVariant: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Item: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
lIndex: i32,
|
|
ppCatalogObject: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
lIndex: i32,
|
|
ppCatalogObject: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
plObjectCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
plObjectCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Remove: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
lIndex: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
lIndex: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Add: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
ppCatalogObject: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
ppCatalogObject: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Populate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SaveChanges: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
pcChanges: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
pcChanges: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetCollection: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
bstrCollName: ?BSTR,
|
|
varObjectKey: VARIANT,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
bstrCollName: ?BSTR,
|
|
varObjectKey: VARIANT,
|
|
ppCatalogCollection: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Name: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
pVarNamel: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
pVarNamel: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_AddEnabled: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
pVarBool: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
pVarBool: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_RemoveEnabled: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
pVarBool: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
pVarBool: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetUtilInterface: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
ppIDispatch: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
ppIDispatch: ?*?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_DataStoreMajorVersion: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
plMajorVersion: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
plMajorVersion: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_DataStoreMinorVersion: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
plMinorVersionl: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
plMinorVersionl: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PopulateByKey: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
psaKeys: ?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
psaKeys: ?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PopulateByQuery: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICatalogCollection,
|
|
bstrQueryString: ?BSTR,
|
|
lQueryType: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICatalogCollection,
|
|
bstrQueryString: ?BSTR,
|
|
lQueryType: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_get__NewEnum(self: *const T, ppEnumVariant: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ICatalogCollection, @ptrCast(self)), ppEnumVariant);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_get_Item(self: *const T, lIndex: i32, ppCatalogObject: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ICatalogCollection, @ptrCast(self)), lIndex, ppCatalogObject);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_get_Count(self: *const T, plObjectCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ICatalogCollection, @ptrCast(self)), plObjectCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_Remove(self: *const T, lIndex: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).Remove(@as(*const ICatalogCollection, @ptrCast(self)), lIndex);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_Add(self: *const T, ppCatalogObject: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).Add(@as(*const ICatalogCollection, @ptrCast(self)), ppCatalogObject);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_Populate(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).Populate(@as(*const ICatalogCollection, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_SaveChanges(self: *const T, pcChanges: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).SaveChanges(@as(*const ICatalogCollection, @ptrCast(self)), pcChanges);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_GetCollection(self: *const T, bstrCollName: ?BSTR, varObjectKey: VARIANT, ppCatalogCollection: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).GetCollection(@as(*const ICatalogCollection, @ptrCast(self)), bstrCollName, varObjectKey, ppCatalogCollection);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_get_Name(self: *const T, pVarNamel: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_Name(@as(*const ICatalogCollection, @ptrCast(self)), pVarNamel);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_get_AddEnabled(self: *const T, pVarBool: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_AddEnabled(@as(*const ICatalogCollection, @ptrCast(self)), pVarBool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_get_RemoveEnabled(self: *const T, pVarBool: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_RemoveEnabled(@as(*const ICatalogCollection, @ptrCast(self)), pVarBool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_GetUtilInterface(self: *const T, ppIDispatch: ?*?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).GetUtilInterface(@as(*const ICatalogCollection, @ptrCast(self)), ppIDispatch);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_get_DataStoreMajorVersion(self: *const T, plMajorVersion: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_DataStoreMajorVersion(@as(*const ICatalogCollection, @ptrCast(self)), plMajorVersion);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_get_DataStoreMinorVersion(self: *const T, plMinorVersionl: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).get_DataStoreMinorVersion(@as(*const ICatalogCollection, @ptrCast(self)), plMinorVersionl);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_PopulateByKey(self: *const T, psaKeys: ?*SAFEARRAY) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).PopulateByKey(@as(*const ICatalogCollection, @ptrCast(self)), psaKeys);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICatalogCollection_PopulateByQuery(self: *const T, bstrQueryString: ?BSTR, lQueryType: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICatalogCollection.VTable, @ptrCast(self.vtable)).PopulateByQuery(@as(*const ICatalogCollection, @ptrCast(self)), bstrQueryString, lQueryType);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const COMAdminComponentType = enum(i32) {
|
|
@"32BitComponent" = 1,
|
|
@"64BitComponent" = 2,
|
|
};
|
|
pub const COMAdmin32BitComponent = COMAdminComponentType.@"32BitComponent";
|
|
pub const COMAdmin64BitComponent = COMAdminComponentType.@"64BitComponent";
|
|
|
|
pub const COMAdminApplicationInstallOptions = enum(i32) {
|
|
NoUsers = 0,
|
|
Users = 1,
|
|
ForceOverwriteOfFiles = 2,
|
|
};
|
|
pub const COMAdminInstallNoUsers = COMAdminApplicationInstallOptions.NoUsers;
|
|
pub const COMAdminInstallUsers = COMAdminApplicationInstallOptions.Users;
|
|
pub const COMAdminInstallForceOverwriteOfFiles = COMAdminApplicationInstallOptions.ForceOverwriteOfFiles;
|
|
|
|
pub const COMAdminApplicationExportOptions = enum(i32) {
|
|
NoUsers = 0,
|
|
Users = 1,
|
|
ApplicationProxy = 2,
|
|
ForceOverwriteOfFiles = 4,
|
|
In10Format = 16,
|
|
};
|
|
pub const COMAdminExportNoUsers = COMAdminApplicationExportOptions.NoUsers;
|
|
pub const COMAdminExportUsers = COMAdminApplicationExportOptions.Users;
|
|
pub const COMAdminExportApplicationProxy = COMAdminApplicationExportOptions.ApplicationProxy;
|
|
pub const COMAdminExportForceOverwriteOfFiles = COMAdminApplicationExportOptions.ForceOverwriteOfFiles;
|
|
pub const COMAdminExportIn10Format = COMAdminApplicationExportOptions.In10Format;
|
|
|
|
pub const COMAdminThreadingModels = enum(i32) {
|
|
Apartment = 0,
|
|
Free = 1,
|
|
Main = 2,
|
|
Both = 3,
|
|
Neutral = 4,
|
|
NotSpecified = 5,
|
|
};
|
|
pub const COMAdminThreadingModelApartment = COMAdminThreadingModels.Apartment;
|
|
pub const COMAdminThreadingModelFree = COMAdminThreadingModels.Free;
|
|
pub const COMAdminThreadingModelMain = COMAdminThreadingModels.Main;
|
|
pub const COMAdminThreadingModelBoth = COMAdminThreadingModels.Both;
|
|
pub const COMAdminThreadingModelNeutral = COMAdminThreadingModels.Neutral;
|
|
pub const COMAdminThreadingModelNotSpecified = COMAdminThreadingModels.NotSpecified;
|
|
|
|
pub const COMAdminTransactionOptions = enum(i32) {
|
|
Ignored = 0,
|
|
None = 1,
|
|
Supported = 2,
|
|
Required = 3,
|
|
RequiresNew = 4,
|
|
};
|
|
pub const COMAdminTransactionIgnored = COMAdminTransactionOptions.Ignored;
|
|
pub const COMAdminTransactionNone = COMAdminTransactionOptions.None;
|
|
pub const COMAdminTransactionSupported = COMAdminTransactionOptions.Supported;
|
|
pub const COMAdminTransactionRequired = COMAdminTransactionOptions.Required;
|
|
pub const COMAdminTransactionRequiresNew = COMAdminTransactionOptions.RequiresNew;
|
|
|
|
pub const COMAdminTxIsolationLevelOptions = enum(i32) {
|
|
Any = 0,
|
|
ReadUnCommitted = 1,
|
|
ReadCommitted = 2,
|
|
RepeatableRead = 3,
|
|
Serializable = 4,
|
|
};
|
|
pub const COMAdminTxIsolationLevelAny = COMAdminTxIsolationLevelOptions.Any;
|
|
pub const COMAdminTxIsolationLevelReadUnCommitted = COMAdminTxIsolationLevelOptions.ReadUnCommitted;
|
|
pub const COMAdminTxIsolationLevelReadCommitted = COMAdminTxIsolationLevelOptions.ReadCommitted;
|
|
pub const COMAdminTxIsolationLevelRepeatableRead = COMAdminTxIsolationLevelOptions.RepeatableRead;
|
|
pub const COMAdminTxIsolationLevelSerializable = COMAdminTxIsolationLevelOptions.Serializable;
|
|
|
|
pub const COMAdminSynchronizationOptions = enum(i32) {
|
|
Ignored = 0,
|
|
None = 1,
|
|
Supported = 2,
|
|
Required = 3,
|
|
RequiresNew = 4,
|
|
};
|
|
pub const COMAdminSynchronizationIgnored = COMAdminSynchronizationOptions.Ignored;
|
|
pub const COMAdminSynchronizationNone = COMAdminSynchronizationOptions.None;
|
|
pub const COMAdminSynchronizationSupported = COMAdminSynchronizationOptions.Supported;
|
|
pub const COMAdminSynchronizationRequired = COMAdminSynchronizationOptions.Required;
|
|
pub const COMAdminSynchronizationRequiresNew = COMAdminSynchronizationOptions.RequiresNew;
|
|
|
|
pub const COMAdminActivationOptions = enum(i32) {
|
|
Inproc = 0,
|
|
Local = 1,
|
|
};
|
|
pub const COMAdminActivationInproc = COMAdminActivationOptions.Inproc;
|
|
pub const COMAdminActivationLocal = COMAdminActivationOptions.Local;
|
|
|
|
pub const COMAdminAccessChecksLevelOptions = enum(i32) {
|
|
Level = 0,
|
|
ComponentLevel = 1,
|
|
};
|
|
pub const COMAdminAccessChecksApplicationLevel = COMAdminAccessChecksLevelOptions.Level;
|
|
pub const COMAdminAccessChecksApplicationComponentLevel = COMAdminAccessChecksLevelOptions.ComponentLevel;
|
|
|
|
pub const COMAdminAuthenticationLevelOptions = enum(i32) {
|
|
Default = 0,
|
|
None = 1,
|
|
Connect = 2,
|
|
Call = 3,
|
|
Packet = 4,
|
|
Integrity = 5,
|
|
Privacy = 6,
|
|
};
|
|
pub const COMAdminAuthenticationDefault = COMAdminAuthenticationLevelOptions.Default;
|
|
pub const COMAdminAuthenticationNone = COMAdminAuthenticationLevelOptions.None;
|
|
pub const COMAdminAuthenticationConnect = COMAdminAuthenticationLevelOptions.Connect;
|
|
pub const COMAdminAuthenticationCall = COMAdminAuthenticationLevelOptions.Call;
|
|
pub const COMAdminAuthenticationPacket = COMAdminAuthenticationLevelOptions.Packet;
|
|
pub const COMAdminAuthenticationIntegrity = COMAdminAuthenticationLevelOptions.Integrity;
|
|
pub const COMAdminAuthenticationPrivacy = COMAdminAuthenticationLevelOptions.Privacy;
|
|
|
|
pub const COMAdminImpersonationLevelOptions = enum(i32) {
|
|
Anonymous = 1,
|
|
Identify = 2,
|
|
Impersonate = 3,
|
|
Delegate = 4,
|
|
};
|
|
pub const COMAdminImpersonationAnonymous = COMAdminImpersonationLevelOptions.Anonymous;
|
|
pub const COMAdminImpersonationIdentify = COMAdminImpersonationLevelOptions.Identify;
|
|
pub const COMAdminImpersonationImpersonate = COMAdminImpersonationLevelOptions.Impersonate;
|
|
pub const COMAdminImpersonationDelegate = COMAdminImpersonationLevelOptions.Delegate;
|
|
|
|
pub const COMAdminAuthenticationCapabilitiesOptions = enum(i32) {
|
|
None = 0,
|
|
SecureReference = 2,
|
|
StaticCloaking = 32,
|
|
DynamicCloaking = 64,
|
|
};
|
|
pub const COMAdminAuthenticationCapabilitiesNone = COMAdminAuthenticationCapabilitiesOptions.None;
|
|
pub const COMAdminAuthenticationCapabilitiesSecureReference = COMAdminAuthenticationCapabilitiesOptions.SecureReference;
|
|
pub const COMAdminAuthenticationCapabilitiesStaticCloaking = COMAdminAuthenticationCapabilitiesOptions.StaticCloaking;
|
|
pub const COMAdminAuthenticationCapabilitiesDynamicCloaking = COMAdminAuthenticationCapabilitiesOptions.DynamicCloaking;
|
|
|
|
pub const COMAdminOS = enum(i32) {
|
|
NotInitialized = 0,
|
|
Windows3_1 = 1,
|
|
Windows9x = 2,
|
|
Windows2000 = 3,
|
|
Windows2000AdvancedServer = 4,
|
|
Windows2000Unknown = 5,
|
|
Unknown = 6,
|
|
WindowsXPPersonal = 11,
|
|
WindowsXPProfessional = 12,
|
|
WindowsNETStandardServer = 13,
|
|
WindowsNETEnterpriseServer = 14,
|
|
WindowsNETDatacenterServer = 15,
|
|
WindowsNETWebServer = 16,
|
|
WindowsLonghornPersonal = 17,
|
|
WindowsLonghornProfessional = 18,
|
|
WindowsLonghornStandardServer = 19,
|
|
WindowsLonghornEnterpriseServer = 20,
|
|
WindowsLonghornDatacenterServer = 21,
|
|
WindowsLonghornWebServer = 22,
|
|
Windows7Personal = 23,
|
|
Windows7Professional = 24,
|
|
Windows7StandardServer = 25,
|
|
Windows7EnterpriseServer = 26,
|
|
Windows7DatacenterServer = 27,
|
|
Windows7WebServer = 28,
|
|
Windows8Personal = 29,
|
|
Windows8Professional = 30,
|
|
Windows8StandardServer = 31,
|
|
Windows8EnterpriseServer = 32,
|
|
Windows8DatacenterServer = 33,
|
|
Windows8WebServer = 34,
|
|
WindowsBluePersonal = 35,
|
|
WindowsBlueProfessional = 36,
|
|
WindowsBlueStandardServer = 37,
|
|
WindowsBlueEnterpriseServer = 38,
|
|
WindowsBlueDatacenterServer = 39,
|
|
WindowsBlueWebServer = 40,
|
|
};
|
|
pub const COMAdminOSNotInitialized = COMAdminOS.NotInitialized;
|
|
pub const COMAdminOSWindows3_1 = COMAdminOS.Windows3_1;
|
|
pub const COMAdminOSWindows9x = COMAdminOS.Windows9x;
|
|
pub const COMAdminOSWindows2000 = COMAdminOS.Windows2000;
|
|
pub const COMAdminOSWindows2000AdvancedServer = COMAdminOS.Windows2000AdvancedServer;
|
|
pub const COMAdminOSWindows2000Unknown = COMAdminOS.Windows2000Unknown;
|
|
pub const COMAdminOSUnknown = COMAdminOS.Unknown;
|
|
pub const COMAdminOSWindowsXPPersonal = COMAdminOS.WindowsXPPersonal;
|
|
pub const COMAdminOSWindowsXPProfessional = COMAdminOS.WindowsXPProfessional;
|
|
pub const COMAdminOSWindowsNETStandardServer = COMAdminOS.WindowsNETStandardServer;
|
|
pub const COMAdminOSWindowsNETEnterpriseServer = COMAdminOS.WindowsNETEnterpriseServer;
|
|
pub const COMAdminOSWindowsNETDatacenterServer = COMAdminOS.WindowsNETDatacenterServer;
|
|
pub const COMAdminOSWindowsNETWebServer = COMAdminOS.WindowsNETWebServer;
|
|
pub const COMAdminOSWindowsLonghornPersonal = COMAdminOS.WindowsLonghornPersonal;
|
|
pub const COMAdminOSWindowsLonghornProfessional = COMAdminOS.WindowsLonghornProfessional;
|
|
pub const COMAdminOSWindowsLonghornStandardServer = COMAdminOS.WindowsLonghornStandardServer;
|
|
pub const COMAdminOSWindowsLonghornEnterpriseServer = COMAdminOS.WindowsLonghornEnterpriseServer;
|
|
pub const COMAdminOSWindowsLonghornDatacenterServer = COMAdminOS.WindowsLonghornDatacenterServer;
|
|
pub const COMAdminOSWindowsLonghornWebServer = COMAdminOS.WindowsLonghornWebServer;
|
|
pub const COMAdminOSWindows7Personal = COMAdminOS.Windows7Personal;
|
|
pub const COMAdminOSWindows7Professional = COMAdminOS.Windows7Professional;
|
|
pub const COMAdminOSWindows7StandardServer = COMAdminOS.Windows7StandardServer;
|
|
pub const COMAdminOSWindows7EnterpriseServer = COMAdminOS.Windows7EnterpriseServer;
|
|
pub const COMAdminOSWindows7DatacenterServer = COMAdminOS.Windows7DatacenterServer;
|
|
pub const COMAdminOSWindows7WebServer = COMAdminOS.Windows7WebServer;
|
|
pub const COMAdminOSWindows8Personal = COMAdminOS.Windows8Personal;
|
|
pub const COMAdminOSWindows8Professional = COMAdminOS.Windows8Professional;
|
|
pub const COMAdminOSWindows8StandardServer = COMAdminOS.Windows8StandardServer;
|
|
pub const COMAdminOSWindows8EnterpriseServer = COMAdminOS.Windows8EnterpriseServer;
|
|
pub const COMAdminOSWindows8DatacenterServer = COMAdminOS.Windows8DatacenterServer;
|
|
pub const COMAdminOSWindows8WebServer = COMAdminOS.Windows8WebServer;
|
|
pub const COMAdminOSWindowsBluePersonal = COMAdminOS.WindowsBluePersonal;
|
|
pub const COMAdminOSWindowsBlueProfessional = COMAdminOS.WindowsBlueProfessional;
|
|
pub const COMAdminOSWindowsBlueStandardServer = COMAdminOS.WindowsBlueStandardServer;
|
|
pub const COMAdminOSWindowsBlueEnterpriseServer = COMAdminOS.WindowsBlueEnterpriseServer;
|
|
pub const COMAdminOSWindowsBlueDatacenterServer = COMAdminOS.WindowsBlueDatacenterServer;
|
|
pub const COMAdminOSWindowsBlueWebServer = COMAdminOS.WindowsBlueWebServer;
|
|
|
|
pub const COMAdminServiceOptions = enum(i32) {
|
|
r = 1,
|
|
};
|
|
pub const COMAdminServiceLoadBalanceRouter = COMAdminServiceOptions.r;
|
|
|
|
pub const COMAdminServiceStatusOptions = enum(i32) {
|
|
Stopped = 0,
|
|
StartPending = 1,
|
|
StopPending = 2,
|
|
Running = 3,
|
|
ContinuePending = 4,
|
|
PausePending = 5,
|
|
Paused = 6,
|
|
UnknownState = 7,
|
|
};
|
|
pub const COMAdminServiceStopped = COMAdminServiceStatusOptions.Stopped;
|
|
pub const COMAdminServiceStartPending = COMAdminServiceStatusOptions.StartPending;
|
|
pub const COMAdminServiceStopPending = COMAdminServiceStatusOptions.StopPending;
|
|
pub const COMAdminServiceRunning = COMAdminServiceStatusOptions.Running;
|
|
pub const COMAdminServiceContinuePending = COMAdminServiceStatusOptions.ContinuePending;
|
|
pub const COMAdminServicePausePending = COMAdminServiceStatusOptions.PausePending;
|
|
pub const COMAdminServicePaused = COMAdminServiceStatusOptions.Paused;
|
|
pub const COMAdminServiceUnknownState = COMAdminServiceStatusOptions.UnknownState;
|
|
|
|
pub const COMAdminQCMessageAuthenticateOptions = enum(i32) {
|
|
SecureApps = 0,
|
|
Off = 1,
|
|
On = 2,
|
|
};
|
|
pub const COMAdminQCMessageAuthenticateSecureApps = COMAdminQCMessageAuthenticateOptions.SecureApps;
|
|
pub const COMAdminQCMessageAuthenticateOff = COMAdminQCMessageAuthenticateOptions.Off;
|
|
pub const COMAdminQCMessageAuthenticateOn = COMAdminQCMessageAuthenticateOptions.On;
|
|
|
|
pub const COMAdminFileFlags = enum(i32) {
|
|
Loadable = 1,
|
|
COM = 2,
|
|
ContainsPS = 4,
|
|
ContainsComp = 8,
|
|
ContainsTLB = 16,
|
|
SelfReg = 32,
|
|
SelfUnReg = 64,
|
|
UnloadableDLL = 128,
|
|
DoesNotExist = 256,
|
|
AlreadyInstalled = 512,
|
|
BadTLB = 1024,
|
|
GetClassObjFailed = 2048,
|
|
ClassNotAvailable = 4096,
|
|
Registrar = 8192,
|
|
NoRegistrar = 16384,
|
|
DLLRegsvrFailed = 32768,
|
|
RegTLBFailed = 65536,
|
|
RegistrarFailed = 131072,
|
|
Error = 262144,
|
|
};
|
|
pub const COMAdminFileFlagLoadable = COMAdminFileFlags.Loadable;
|
|
pub const COMAdminFileFlagCOM = COMAdminFileFlags.COM;
|
|
pub const COMAdminFileFlagContainsPS = COMAdminFileFlags.ContainsPS;
|
|
pub const COMAdminFileFlagContainsComp = COMAdminFileFlags.ContainsComp;
|
|
pub const COMAdminFileFlagContainsTLB = COMAdminFileFlags.ContainsTLB;
|
|
pub const COMAdminFileFlagSelfReg = COMAdminFileFlags.SelfReg;
|
|
pub const COMAdminFileFlagSelfUnReg = COMAdminFileFlags.SelfUnReg;
|
|
pub const COMAdminFileFlagUnloadableDLL = COMAdminFileFlags.UnloadableDLL;
|
|
pub const COMAdminFileFlagDoesNotExist = COMAdminFileFlags.DoesNotExist;
|
|
pub const COMAdminFileFlagAlreadyInstalled = COMAdminFileFlags.AlreadyInstalled;
|
|
pub const COMAdminFileFlagBadTLB = COMAdminFileFlags.BadTLB;
|
|
pub const COMAdminFileFlagGetClassObjFailed = COMAdminFileFlags.GetClassObjFailed;
|
|
pub const COMAdminFileFlagClassNotAvailable = COMAdminFileFlags.ClassNotAvailable;
|
|
pub const COMAdminFileFlagRegistrar = COMAdminFileFlags.Registrar;
|
|
pub const COMAdminFileFlagNoRegistrar = COMAdminFileFlags.NoRegistrar;
|
|
pub const COMAdminFileFlagDLLRegsvrFailed = COMAdminFileFlags.DLLRegsvrFailed;
|
|
pub const COMAdminFileFlagRegTLBFailed = COMAdminFileFlags.RegTLBFailed;
|
|
pub const COMAdminFileFlagRegistrarFailed = COMAdminFileFlags.RegistrarFailed;
|
|
pub const COMAdminFileFlagError = COMAdminFileFlags.Error;
|
|
|
|
pub const COMAdminComponentFlags = enum(i32) {
|
|
TypeInfoFound = 1,
|
|
COMPlusPropertiesFound = 2,
|
|
ProxyFound = 4,
|
|
InterfacesFound = 8,
|
|
AlreadyInstalled = 16,
|
|
NotInApplication = 32,
|
|
};
|
|
pub const COMAdminCompFlagTypeInfoFound = COMAdminComponentFlags.TypeInfoFound;
|
|
pub const COMAdminCompFlagCOMPlusPropertiesFound = COMAdminComponentFlags.COMPlusPropertiesFound;
|
|
pub const COMAdminCompFlagProxyFound = COMAdminComponentFlags.ProxyFound;
|
|
pub const COMAdminCompFlagInterfacesFound = COMAdminComponentFlags.InterfacesFound;
|
|
pub const COMAdminCompFlagAlreadyInstalled = COMAdminComponentFlags.AlreadyInstalled;
|
|
pub const COMAdminCompFlagNotInApplication = COMAdminComponentFlags.NotInApplication;
|
|
|
|
pub const COMAdminErrorCodes = enum(i32) {
|
|
ObjectErrors = -2146368511,
|
|
ObjectInvalid = -2146368510,
|
|
KeyMissing = -2146368509,
|
|
AlreadyInstalled = -2146368508,
|
|
AppFileWriteFail = -2146368505,
|
|
AppFileReadFail = -2146368504,
|
|
AppFileVersion = -2146368503,
|
|
BadPath = -2146368502,
|
|
ApplicationExists = -2146368501,
|
|
RoleExists = -2146368500,
|
|
CantCopyFile = -2146368499,
|
|
NoUser = -2146368497,
|
|
InvalidUserids = -2146368496,
|
|
NoRegistryCLSID = -2146368495,
|
|
BadRegistryProgID = -2146368494,
|
|
AuthenticationLevel = -2146368493,
|
|
UserPasswdNotValid = -2146368492,
|
|
CLSIDOrIIDMismatch = -2146368488,
|
|
RemoteInterface = -2146368487,
|
|
DllRegisterServer = -2146368486,
|
|
NoServerShare = -2146368485,
|
|
DllLoadFailed = -2146368483,
|
|
BadRegistryLibID = -2146368482,
|
|
AppDirNotFound = -2146368481,
|
|
RegistrarFailed = -2146368477,
|
|
CompFileDoesNotExist = -2146368476,
|
|
CompFileLoadDLLFail = -2146368475,
|
|
CompFileGetClassObj = -2146368474,
|
|
CompFileClassNotAvail = -2146368473,
|
|
CompFileBadTLB = -2146368472,
|
|
CompFileNotInstallable = -2146368471,
|
|
NotChangeable = -2146368470,
|
|
NotDeletable = -2146368469,
|
|
Session = -2146368468,
|
|
CompMoveLocked = -2146368467,
|
|
CompMoveBadDest = -2146368466,
|
|
RegisterTLB = -2146368464,
|
|
SystemApp = -2146368461,
|
|
CompFileNoRegistrar = -2146368460,
|
|
CoReqCompInstalled = -2146368459,
|
|
ServiceNotInstalled = -2146368458,
|
|
PropertySaveFailed = -2146368457,
|
|
ObjectExists = -2146368456,
|
|
ComponentExists = -2146368455,
|
|
RegFileCorrupt = -2146368453,
|
|
PropertyOverflow = -2146368452,
|
|
NotInRegistry = -2146368450,
|
|
ObjectNotPoolable = -2146368449,
|
|
ApplidMatchesClsid = -2146368442,
|
|
RoleDoesNotExist = -2146368441,
|
|
StartAppNeedsComponents = -2146368440,
|
|
RequiresDifferentPlatform = -2146368439,
|
|
QueuingServiceNotAvailable = -2146367998,
|
|
ObjectParentMissing = -2146367480,
|
|
ObjectDoesNotExist = -2146367479,
|
|
CanNotExportAppProxy = -2146368438,
|
|
CanNotStartApp = -2146368437,
|
|
CanNotExportSystemApp = -2146368436,
|
|
CanNotSubscribeToComponent = -2146368435,
|
|
AppNotRunning = -2146367478,
|
|
EventClassCannotBeSubscriber = -2146368434,
|
|
LibAppProxyIncompatible = -2146368433,
|
|
BasePartitionOnly = -2146368432,
|
|
DuplicatePartitionName = -2146368425,
|
|
PartitionInUse = -2146368423,
|
|
ImportedComponentsNotAllowed = -2146368421,
|
|
RegdbNotInitialized = -2146368398,
|
|
RegdbNotOpen = -2146368397,
|
|
RegdbSystemErr = -2146368396,
|
|
RegdbAlreadyRunning = -2146368395,
|
|
MigVersionNotSupported = -2146368384,
|
|
MigSchemaNotFound = -2146368383,
|
|
CatBitnessMismatch = -2146368382,
|
|
CatUnacceptableBitness = -2146368381,
|
|
CatWrongAppBitnessBitness = -2146368380,
|
|
CatPauseResumeNotSupported = -2146368379,
|
|
CatServerFault = -2146368378,
|
|
CantRecycleLibraryApps = -2146367473,
|
|
CantRecycleServiceApps = -2146367471,
|
|
ProcessAlreadyRecycled = -2146367470,
|
|
PausedProcessMayNotBeRecycled = -2146367469,
|
|
InvalidPartition = -2146367477,
|
|
PartitionMsiOnly = -2146367463,
|
|
StartAppDisabled = -2146368431,
|
|
CompMoveSource = -2146367460,
|
|
CompMoveDest = -2146367459,
|
|
CompMovePrivate = -2146367458,
|
|
CannotCopyEventClass = -2146367456,
|
|
};
|
|
pub const COMAdminErrObjectErrors = COMAdminErrorCodes.ObjectErrors;
|
|
pub const COMAdminErrObjectInvalid = COMAdminErrorCodes.ObjectInvalid;
|
|
pub const COMAdminErrKeyMissing = COMAdminErrorCodes.KeyMissing;
|
|
pub const COMAdminErrAlreadyInstalled = COMAdminErrorCodes.AlreadyInstalled;
|
|
pub const COMAdminErrAppFileWriteFail = COMAdminErrorCodes.AppFileWriteFail;
|
|
pub const COMAdminErrAppFileReadFail = COMAdminErrorCodes.AppFileReadFail;
|
|
pub const COMAdminErrAppFileVersion = COMAdminErrorCodes.AppFileVersion;
|
|
pub const COMAdminErrBadPath = COMAdminErrorCodes.BadPath;
|
|
pub const COMAdminErrApplicationExists = COMAdminErrorCodes.ApplicationExists;
|
|
pub const COMAdminErrRoleExists = COMAdminErrorCodes.RoleExists;
|
|
pub const COMAdminErrCantCopyFile = COMAdminErrorCodes.CantCopyFile;
|
|
pub const COMAdminErrNoUser = COMAdminErrorCodes.NoUser;
|
|
pub const COMAdminErrInvalidUserids = COMAdminErrorCodes.InvalidUserids;
|
|
pub const COMAdminErrNoRegistryCLSID = COMAdminErrorCodes.NoRegistryCLSID;
|
|
pub const COMAdminErrBadRegistryProgID = COMAdminErrorCodes.BadRegistryProgID;
|
|
pub const COMAdminErrAuthenticationLevel = COMAdminErrorCodes.AuthenticationLevel;
|
|
pub const COMAdminErrUserPasswdNotValid = COMAdminErrorCodes.UserPasswdNotValid;
|
|
pub const COMAdminErrCLSIDOrIIDMismatch = COMAdminErrorCodes.CLSIDOrIIDMismatch;
|
|
pub const COMAdminErrRemoteInterface = COMAdminErrorCodes.RemoteInterface;
|
|
pub const COMAdminErrDllRegisterServer = COMAdminErrorCodes.DllRegisterServer;
|
|
pub const COMAdminErrNoServerShare = COMAdminErrorCodes.NoServerShare;
|
|
pub const COMAdminErrDllLoadFailed = COMAdminErrorCodes.DllLoadFailed;
|
|
pub const COMAdminErrBadRegistryLibID = COMAdminErrorCodes.BadRegistryLibID;
|
|
pub const COMAdminErrAppDirNotFound = COMAdminErrorCodes.AppDirNotFound;
|
|
pub const COMAdminErrRegistrarFailed = COMAdminErrorCodes.RegistrarFailed;
|
|
pub const COMAdminErrCompFileDoesNotExist = COMAdminErrorCodes.CompFileDoesNotExist;
|
|
pub const COMAdminErrCompFileLoadDLLFail = COMAdminErrorCodes.CompFileLoadDLLFail;
|
|
pub const COMAdminErrCompFileGetClassObj = COMAdminErrorCodes.CompFileGetClassObj;
|
|
pub const COMAdminErrCompFileClassNotAvail = COMAdminErrorCodes.CompFileClassNotAvail;
|
|
pub const COMAdminErrCompFileBadTLB = COMAdminErrorCodes.CompFileBadTLB;
|
|
pub const COMAdminErrCompFileNotInstallable = COMAdminErrorCodes.CompFileNotInstallable;
|
|
pub const COMAdminErrNotChangeable = COMAdminErrorCodes.NotChangeable;
|
|
pub const COMAdminErrNotDeletable = COMAdminErrorCodes.NotDeletable;
|
|
pub const COMAdminErrSession = COMAdminErrorCodes.Session;
|
|
pub const COMAdminErrCompMoveLocked = COMAdminErrorCodes.CompMoveLocked;
|
|
pub const COMAdminErrCompMoveBadDest = COMAdminErrorCodes.CompMoveBadDest;
|
|
pub const COMAdminErrRegisterTLB = COMAdminErrorCodes.RegisterTLB;
|
|
pub const COMAdminErrSystemApp = COMAdminErrorCodes.SystemApp;
|
|
pub const COMAdminErrCompFileNoRegistrar = COMAdminErrorCodes.CompFileNoRegistrar;
|
|
pub const COMAdminErrCoReqCompInstalled = COMAdminErrorCodes.CoReqCompInstalled;
|
|
pub const COMAdminErrServiceNotInstalled = COMAdminErrorCodes.ServiceNotInstalled;
|
|
pub const COMAdminErrPropertySaveFailed = COMAdminErrorCodes.PropertySaveFailed;
|
|
pub const COMAdminErrObjectExists = COMAdminErrorCodes.ObjectExists;
|
|
pub const COMAdminErrComponentExists = COMAdminErrorCodes.ComponentExists;
|
|
pub const COMAdminErrRegFileCorrupt = COMAdminErrorCodes.RegFileCorrupt;
|
|
pub const COMAdminErrPropertyOverflow = COMAdminErrorCodes.PropertyOverflow;
|
|
pub const COMAdminErrNotInRegistry = COMAdminErrorCodes.NotInRegistry;
|
|
pub const COMAdminErrObjectNotPoolable = COMAdminErrorCodes.ObjectNotPoolable;
|
|
pub const COMAdminErrApplidMatchesClsid = COMAdminErrorCodes.ApplidMatchesClsid;
|
|
pub const COMAdminErrRoleDoesNotExist = COMAdminErrorCodes.RoleDoesNotExist;
|
|
pub const COMAdminErrStartAppNeedsComponents = COMAdminErrorCodes.StartAppNeedsComponents;
|
|
pub const COMAdminErrRequiresDifferentPlatform = COMAdminErrorCodes.RequiresDifferentPlatform;
|
|
pub const COMAdminErrQueuingServiceNotAvailable = COMAdminErrorCodes.QueuingServiceNotAvailable;
|
|
pub const COMAdminErrObjectParentMissing = COMAdminErrorCodes.ObjectParentMissing;
|
|
pub const COMAdminErrObjectDoesNotExist = COMAdminErrorCodes.ObjectDoesNotExist;
|
|
pub const COMAdminErrCanNotExportAppProxy = COMAdminErrorCodes.CanNotExportAppProxy;
|
|
pub const COMAdminErrCanNotStartApp = COMAdminErrorCodes.CanNotStartApp;
|
|
pub const COMAdminErrCanNotExportSystemApp = COMAdminErrorCodes.CanNotExportSystemApp;
|
|
pub const COMAdminErrCanNotSubscribeToComponent = COMAdminErrorCodes.CanNotSubscribeToComponent;
|
|
pub const COMAdminErrAppNotRunning = COMAdminErrorCodes.AppNotRunning;
|
|
pub const COMAdminErrEventClassCannotBeSubscriber = COMAdminErrorCodes.EventClassCannotBeSubscriber;
|
|
pub const COMAdminErrLibAppProxyIncompatible = COMAdminErrorCodes.LibAppProxyIncompatible;
|
|
pub const COMAdminErrBasePartitionOnly = COMAdminErrorCodes.BasePartitionOnly;
|
|
pub const COMAdminErrDuplicatePartitionName = COMAdminErrorCodes.DuplicatePartitionName;
|
|
pub const COMAdminErrPartitionInUse = COMAdminErrorCodes.PartitionInUse;
|
|
pub const COMAdminErrImportedComponentsNotAllowed = COMAdminErrorCodes.ImportedComponentsNotAllowed;
|
|
pub const COMAdminErrRegdbNotInitialized = COMAdminErrorCodes.RegdbNotInitialized;
|
|
pub const COMAdminErrRegdbNotOpen = COMAdminErrorCodes.RegdbNotOpen;
|
|
pub const COMAdminErrRegdbSystemErr = COMAdminErrorCodes.RegdbSystemErr;
|
|
pub const COMAdminErrRegdbAlreadyRunning = COMAdminErrorCodes.RegdbAlreadyRunning;
|
|
pub const COMAdminErrMigVersionNotSupported = COMAdminErrorCodes.MigVersionNotSupported;
|
|
pub const COMAdminErrMigSchemaNotFound = COMAdminErrorCodes.MigSchemaNotFound;
|
|
pub const COMAdminErrCatBitnessMismatch = COMAdminErrorCodes.CatBitnessMismatch;
|
|
pub const COMAdminErrCatUnacceptableBitness = COMAdminErrorCodes.CatUnacceptableBitness;
|
|
pub const COMAdminErrCatWrongAppBitnessBitness = COMAdminErrorCodes.CatWrongAppBitnessBitness;
|
|
pub const COMAdminErrCatPauseResumeNotSupported = COMAdminErrorCodes.CatPauseResumeNotSupported;
|
|
pub const COMAdminErrCatServerFault = COMAdminErrorCodes.CatServerFault;
|
|
pub const COMAdminErrCantRecycleLibraryApps = COMAdminErrorCodes.CantRecycleLibraryApps;
|
|
pub const COMAdminErrCantRecycleServiceApps = COMAdminErrorCodes.CantRecycleServiceApps;
|
|
pub const COMAdminErrProcessAlreadyRecycled = COMAdminErrorCodes.ProcessAlreadyRecycled;
|
|
pub const COMAdminErrPausedProcessMayNotBeRecycled = COMAdminErrorCodes.PausedProcessMayNotBeRecycled;
|
|
pub const COMAdminErrInvalidPartition = COMAdminErrorCodes.InvalidPartition;
|
|
pub const COMAdminErrPartitionMsiOnly = COMAdminErrorCodes.PartitionMsiOnly;
|
|
pub const COMAdminErrStartAppDisabled = COMAdminErrorCodes.StartAppDisabled;
|
|
pub const COMAdminErrCompMoveSource = COMAdminErrorCodes.CompMoveSource;
|
|
pub const COMAdminErrCompMoveDest = COMAdminErrorCodes.CompMoveDest;
|
|
pub const COMAdminErrCompMovePrivate = COMAdminErrorCodes.CompMovePrivate;
|
|
pub const COMAdminErrCannotCopyEventClass = COMAdminErrorCodes.CannotCopyEventClass;
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISecurityIdentityColl_Value = Guid.initString("cafc823c-b441-11d1-b82b-0000f8757e2a");
|
|
pub const IID_ISecurityIdentityColl = &IID_ISecurityIdentityColl_Value;
|
|
pub const ISecurityIdentityColl = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityIdentityColl,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityIdentityColl,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Item: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityIdentityColl,
|
|
name: ?BSTR,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityIdentityColl,
|
|
name: ?BSTR,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get__NewEnum: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityIdentityColl,
|
|
ppEnum: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityIdentityColl,
|
|
ppEnum: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityIdentityColl_get_Count(self: *const T, plCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityIdentityColl.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ISecurityIdentityColl, @ptrCast(self)), plCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityIdentityColl_get_Item(self: *const T, name: ?BSTR, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityIdentityColl.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ISecurityIdentityColl, @ptrCast(self)), name, pItem);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityIdentityColl_get__NewEnum(self: *const T, ppEnum: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityIdentityColl.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ISecurityIdentityColl, @ptrCast(self)), ppEnum);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISecurityCallersColl_Value = Guid.initString("cafc823d-b441-11d1-b82b-0000f8757e2a");
|
|
pub const IID_ISecurityCallersColl = &IID_ISecurityCallersColl_Value;
|
|
pub const ISecurityCallersColl = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallersColl,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityCallersColl,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Item: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallersColl,
|
|
lIndex: i32,
|
|
pObj: ?*?*ISecurityIdentityColl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityCallersColl,
|
|
lIndex: i32,
|
|
pObj: ?*?*ISecurityIdentityColl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get__NewEnum: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallersColl,
|
|
ppEnum: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityCallersColl,
|
|
ppEnum: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallersColl_get_Count(self: *const T, plCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallersColl.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ISecurityCallersColl, @ptrCast(self)), plCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallersColl_get_Item(self: *const T, lIndex: i32, pObj: ?*?*ISecurityIdentityColl) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallersColl.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ISecurityCallersColl, @ptrCast(self)), lIndex, pObj);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallersColl_get__NewEnum(self: *const T, ppEnum: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallersColl.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ISecurityCallersColl, @ptrCast(self)), ppEnum);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISecurityCallContext_Value = Guid.initString("cafc823e-b441-11d1-b82b-0000f8757e2a");
|
|
pub const IID_ISecurityCallContext = &IID_ISecurityCallContext_Value;
|
|
pub const ISecurityCallContext = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallContext,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityCallContext,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Item: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallContext,
|
|
name: ?BSTR,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityCallContext,
|
|
name: ?BSTR,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get__NewEnum: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallContext,
|
|
ppEnum: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISecurityCallContext,
|
|
ppEnum: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsCallerInRole: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallContext,
|
|
bstrRole: ?BSTR,
|
|
pfInRole: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISecurityCallContext,
|
|
bstrRole: ?BSTR,
|
|
pfInRole: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsSecurityEnabled: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallContext,
|
|
pfIsEnabled: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISecurityCallContext,
|
|
pfIsEnabled: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsUserInRole: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISecurityCallContext,
|
|
pUser: ?*VARIANT,
|
|
bstrRole: ?BSTR,
|
|
pfInRole: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISecurityCallContext,
|
|
pUser: ?*VARIANT,
|
|
bstrRole: ?BSTR,
|
|
pfInRole: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallContext_get_Count(self: *const T, plCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ISecurityCallContext, @ptrCast(self)), plCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallContext_get_Item(self: *const T, name: ?BSTR, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ISecurityCallContext, @ptrCast(self)), name, pItem);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallContext_get__NewEnum(self: *const T, ppEnum: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ISecurityCallContext, @ptrCast(self)), ppEnum);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallContext_IsCallerInRole(self: *const T, bstrRole: ?BSTR, pfInRole: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).IsCallerInRole(@as(*const ISecurityCallContext, @ptrCast(self)), bstrRole, pfInRole);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallContext_IsSecurityEnabled(self: *const T, pfIsEnabled: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).IsSecurityEnabled(@as(*const ISecurityCallContext, @ptrCast(self)), pfIsEnabled);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityCallContext_IsUserInRole(self: *const T, pUser: ?*VARIANT, bstrRole: ?BSTR, pfInRole: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityCallContext.VTable, @ptrCast(self.vtable)).IsUserInRole(@as(*const ISecurityCallContext, @ptrCast(self)), pUser, bstrRole, pfInRole);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IGetSecurityCallContext_Value = Guid.initString("cafc823f-b441-11d1-b82b-0000f8757e2a");
|
|
pub const IID_IGetSecurityCallContext = &IID_IGetSecurityCallContext_Value;
|
|
pub const IGetSecurityCallContext = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
GetSecurityCallContext: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetSecurityCallContext,
|
|
ppObject: ?*?*ISecurityCallContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetSecurityCallContext,
|
|
ppObject: ?*?*ISecurityCallContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetSecurityCallContext_GetSecurityCallContext(self: *const T, ppObject: ?*?*ISecurityCallContext) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetSecurityCallContext.VTable, @ptrCast(self.vtable)).GetSecurityCallContext(@as(*const IGetSecurityCallContext, @ptrCast(self)), ppObject);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_SecurityProperty_Value = Guid.initString("e74a7215-014d-11d1-a63c-00a0c911b4e0");
|
|
pub const IID_SecurityProperty = &IID_SecurityProperty_Value;
|
|
pub const SecurityProperty = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
GetDirectCallerName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const SecurityProperty,
|
|
bstrUserName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const SecurityProperty,
|
|
bstrUserName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetDirectCreatorName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const SecurityProperty,
|
|
bstrUserName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const SecurityProperty,
|
|
bstrUserName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOriginalCallerName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const SecurityProperty,
|
|
bstrUserName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const SecurityProperty,
|
|
bstrUserName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOriginalCreatorName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const SecurityProperty,
|
|
bstrUserName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const SecurityProperty,
|
|
bstrUserName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn SecurityProperty_GetDirectCallerName(self: *const T, bstrUserName: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const SecurityProperty.VTable, @ptrCast(self.vtable)).GetDirectCallerName(@as(*const SecurityProperty, @ptrCast(self)), bstrUserName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn SecurityProperty_GetDirectCreatorName(self: *const T, bstrUserName: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const SecurityProperty.VTable, @ptrCast(self.vtable)).GetDirectCreatorName(@as(*const SecurityProperty, @ptrCast(self)), bstrUserName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn SecurityProperty_GetOriginalCallerName(self: *const T, bstrUserName: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const SecurityProperty.VTable, @ptrCast(self.vtable)).GetOriginalCallerName(@as(*const SecurityProperty, @ptrCast(self)), bstrUserName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn SecurityProperty_GetOriginalCreatorName(self: *const T, bstrUserName: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const SecurityProperty.VTable, @ptrCast(self.vtable)).GetOriginalCreatorName(@as(*const SecurityProperty, @ptrCast(self)), bstrUserName);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ContextInfo_Value = Guid.initString("19a5a02c-0ac8-11d2-b286-00c04f8ef934");
|
|
pub const IID_ContextInfo = &IID_ContextInfo_Value;
|
|
pub const ContextInfo = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
IsInTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ContextInfo,
|
|
pbIsInTx: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ContextInfo,
|
|
pbIsInTx: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ContextInfo,
|
|
ppTx: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ContextInfo,
|
|
ppTx: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTransactionId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ContextInfo,
|
|
pbstrTxId: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ContextInfo,
|
|
pbstrTxId: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetActivityId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ContextInfo,
|
|
pbstrActivityId: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ContextInfo,
|
|
pbstrActivityId: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetContextId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ContextInfo,
|
|
pbstrCtxId: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ContextInfo,
|
|
pbstrCtxId: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ContextInfo_IsInTransaction(self: *const T, pbIsInTx: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).IsInTransaction(@as(*const ContextInfo, @ptrCast(self)), pbIsInTx);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ContextInfo_GetTransaction(self: *const T, ppTx: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).GetTransaction(@as(*const ContextInfo, @ptrCast(self)), ppTx);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ContextInfo_GetTransactionId(self: *const T, pbstrTxId: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).GetTransactionId(@as(*const ContextInfo, @ptrCast(self)), pbstrTxId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ContextInfo_GetActivityId(self: *const T, pbstrActivityId: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).GetActivityId(@as(*const ContextInfo, @ptrCast(self)), pbstrActivityId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ContextInfo_GetContextId(self: *const T, pbstrCtxId: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ContextInfo.VTable, @ptrCast(self.vtable)).GetContextId(@as(*const ContextInfo, @ptrCast(self)), pbstrCtxId);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_ContextInfo2_Value = Guid.initString("c99d6e75-2375-11d4-8331-00c04f605588");
|
|
pub const IID_ContextInfo2 = &IID_ContextInfo2_Value;
|
|
pub const ContextInfo2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: ContextInfo.VTable,
|
|
GetPartitionId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ContextInfo2,
|
|
__MIDL__ContextInfo20000: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ContextInfo2,
|
|
__MIDL__ContextInfo20000: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetApplicationId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ContextInfo2,
|
|
__MIDL__ContextInfo20001: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ContextInfo2,
|
|
__MIDL__ContextInfo20001: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetApplicationInstanceId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ContextInfo2,
|
|
__MIDL__ContextInfo20002: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ContextInfo2,
|
|
__MIDL__ContextInfo20002: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace ContextInfo.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ContextInfo2_GetPartitionId(self: *const T, __MIDL__ContextInfo20000: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ContextInfo2.VTable, @ptrCast(self.vtable)).GetPartitionId(@as(*const ContextInfo2, @ptrCast(self)), __MIDL__ContextInfo20000);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ContextInfo2_GetApplicationId(self: *const T, __MIDL__ContextInfo20001: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ContextInfo2.VTable, @ptrCast(self.vtable)).GetApplicationId(@as(*const ContextInfo2, @ptrCast(self)), __MIDL__ContextInfo20001);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ContextInfo2_GetApplicationInstanceId(self: *const T, __MIDL__ContextInfo20002: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ContextInfo2.VTable, @ptrCast(self.vtable)).GetApplicationInstanceId(@as(*const ContextInfo2, @ptrCast(self)), __MIDL__ContextInfo20002);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ObjectContext_Value = Guid.initString("74c08646-cedb-11cf-8b49-00aa00b8a790");
|
|
pub const IID_ObjectContext = &IID_ObjectContext_Value;
|
|
pub const ObjectContext = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
CreateInstance: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
bstrProgID: ?BSTR,
|
|
pObject: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
bstrProgID: ?BSTR,
|
|
pObject: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetComplete: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnableCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DisableCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsInTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
pbIsInTx: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
pbIsInTx: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsSecurityEnabled: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
pbIsEnabled: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
pbIsEnabled: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsCallerInRole: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
bstrRole: ?BSTR,
|
|
pbInRole: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
bstrRole: ?BSTR,
|
|
pbInRole: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Item: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
name: ?BSTR,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
name: ?BSTR,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get__NewEnum: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
ppEnum: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
ppEnum: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Security: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
ppSecurityProperty: ?*?*SecurityProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
ppSecurityProperty: ?*?*SecurityProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_ContextInfo: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ObjectContext,
|
|
ppContextInfo: ?*?*ContextInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ObjectContext,
|
|
ppContextInfo: ?*?*ContextInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_CreateInstance(self: *const T, bstrProgID: ?BSTR, pObject: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ObjectContext, @ptrCast(self)), bstrProgID, pObject);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_SetComplete(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).SetComplete(@as(*const ObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_SetAbort(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).SetAbort(@as(*const ObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_EnableCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).EnableCommit(@as(*const ObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_DisableCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).DisableCommit(@as(*const ObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_IsInTransaction(self: *const T, pbIsInTx: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).IsInTransaction(@as(*const ObjectContext, @ptrCast(self)), pbIsInTx);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_IsSecurityEnabled(self: *const T, pbIsEnabled: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).IsSecurityEnabled(@as(*const ObjectContext, @ptrCast(self)), pbIsEnabled);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_IsCallerInRole(self: *const T, bstrRole: ?BSTR, pbInRole: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).IsCallerInRole(@as(*const ObjectContext, @ptrCast(self)), bstrRole, pbInRole);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_get_Count(self: *const T, plCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ObjectContext, @ptrCast(self)), plCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_get_Item(self: *const T, name: ?BSTR, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get_Item(@as(*const ObjectContext, @ptrCast(self)), name, pItem);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_get__NewEnum(self: *const T, ppEnum: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ObjectContext, @ptrCast(self)), ppEnum);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_get_Security(self: *const T, ppSecurityProperty: ?*?*SecurityProperty) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get_Security(@as(*const ObjectContext, @ptrCast(self)), ppSecurityProperty);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectContext_get_ContextInfo(self: *const T, ppContextInfo: ?*?*ContextInfo) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectContext.VTable, @ptrCast(self.vtable)).get_ContextInfo(@as(*const ObjectContext, @ptrCast(self)), ppContextInfo);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ITransactionContextEx_Value = Guid.initString("7999fc22-d3c6-11cf-acab-00a024a55aef");
|
|
pub const IID_ITransactionContextEx = &IID_ITransactionContextEx_Value;
|
|
pub const ITransactionContextEx = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateInstance: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionContextEx,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
pObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionContextEx,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
pObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Commit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionContextEx,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionContextEx,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Abort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionContextEx,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionContextEx,
|
|
) 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 ITransactionContextEx_CreateInstance(self: *const T, rclsid: ?*const Guid, riid: ?*const Guid, pObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionContextEx.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ITransactionContextEx, @ptrCast(self)), rclsid, riid, pObject);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionContextEx_Commit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionContextEx.VTable, @ptrCast(self.vtable)).Commit(@as(*const ITransactionContextEx, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionContextEx_Abort(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionContextEx.VTable, @ptrCast(self.vtable)).Abort(@as(*const ITransactionContextEx, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ITransactionContext_Value = Guid.initString("7999fc21-d3c6-11cf-acab-00a024a55aef");
|
|
pub const IID_ITransactionContext = &IID_ITransactionContext_Value;
|
|
pub const ITransactionContext = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
CreateInstance: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionContext,
|
|
pszProgId: ?BSTR,
|
|
pObject: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionContext,
|
|
pszProgId: ?BSTR,
|
|
pObject: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Commit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Abort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionContext_CreateInstance(self: *const T, pszProgId: ?BSTR, pObject: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionContext.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ITransactionContext, @ptrCast(self)), pszProgId, pObject);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionContext_Commit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionContext.VTable, @ptrCast(self.vtable)).Commit(@as(*const ITransactionContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionContext_Abort(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionContext.VTable, @ptrCast(self.vtable)).Abort(@as(*const ITransactionContext, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICreateWithTransactionEx_Value = Guid.initString("455acf57-5345-11d2-99cf-00c04f797bc9");
|
|
pub const IID_ICreateWithTransactionEx = &IID_ICreateWithTransactionEx_Value;
|
|
pub const ICreateWithTransactionEx = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateInstance: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICreateWithTransactionEx,
|
|
pTransaction: ?*ITransaction,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
pObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICreateWithTransactionEx,
|
|
pTransaction: ?*ITransaction,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
pObject: ?*?*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 ICreateWithTransactionEx_CreateInstance(self: *const T, pTransaction: ?*ITransaction, rclsid: ?*const Guid, riid: ?*const Guid, pObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const ICreateWithTransactionEx.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ICreateWithTransactionEx, @ptrCast(self)), pTransaction, rclsid, riid, pObject);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_ICreateWithLocalTransaction_Value = Guid.initString("227ac7a8-8423-42ce-b7cf-03061ec9aaa3");
|
|
pub const IID_ICreateWithLocalTransaction = &IID_ICreateWithLocalTransaction_Value;
|
|
pub const ICreateWithLocalTransaction = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateInstanceWithSysTx: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICreateWithLocalTransaction,
|
|
pTransaction: ?*IUnknown,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
pObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICreateWithLocalTransaction,
|
|
pTransaction: ?*IUnknown,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
pObject: ?*?*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 ICreateWithLocalTransaction_CreateInstanceWithSysTx(self: *const T, pTransaction: ?*IUnknown, rclsid: ?*const Guid, riid: ?*const Guid, pObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const ICreateWithLocalTransaction.VTable, @ptrCast(self.vtable)).CreateInstanceWithSysTx(@as(*const ICreateWithLocalTransaction, @ptrCast(self)), pTransaction, rclsid, riid, pObject);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICreateWithTipTransactionEx_Value = Guid.initString("455acf59-5345-11d2-99cf-00c04f797bc9");
|
|
pub const IID_ICreateWithTipTransactionEx = &IID_ICreateWithTipTransactionEx_Value;
|
|
pub const ICreateWithTipTransactionEx = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateInstance: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICreateWithTipTransactionEx,
|
|
bstrTipUrl: ?BSTR,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
pObject: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICreateWithTipTransactionEx,
|
|
bstrTipUrl: ?BSTR,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
pObject: ?*?*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 ICreateWithTipTransactionEx_CreateInstance(self: *const T, bstrTipUrl: ?BSTR, rclsid: ?*const Guid, riid: ?*const Guid, pObject: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const ICreateWithTipTransactionEx.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const ICreateWithTipTransactionEx, @ptrCast(self)), bstrTipUrl, rclsid, riid, pObject);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const COMSVCSEVENTINFO = extern struct {
|
|
cbSize: u32,
|
|
dwPid: u32,
|
|
lTime: i64,
|
|
lMicroTime: i32,
|
|
perfCount: i64,
|
|
guidApp: Guid,
|
|
sMachineName: ?PWSTR,
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IComLTxEvents_Value = Guid.initString("605cf82c-578e-4298-975d-82babcd9e053");
|
|
pub const IID_IComLTxEvents = &IID_IComLTxEvents_Value;
|
|
pub const IComLTxEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnLtxTransactionStart: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
tsid: Guid,
|
|
fRoot: BOOL,
|
|
nIsolationLevel: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
tsid: Guid,
|
|
fRoot: BOOL,
|
|
nIsolationLevel: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnLtxTransactionPrepare: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
fVote: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
fVote: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnLtxTransactionAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnLtxTransactionCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnLtxTransactionPromote: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
txnId: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComLTxEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidLtx: Guid,
|
|
txnId: Guid,
|
|
) 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 IComLTxEvents_OnLtxTransactionStart(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid, tsid: Guid, fRoot: BOOL, nIsolationLevel: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionStart(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx, tsid, fRoot, nIsolationLevel);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComLTxEvents_OnLtxTransactionPrepare(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid, fVote: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionPrepare(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx, fVote);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComLTxEvents_OnLtxTransactionAbort(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionAbort(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComLTxEvents_OnLtxTransactionCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionCommit(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComLTxEvents_OnLtxTransactionPromote(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidLtx: Guid, txnId: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComLTxEvents.VTable, @ptrCast(self.vtable)).OnLtxTransactionPromote(@as(*const IComLTxEvents, @ptrCast(self)), pInfo, guidLtx, txnId);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComUserEvent_Value = Guid.initString("683130a4-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComUserEvent = &IID_IComUserEvent_Value;
|
|
pub const IComUserEvent = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnUserEvent: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComUserEvent,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
pvarEvent: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComUserEvent,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
pvarEvent: ?*VARIANT,
|
|
) 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 IComUserEvent_OnUserEvent(self: *const T, pInfo: ?*COMSVCSEVENTINFO, pvarEvent: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComUserEvent.VTable, @ptrCast(self.vtable)).OnUserEvent(@as(*const IComUserEvent, @ptrCast(self)), pInfo, pvarEvent);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComThreadEvents_Value = Guid.initString("683130a5-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComThreadEvents = &IID_IComThreadEvents_Value;
|
|
pub const IComThreadEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnThreadStart: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
dwThread: u32,
|
|
dwTheadCnt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
dwThread: u32,
|
|
dwTheadCnt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadTerminate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
dwThread: u32,
|
|
dwTheadCnt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
dwThread: u32,
|
|
dwTheadCnt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadBindToApartment: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
AptID: u64,
|
|
dwActCnt: u32,
|
|
dwLowCnt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
AptID: u64,
|
|
dwActCnt: u32,
|
|
dwLowCnt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadUnBind: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
AptID: u64,
|
|
dwActCnt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
AptID: u64,
|
|
dwActCnt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadWorkEnque: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
QueueLen: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
QueueLen: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadWorkPrivate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadWorkPublic: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
QueueLen: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
QueueLen: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadWorkRedirect: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
QueueLen: u32,
|
|
ThreadNum: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
QueueLen: u32,
|
|
ThreadNum: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadWorkReject: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
QueueLen: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ThreadID: u64,
|
|
MsgWorkID: u64,
|
|
QueueLen: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadAssignApartment: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
AptID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
AptID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnThreadUnassignApartment: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
AptID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComThreadEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
AptID: u64,
|
|
) 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 IComThreadEvents_OnThreadStart(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, dwThread: u32, dwTheadCnt: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadStart(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, dwThread, dwTheadCnt);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadTerminate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, dwThread: u32, dwTheadCnt: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadTerminate(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, dwThread, dwTheadCnt);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadBindToApartment(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, AptID: u64, dwActCnt: u32, dwLowCnt: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadBindToApartment(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, AptID, dwActCnt, dwLowCnt);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadUnBind(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, AptID: u64, dwActCnt: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadUnBind(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, AptID, dwActCnt);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadWorkEnque(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64, QueueLen: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkEnque(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID, QueueLen);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadWorkPrivate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkPrivate(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadWorkPublic(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64, QueueLen: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkPublic(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID, QueueLen);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadWorkRedirect(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64, QueueLen: u32, ThreadNum: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkRedirect(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID, QueueLen, ThreadNum);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadWorkReject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ThreadID: u64, MsgWorkID: u64, QueueLen: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadWorkReject(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, ThreadID, MsgWorkID, QueueLen);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadAssignApartment(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, AptID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadAssignApartment(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, guidActivity, AptID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComThreadEvents_OnThreadUnassignApartment(self: *const T, pInfo: ?*COMSVCSEVENTINFO, AptID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComThreadEvents.VTable, @ptrCast(self.vtable)).OnThreadUnassignApartment(@as(*const IComThreadEvents, @ptrCast(self)), pInfo, AptID);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComAppEvents_Value = Guid.initString("683130a6-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComAppEvents = &IID_IComAppEvents_Value;
|
|
pub const IComAppEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnAppActivation: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComAppEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComAppEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnAppShutdown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComAppEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComAppEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnAppForceShutdown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComAppEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComAppEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) 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 IComAppEvents_OnAppActivation(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComAppEvents.VTable, @ptrCast(self.vtable)).OnAppActivation(@as(*const IComAppEvents, @ptrCast(self)), pInfo, guidApp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComAppEvents_OnAppShutdown(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComAppEvents.VTable, @ptrCast(self.vtable)).OnAppShutdown(@as(*const IComAppEvents, @ptrCast(self)), pInfo, guidApp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComAppEvents_OnAppForceShutdown(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComAppEvents.VTable, @ptrCast(self.vtable)).OnAppForceShutdown(@as(*const IComAppEvents, @ptrCast(self)), pInfo, guidApp);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComInstanceEvents_Value = Guid.initString("683130a7-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComInstanceEvents = &IID_IComInstanceEvents_Value;
|
|
pub const IComInstanceEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnObjectCreate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComInstanceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
clsid: ?*const Guid,
|
|
tsid: ?*const Guid,
|
|
CtxtID: u64,
|
|
ObjectID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComInstanceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
clsid: ?*const Guid,
|
|
tsid: ?*const Guid,
|
|
CtxtID: u64,
|
|
ObjectID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjectDestroy: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComInstanceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComInstanceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) 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 IComInstanceEvents_OnObjectCreate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, clsid: ?*const Guid, tsid: ?*const Guid, CtxtID: u64, ObjectID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComInstanceEvents.VTable, @ptrCast(self.vtable)).OnObjectCreate(@as(*const IComInstanceEvents, @ptrCast(self)), pInfo, guidActivity, clsid, tsid, CtxtID, ObjectID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComInstanceEvents_OnObjectDestroy(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComInstanceEvents.VTable, @ptrCast(self.vtable)).OnObjectDestroy(@as(*const IComInstanceEvents, @ptrCast(self)), pInfo, CtxtID);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComTransactionEvents_Value = Guid.initString("683130a8-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComTransactionEvents = &IID_IComTransactionEvents_Value;
|
|
pub const IComTransactionEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnTransactionStart: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTransactionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
tsid: ?*const Guid,
|
|
fRoot: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTransactionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
tsid: ?*const Guid,
|
|
fRoot: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnTransactionPrepare: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTransactionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
fVoteYes: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTransactionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
fVoteYes: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnTransactionAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTransactionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTransactionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnTransactionCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTransactionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTransactionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
) 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 IComTransactionEvents_OnTransactionStart(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid, tsid: ?*const Guid, fRoot: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTransactionEvents.VTable, @ptrCast(self.vtable)).OnTransactionStart(@as(*const IComTransactionEvents, @ptrCast(self)), pInfo, guidTx, tsid, fRoot);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTransactionEvents_OnTransactionPrepare(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid, fVoteYes: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTransactionEvents.VTable, @ptrCast(self.vtable)).OnTransactionPrepare(@as(*const IComTransactionEvents, @ptrCast(self)), pInfo, guidTx, fVoteYes);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTransactionEvents_OnTransactionAbort(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTransactionEvents.VTable, @ptrCast(self.vtable)).OnTransactionAbort(@as(*const IComTransactionEvents, @ptrCast(self)), pInfo, guidTx);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTransactionEvents_OnTransactionCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTransactionEvents.VTable, @ptrCast(self.vtable)).OnTransactionCommit(@as(*const IComTransactionEvents, @ptrCast(self)), pInfo, guidTx);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComMethodEvents_Value = Guid.initString("683130a9-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComMethodEvents = &IID_IComMethodEvents_Value;
|
|
pub const IComMethodEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnMethodCall: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMethodEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
iMeth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMethodEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
iMeth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnMethodReturn: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMethodEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
iMeth: u32,
|
|
hresult: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMethodEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
iMeth: u32,
|
|
hresult: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnMethodException: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMethodEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
iMeth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMethodEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
iMeth: u32,
|
|
) 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 IComMethodEvents_OnMethodCall(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, iMeth: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMethodEvents.VTable, @ptrCast(self.vtable)).OnMethodCall(@as(*const IComMethodEvents, @ptrCast(self)), pInfo, oid, guidCid, guidRid, iMeth);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComMethodEvents_OnMethodReturn(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, iMeth: u32, hresult: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMethodEvents.VTable, @ptrCast(self.vtable)).OnMethodReturn(@as(*const IComMethodEvents, @ptrCast(self)), pInfo, oid, guidCid, guidRid, iMeth, hresult);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComMethodEvents_OnMethodException(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, iMeth: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMethodEvents.VTable, @ptrCast(self.vtable)).OnMethodException(@as(*const IComMethodEvents, @ptrCast(self)), pInfo, oid, guidCid, guidRid, iMeth);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComObjectEvents_Value = Guid.initString("683130aa-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComObjectEvents = &IID_IComObjectEvents_Value;
|
|
pub const IComObjectEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnObjectActivate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
ObjectID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
ObjectID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjectDeactivate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
ObjectID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
ObjectID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnDisableCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnEnableCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnSetComplete: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnSetAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) 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 IComObjectEvents_OnObjectActivate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64, ObjectID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnObjectActivate(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID, ObjectID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectEvents_OnObjectDeactivate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64, ObjectID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnObjectDeactivate(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID, ObjectID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectEvents_OnDisableCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnDisableCommit(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectEvents_OnEnableCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnEnableCommit(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectEvents_OnSetComplete(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnSetComplete(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectEvents_OnSetAbort(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectEvents.VTable, @ptrCast(self.vtable)).OnSetAbort(@as(*const IComObjectEvents, @ptrCast(self)), pInfo, CtxtID);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComResourceEvents_Value = Guid.initString("683130ab-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComResourceEvents = &IID_IComResourceEvents_Value;
|
|
pub const IComResourceEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnResourceCreate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
enlisted: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
enlisted: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnResourceAllocate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
enlisted: BOOL,
|
|
NumRated: u32,
|
|
Rating: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
enlisted: BOOL,
|
|
NumRated: u32,
|
|
Rating: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnResourceRecycle: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnResourceDestroy: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
hr: HRESULT,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
hr: HRESULT,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnResourceTrack: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
enlisted: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComResourceEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjectID: u64,
|
|
pszType: ?[*:0]const u16,
|
|
resId: u64,
|
|
enlisted: BOOL,
|
|
) 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 IComResourceEvents_OnResourceCreate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, pszType: ?[*:0]const u16, resId: u64, enlisted: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceCreate(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, pszType, resId, enlisted);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComResourceEvents_OnResourceAllocate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, pszType: ?[*:0]const u16, resId: u64, enlisted: BOOL, NumRated: u32, Rating: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceAllocate(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, pszType, resId, enlisted, NumRated, Rating);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComResourceEvents_OnResourceRecycle(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, pszType: ?[*:0]const u16, resId: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceRecycle(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, pszType, resId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComResourceEvents_OnResourceDestroy(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, hr: HRESULT, pszType: ?[*:0]const u16, resId: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceDestroy(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, hr, pszType, resId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComResourceEvents_OnResourceTrack(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjectID: u64, pszType: ?[*:0]const u16, resId: u64, enlisted: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComResourceEvents.VTable, @ptrCast(self.vtable)).OnResourceTrack(@as(*const IComResourceEvents, @ptrCast(self)), pInfo, ObjectID, pszType, resId, enlisted);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComSecurityEvents_Value = Guid.initString("683130ac-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComSecurityEvents = &IID_IComSecurityEvents_Value;
|
|
pub const IComSecurityEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnAuthenticate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComSecurityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
ObjectID: u64,
|
|
guidIID: ?*const Guid,
|
|
iMeth: u32,
|
|
cbByteOrig: u32,
|
|
pSidOriginalUser: [*:0]u8,
|
|
cbByteCur: u32,
|
|
pSidCurrentUser: [*:0]u8,
|
|
bCurrentUserInpersonatingInProc: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComSecurityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
ObjectID: u64,
|
|
guidIID: ?*const Guid,
|
|
iMeth: u32,
|
|
cbByteOrig: u32,
|
|
pSidOriginalUser: [*:0]u8,
|
|
cbByteCur: u32,
|
|
pSidCurrentUser: [*:0]u8,
|
|
bCurrentUserInpersonatingInProc: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnAuthenticateFail: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComSecurityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
ObjectID: u64,
|
|
guidIID: ?*const Guid,
|
|
iMeth: u32,
|
|
cbByteOrig: u32,
|
|
pSidOriginalUser: [*:0]u8,
|
|
cbByteCur: u32,
|
|
pSidCurrentUser: [*:0]u8,
|
|
bCurrentUserInpersonatingInProc: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComSecurityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
ObjectID: u64,
|
|
guidIID: ?*const Guid,
|
|
iMeth: u32,
|
|
cbByteOrig: u32,
|
|
pSidOriginalUser: [*:0]u8,
|
|
cbByteCur: u32,
|
|
pSidCurrentUser: [*:0]u8,
|
|
bCurrentUserInpersonatingInProc: BOOL,
|
|
) 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 IComSecurityEvents_OnAuthenticate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, ObjectID: u64, guidIID: ?*const Guid, iMeth: u32, cbByteOrig: u32, pSidOriginalUser: [*:0]u8, cbByteCur: u32, pSidCurrentUser: [*:0]u8, bCurrentUserInpersonatingInProc: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComSecurityEvents.VTable, @ptrCast(self.vtable)).OnAuthenticate(@as(*const IComSecurityEvents, @ptrCast(self)), pInfo, guidActivity, ObjectID, guidIID, iMeth, cbByteOrig, pSidOriginalUser, cbByteCur, pSidCurrentUser, bCurrentUserInpersonatingInProc);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComSecurityEvents_OnAuthenticateFail(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, ObjectID: u64, guidIID: ?*const Guid, iMeth: u32, cbByteOrig: u32, pSidOriginalUser: [*:0]u8, cbByteCur: u32, pSidCurrentUser: [*:0]u8, bCurrentUserInpersonatingInProc: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComSecurityEvents.VTable, @ptrCast(self.vtable)).OnAuthenticateFail(@as(*const IComSecurityEvents, @ptrCast(self)), pInfo, guidActivity, ObjectID, guidIID, iMeth, cbByteOrig, pSidOriginalUser, cbByteCur, pSidCurrentUser, bCurrentUserInpersonatingInProc);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComObjectPoolEvents_Value = Guid.initString("683130ad-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComObjectPoolEvents = &IID_IComObjectPoolEvents_Value;
|
|
pub const IComObjectPoolEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnObjPoolPutObject: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
nReason: i32,
|
|
dwAvailable: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
nReason: i32,
|
|
dwAvailable: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolGetObject: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
dwAvailable: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
dwAvailable: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolRecycleToTx: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
guidTx: ?*const Guid,
|
|
objid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
guidTx: ?*const Guid,
|
|
objid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolGetFromTx: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
guidTx: ?*const Guid,
|
|
objid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
guidTx: ?*const Guid,
|
|
objid: u64,
|
|
) 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 IComObjectPoolEvents_OnObjPoolPutObject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, nReason: i32, dwAvailable: u32, oid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents.VTable, @ptrCast(self.vtable)).OnObjPoolPutObject(@as(*const IComObjectPoolEvents, @ptrCast(self)), pInfo, guidObject, nReason, dwAvailable, oid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPoolEvents_OnObjPoolGetObject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, dwAvailable: u32, oid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents.VTable, @ptrCast(self.vtable)).OnObjPoolGetObject(@as(*const IComObjectPoolEvents, @ptrCast(self)), pInfo, guidActivity, guidObject, dwAvailable, oid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPoolEvents_OnObjPoolRecycleToTx(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, guidTx: ?*const Guid, objid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents.VTable, @ptrCast(self.vtable)).OnObjPoolRecycleToTx(@as(*const IComObjectPoolEvents, @ptrCast(self)), pInfo, guidActivity, guidObject, guidTx, objid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPoolEvents_OnObjPoolGetFromTx(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, guidTx: ?*const Guid, objid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents.VTable, @ptrCast(self.vtable)).OnObjPoolGetFromTx(@as(*const IComObjectPoolEvents, @ptrCast(self)), pInfo, guidActivity, guidObject, guidTx, objid);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComObjectPoolEvents2_Value = Guid.initString("683130ae-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComObjectPoolEvents2 = &IID_IComObjectPoolEvents2_Value;
|
|
pub const IComObjectPoolEvents2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnObjPoolCreateObject: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
dwObjsCreated: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
dwObjsCreated: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolDestroyObject: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
dwObjsCreated: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
dwObjsCreated: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolCreateDecision: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
dwThreadsWaiting: u32,
|
|
dwAvail: u32,
|
|
dwCreated: u32,
|
|
dwMin: u32,
|
|
dwMax: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
dwThreadsWaiting: u32,
|
|
dwAvail: u32,
|
|
dwCreated: u32,
|
|
dwMin: u32,
|
|
dwMax: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolTimeout: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
guidActivity: ?*const Guid,
|
|
dwTimeout: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
guidActivity: ?*const Guid,
|
|
dwTimeout: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolCreatePool: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
dwMin: u32,
|
|
dwMax: u32,
|
|
dwTimeout: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPoolEvents2,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
dwMin: u32,
|
|
dwMax: u32,
|
|
dwTimeout: u32,
|
|
) 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 IComObjectPoolEvents2_OnObjPoolCreateObject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, dwObjsCreated: u32, oid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolCreateObject(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, guidObject, dwObjsCreated, oid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPoolEvents2_OnObjPoolDestroyObject(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, dwObjsCreated: u32, oid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolDestroyObject(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, guidObject, dwObjsCreated, oid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPoolEvents2_OnObjPoolCreateDecision(self: *const T, pInfo: ?*COMSVCSEVENTINFO, dwThreadsWaiting: u32, dwAvail: u32, dwCreated: u32, dwMin: u32, dwMax: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolCreateDecision(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, dwThreadsWaiting, dwAvail, dwCreated, dwMin, dwMax);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPoolEvents2_OnObjPoolTimeout(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, guidActivity: ?*const Guid, dwTimeout: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolTimeout(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, guidObject, guidActivity, dwTimeout);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPoolEvents2_OnObjPoolCreatePool(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, dwMin: u32, dwMax: u32, dwTimeout: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPoolEvents2.VTable, @ptrCast(self.vtable)).OnObjPoolCreatePool(@as(*const IComObjectPoolEvents2, @ptrCast(self)), pInfo, guidObject, dwMin, dwMax, dwTimeout);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComObjectConstructionEvents_Value = Guid.initString("683130af-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComObjectConstructionEvents = &IID_IComObjectConstructionEvents_Value;
|
|
pub const IComObjectConstructionEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnObjectConstruct: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectConstructionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
sConstructString: ?[*:0]const u16,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectConstructionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
sConstructString: ?[*:0]const u16,
|
|
oid: u64,
|
|
) 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 IComObjectConstructionEvents_OnObjectConstruct(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, sConstructString: ?[*:0]const u16, oid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectConstructionEvents.VTable, @ptrCast(self.vtable)).OnObjectConstruct(@as(*const IComObjectConstructionEvents, @ptrCast(self)), pInfo, guidObject, sConstructString, oid);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComActivityEvents_Value = Guid.initString("683130b0-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComActivityEvents = &IID_IComActivityEvents_Value;
|
|
pub const IComActivityEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnActivityCreate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnActivityDestroy: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnActivityEnter: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
guidEntered: ?*const Guid,
|
|
dwThread: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
guidEntered: ?*const Guid,
|
|
dwThread: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnActivityTimeout: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
guidEntered: ?*const Guid,
|
|
dwThread: u32,
|
|
dwTimeout: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
guidEntered: ?*const Guid,
|
|
dwThread: u32,
|
|
dwTimeout: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnActivityReenter: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
dwThread: u32,
|
|
dwCallDepth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
dwThread: u32,
|
|
dwCallDepth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnActivityLeave: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
guidLeft: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
guidLeft: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnActivityLeaveSame: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
dwCallDepth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComActivityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidCurrent: ?*const Guid,
|
|
dwCallDepth: u32,
|
|
) 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 IComActivityEvents_OnActivityCreate(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityCreate(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidActivity);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComActivityEvents_OnActivityDestroy(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityDestroy(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidActivity);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComActivityEvents_OnActivityEnter(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, guidEntered: ?*const Guid, dwThread: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityEnter(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, guidEntered, dwThread);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComActivityEvents_OnActivityTimeout(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, guidEntered: ?*const Guid, dwThread: u32, dwTimeout: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityTimeout(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, guidEntered, dwThread, dwTimeout);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComActivityEvents_OnActivityReenter(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, dwThread: u32, dwCallDepth: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityReenter(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, dwThread, dwCallDepth);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComActivityEvents_OnActivityLeave(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, guidLeft: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityLeave(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, guidLeft);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComActivityEvents_OnActivityLeaveSame(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidCurrent: ?*const Guid, dwCallDepth: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComActivityEvents.VTable, @ptrCast(self.vtable)).OnActivityLeaveSame(@as(*const IComActivityEvents, @ptrCast(self)), pInfo, guidCurrent, dwCallDepth);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComIdentityEvents_Value = Guid.initString("683130b1-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComIdentityEvents = &IID_IComIdentityEvents_Value;
|
|
pub const IComIdentityEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnIISRequestInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComIdentityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjId: u64,
|
|
pszClientIP: ?[*:0]const u16,
|
|
pszServerIP: ?[*:0]const u16,
|
|
pszURL: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComIdentityEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
ObjId: u64,
|
|
pszClientIP: ?[*:0]const u16,
|
|
pszServerIP: ?[*:0]const u16,
|
|
pszURL: ?[*:0]const u16,
|
|
) 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 IComIdentityEvents_OnIISRequestInfo(self: *const T, pInfo: ?*COMSVCSEVENTINFO, ObjId: u64, pszClientIP: ?[*:0]const u16, pszServerIP: ?[*:0]const u16, pszURL: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IComIdentityEvents.VTable, @ptrCast(self.vtable)).OnIISRequestInfo(@as(*const IComIdentityEvents, @ptrCast(self)), pInfo, ObjId, pszClientIP, pszServerIP, pszURL);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComQCEvents_Value = Guid.initString("683130b2-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComQCEvents = &IID_IComQCEvents_Value;
|
|
pub const IComQCEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnQCRecord: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
objid: u64,
|
|
szQueue: *[60]u16,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
msmqhr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
objid: u64,
|
|
szQueue: *[60]u16,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
msmqhr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnQCQueueOpen: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
szQueue: *[60]u16,
|
|
QueueID: u64,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
szQueue: *[60]u16,
|
|
QueueID: u64,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnQCReceive: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
QueueID: u64,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
QueueID: u64,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnQCReceiveFail: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
QueueID: u64,
|
|
msmqhr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
QueueID: u64,
|
|
msmqhr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnQCMoveToReTryQueue: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
RetryIndex: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
RetryIndex: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnQCMoveToDeadQueue: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnQCPlayback: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
objid: u64,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComQCEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
objid: u64,
|
|
guidMsgId: ?*const Guid,
|
|
guidWorkFlowId: ?*const Guid,
|
|
hr: HRESULT,
|
|
) 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 IComQCEvents_OnQCRecord(self: *const T, pInfo: ?*COMSVCSEVENTINFO, objid: u64, szQueue: *[60]u16, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid, msmqhr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCRecord(@as(*const IComQCEvents, @ptrCast(self)), pInfo, objid, szQueue, guidMsgId, guidWorkFlowId, msmqhr);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComQCEvents_OnQCQueueOpen(self: *const T, pInfo: ?*COMSVCSEVENTINFO, szQueue: *[60]u16, QueueID: u64, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCQueueOpen(@as(*const IComQCEvents, @ptrCast(self)), pInfo, szQueue, QueueID, hr);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComQCEvents_OnQCReceive(self: *const T, pInfo: ?*COMSVCSEVENTINFO, QueueID: u64, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCReceive(@as(*const IComQCEvents, @ptrCast(self)), pInfo, QueueID, guidMsgId, guidWorkFlowId, hr);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComQCEvents_OnQCReceiveFail(self: *const T, pInfo: ?*COMSVCSEVENTINFO, QueueID: u64, msmqhr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCReceiveFail(@as(*const IComQCEvents, @ptrCast(self)), pInfo, QueueID, msmqhr);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComQCEvents_OnQCMoveToReTryQueue(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid, RetryIndex: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCMoveToReTryQueue(@as(*const IComQCEvents, @ptrCast(self)), pInfo, guidMsgId, guidWorkFlowId, RetryIndex);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComQCEvents_OnQCMoveToDeadQueue(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCMoveToDeadQueue(@as(*const IComQCEvents, @ptrCast(self)), pInfo, guidMsgId, guidWorkFlowId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComQCEvents_OnQCPlayback(self: *const T, pInfo: ?*COMSVCSEVENTINFO, objid: u64, guidMsgId: ?*const Guid, guidWorkFlowId: ?*const Guid, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComQCEvents.VTable, @ptrCast(self.vtable)).OnQCPlayback(@as(*const IComQCEvents, @ptrCast(self)), pInfo, objid, guidMsgId, guidWorkFlowId, hr);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComExceptionEvents_Value = Guid.initString("683130b3-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComExceptionEvents = &IID_IComExceptionEvents_Value;
|
|
pub const IComExceptionEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnExceptionUser: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComExceptionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
code: u32,
|
|
address: u64,
|
|
pszStackTrace: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComExceptionEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
code: u32,
|
|
address: u64,
|
|
pszStackTrace: ?[*:0]const u16,
|
|
) 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 IComExceptionEvents_OnExceptionUser(self: *const T, pInfo: ?*COMSVCSEVENTINFO, code: u32, address: u64, pszStackTrace: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IComExceptionEvents.VTable, @ptrCast(self.vtable)).OnExceptionUser(@as(*const IComExceptionEvents, @ptrCast(self)), pInfo, code, address, pszStackTrace);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ILBEvents_Value = Guid.initString("683130b4-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_ILBEvents = &IID_ILBEvents_Value;
|
|
pub const ILBEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
TargetUp: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ILBEvents,
|
|
bstrServerName: ?BSTR,
|
|
bstrClsidEng: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ILBEvents,
|
|
bstrServerName: ?BSTR,
|
|
bstrClsidEng: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TargetDown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ILBEvents,
|
|
bstrServerName: ?BSTR,
|
|
bstrClsidEng: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ILBEvents,
|
|
bstrServerName: ?BSTR,
|
|
bstrClsidEng: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EngineDefined: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ILBEvents,
|
|
bstrPropName: ?BSTR,
|
|
varPropValue: ?*VARIANT,
|
|
bstrClsidEng: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ILBEvents,
|
|
bstrPropName: ?BSTR,
|
|
varPropValue: ?*VARIANT,
|
|
bstrClsidEng: ?BSTR,
|
|
) 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 ILBEvents_TargetUp(self: *const T, bstrServerName: ?BSTR, bstrClsidEng: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ILBEvents.VTable, @ptrCast(self.vtable)).TargetUp(@as(*const ILBEvents, @ptrCast(self)), bstrServerName, bstrClsidEng);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ILBEvents_TargetDown(self: *const T, bstrServerName: ?BSTR, bstrClsidEng: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ILBEvents.VTable, @ptrCast(self.vtable)).TargetDown(@as(*const ILBEvents, @ptrCast(self)), bstrServerName, bstrClsidEng);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ILBEvents_EngineDefined(self: *const T, bstrPropName: ?BSTR, varPropValue: ?*VARIANT, bstrClsidEng: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ILBEvents.VTable, @ptrCast(self.vtable)).EngineDefined(@as(*const ILBEvents, @ptrCast(self)), bstrPropName, varPropValue, bstrClsidEng);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComCRMEvents_Value = Guid.initString("683130b5-2e50-11d2-98a5-00c04f8ee1c4");
|
|
pub const IID_IComCRMEvents = &IID_IComCRMEvents_Value;
|
|
pub const IComCRMEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnCRMRecoveryStart: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMRecoveryDone: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMCheckpoint: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMBegin: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
guidActivity: Guid,
|
|
guidTx: Guid,
|
|
szProgIdCompensator: *[64]u16,
|
|
szDescription: *[64]u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
guidActivity: Guid,
|
|
guidTx: Guid,
|
|
szProgIdCompensator: *[64]u16,
|
|
szDescription: *[64]u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMPrepare: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMIndoubt: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMDone: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMRelease: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMAnalyze: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
dwCrmRecordType: u32,
|
|
dwRecordSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
dwCrmRecordType: u32,
|
|
dwRecordSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMWrite: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
fVariants: BOOL,
|
|
dwRecordSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
fVariants: BOOL,
|
|
dwRecordSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMForget: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMForce: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnCRMDeliver: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
fVariants: BOOL,
|
|
dwRecordSize: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComCRMEvents,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidClerkCLSID: Guid,
|
|
fVariants: BOOL,
|
|
dwRecordSize: u32,
|
|
) 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 IComCRMEvents_OnCRMRecoveryStart(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMRecoveryStart(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidApp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMRecoveryDone(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMRecoveryDone(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidApp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMCheckpoint(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMCheckpoint(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidApp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMBegin(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid, guidActivity: Guid, guidTx: Guid, szProgIdCompensator: *[64]u16, szDescription: *[64]u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMBegin(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID, guidActivity, guidTx, szProgIdCompensator, szDescription);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMPrepare(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMPrepare(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMCommit(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMCommit(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMAbort(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMAbort(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMIndoubt(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMIndoubt(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMDone(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMDone(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMRelease(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMRelease(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMAnalyze(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid, dwCrmRecordType: u32, dwRecordSize: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMAnalyze(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID, dwCrmRecordType, dwRecordSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMWrite(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid, fVariants: BOOL, dwRecordSize: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMWrite(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID, fVariants, dwRecordSize);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMForget(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMForget(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMForce(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMForce(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComCRMEvents_OnCRMDeliver(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidClerkCLSID: Guid, fVariants: BOOL, dwRecordSize: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComCRMEvents.VTable, @ptrCast(self.vtable)).OnCRMDeliver(@as(*const IComCRMEvents, @ptrCast(self)), pInfo, guidClerkCLSID, fVariants, dwRecordSize);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComMethod2Events_Value = Guid.initString("fb388aaa-567d-4024-af8e-6e93ee748573");
|
|
pub const IID_IComMethod2Events = &IID_IComMethod2Events_Value;
|
|
pub const IComMethod2Events = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnMethodCall2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMethod2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
dwThread: u32,
|
|
iMeth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMethod2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
dwThread: u32,
|
|
iMeth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnMethodReturn2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMethod2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
dwThread: u32,
|
|
iMeth: u32,
|
|
hresult: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMethod2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
dwThread: u32,
|
|
iMeth: u32,
|
|
hresult: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnMethodException2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMethod2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
dwThread: u32,
|
|
iMeth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMethod2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
oid: u64,
|
|
guidCid: ?*const Guid,
|
|
guidRid: ?*const Guid,
|
|
dwThread: u32,
|
|
iMeth: u32,
|
|
) 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 IComMethod2Events_OnMethodCall2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, dwThread: u32, iMeth: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMethod2Events.VTable, @ptrCast(self.vtable)).OnMethodCall2(@as(*const IComMethod2Events, @ptrCast(self)), pInfo, oid, guidCid, guidRid, dwThread, iMeth);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComMethod2Events_OnMethodReturn2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, dwThread: u32, iMeth: u32, hresult: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMethod2Events.VTable, @ptrCast(self.vtable)).OnMethodReturn2(@as(*const IComMethod2Events, @ptrCast(self)), pInfo, oid, guidCid, guidRid, dwThread, iMeth, hresult);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComMethod2Events_OnMethodException2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, oid: u64, guidCid: ?*const Guid, guidRid: ?*const Guid, dwThread: u32, iMeth: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMethod2Events.VTable, @ptrCast(self.vtable)).OnMethodException2(@as(*const IComMethod2Events, @ptrCast(self)), pInfo, oid, guidCid, guidRid, dwThread, iMeth);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IComTrackingInfoEvents_Value = Guid.initString("4e6cdcc9-fb25-4fd5-9cc5-c9f4b6559cec");
|
|
pub const IID_IComTrackingInfoEvents = &IID_IComTrackingInfoEvents_Value;
|
|
pub const IComTrackingInfoEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnNewTrackingInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTrackingInfoEvents,
|
|
pToplevelCollection: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTrackingInfoEvents,
|
|
pToplevelCollection: ?*IUnknown,
|
|
) 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 IComTrackingInfoEvents_OnNewTrackingInfo(self: *const T, pToplevelCollection: ?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTrackingInfoEvents.VTable, @ptrCast(self.vtable)).OnNewTrackingInfo(@as(*const IComTrackingInfoEvents, @ptrCast(self)), pToplevelCollection);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const TRACKING_COLL_TYPE = enum(i32) {
|
|
PROCESSES = 0,
|
|
APPLICATIONS = 1,
|
|
COMPONENTS = 2,
|
|
};
|
|
pub const TRKCOLL_PROCESSES = TRACKING_COLL_TYPE.PROCESSES;
|
|
pub const TRKCOLL_APPLICATIONS = TRACKING_COLL_TYPE.APPLICATIONS;
|
|
pub const TRKCOLL_COMPONENTS = TRACKING_COLL_TYPE.COMPONENTS;
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IComTrackingInfoCollection_Value = Guid.initString("c266c677-c9ad-49ab-9fd9-d9661078588a");
|
|
pub const IID_IComTrackingInfoCollection = &IID_IComTrackingInfoCollection_Value;
|
|
pub const IComTrackingInfoCollection = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Type: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTrackingInfoCollection,
|
|
pType: ?*TRACKING_COLL_TYPE,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTrackingInfoCollection,
|
|
pType: ?*TRACKING_COLL_TYPE,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Count: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTrackingInfoCollection,
|
|
pCount: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTrackingInfoCollection,
|
|
pCount: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Item: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTrackingInfoCollection,
|
|
ulIndex: u32,
|
|
riid: ?*const Guid,
|
|
ppv: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTrackingInfoCollection,
|
|
ulIndex: u32,
|
|
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 IComTrackingInfoCollection_Type(self: *const T, pType: ?*TRACKING_COLL_TYPE) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTrackingInfoCollection.VTable, @ptrCast(self.vtable)).Type(@as(*const IComTrackingInfoCollection, @ptrCast(self)), pType);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTrackingInfoCollection_Count(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTrackingInfoCollection.VTable, @ptrCast(self.vtable)).Count(@as(*const IComTrackingInfoCollection, @ptrCast(self)), pCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTrackingInfoCollection_Item(self: *const T, ulIndex: u32, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTrackingInfoCollection.VTable, @ptrCast(self.vtable)).Item(@as(*const IComTrackingInfoCollection, @ptrCast(self)), ulIndex, riid, ppv);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IComTrackingInfoObject_Value = Guid.initString("116e42c5-d8b1-47bf-ab1e-c895ed3e2372");
|
|
pub const IID_IComTrackingInfoObject = &IID_IComTrackingInfoObject_Value;
|
|
pub const IComTrackingInfoObject = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetValue: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTrackingInfoObject,
|
|
szPropertyName: ?PWSTR,
|
|
pvarOut: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTrackingInfoObject,
|
|
szPropertyName: ?PWSTR,
|
|
pvarOut: ?*VARIANT,
|
|
) 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 IComTrackingInfoObject_GetValue(self: *const T, szPropertyName: ?PWSTR, pvarOut: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTrackingInfoObject.VTable, @ptrCast(self.vtable)).GetValue(@as(*const IComTrackingInfoObject, @ptrCast(self)), szPropertyName, pvarOut);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IComTrackingInfoProperties_Value = Guid.initString("789b42be-6f6b-443a-898e-67abf390aa14");
|
|
pub const IID_IComTrackingInfoProperties = &IID_IComTrackingInfoProperties_Value;
|
|
pub const IComTrackingInfoProperties = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
PropCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTrackingInfoProperties,
|
|
pCount: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTrackingInfoProperties,
|
|
pCount: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetPropName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTrackingInfoProperties,
|
|
ulIndex: u32,
|
|
ppszPropName: ?*?PWSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTrackingInfoProperties,
|
|
ulIndex: u32,
|
|
ppszPropName: ?*?PWSTR,
|
|
) 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 IComTrackingInfoProperties_PropCount(self: *const T, pCount: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTrackingInfoProperties.VTable, @ptrCast(self.vtable)).PropCount(@as(*const IComTrackingInfoProperties, @ptrCast(self)), pCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTrackingInfoProperties_GetPropName(self: *const T, ulIndex: u32, ppszPropName: ?*?PWSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTrackingInfoProperties.VTable, @ptrCast(self.vtable)).GetPropName(@as(*const IComTrackingInfoProperties, @ptrCast(self)), ulIndex, ppszPropName);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IComApp2Events_Value = Guid.initString("1290bc1a-b219-418d-b078-5934ded08242");
|
|
pub const IID_IComApp2Events = &IID_IComApp2Events_Value;
|
|
pub const IComApp2Events = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnAppActivation2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
guidProcess: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
guidProcess: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnAppShutdown2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnAppForceShutdown2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnAppPaused2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
bPaused: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
bPaused: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnAppRecycle2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
guidProcess: Guid,
|
|
lReason: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComApp2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidApp: Guid,
|
|
guidProcess: Guid,
|
|
lReason: i32,
|
|
) 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 IComApp2Events_OnAppActivation2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid, guidProcess: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppActivation2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp, guidProcess);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComApp2Events_OnAppShutdown2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppShutdown2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComApp2Events_OnAppForceShutdown2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppForceShutdown2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComApp2Events_OnAppPaused2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid, bPaused: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppPaused2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp, bPaused);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComApp2Events_OnAppRecycle2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidApp: Guid, guidProcess: Guid, lReason: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComApp2Events.VTable, @ptrCast(self.vtable)).OnAppRecycle2(@as(*const IComApp2Events, @ptrCast(self)), pInfo, guidApp, guidProcess, lReason);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComTransaction2Events_Value = Guid.initString("a136f62a-2f94-4288-86e0-d8a1fa4c0299");
|
|
pub const IID_IComTransaction2Events = &IID_IComTransaction2Events_Value;
|
|
pub const IComTransaction2Events = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnTransactionStart2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTransaction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
tsid: ?*const Guid,
|
|
fRoot: BOOL,
|
|
nIsolationLevel: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTransaction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
tsid: ?*const Guid,
|
|
fRoot: BOOL,
|
|
nIsolationLevel: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnTransactionPrepare2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTransaction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
fVoteYes: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTransaction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
fVoteYes: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnTransactionAbort2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTransaction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTransaction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnTransactionCommit2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComTransaction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComTransaction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidTx: ?*const Guid,
|
|
) 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 IComTransaction2Events_OnTransactionStart2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid, tsid: ?*const Guid, fRoot: BOOL, nIsolationLevel: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTransaction2Events.VTable, @ptrCast(self.vtable)).OnTransactionStart2(@as(*const IComTransaction2Events, @ptrCast(self)), pInfo, guidTx, tsid, fRoot, nIsolationLevel);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTransaction2Events_OnTransactionPrepare2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid, fVoteYes: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTransaction2Events.VTable, @ptrCast(self.vtable)).OnTransactionPrepare2(@as(*const IComTransaction2Events, @ptrCast(self)), pInfo, guidTx, fVoteYes);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTransaction2Events_OnTransactionAbort2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTransaction2Events.VTable, @ptrCast(self.vtable)).OnTransactionAbort2(@as(*const IComTransaction2Events, @ptrCast(self)), pInfo, guidTx);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComTransaction2Events_OnTransactionCommit2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidTx: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComTransaction2Events.VTable, @ptrCast(self.vtable)).OnTransactionCommit2(@as(*const IComTransaction2Events, @ptrCast(self)), pInfo, guidTx);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComInstance2Events_Value = Guid.initString("20e3bf07-b506-4ad5-a50c-d2ca5b9c158e");
|
|
pub const IID_IComInstance2Events = &IID_IComInstance2Events_Value;
|
|
pub const IComInstance2Events = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnObjectCreate2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComInstance2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
clsid: ?*const Guid,
|
|
tsid: ?*const Guid,
|
|
CtxtID: u64,
|
|
ObjectID: u64,
|
|
guidPartition: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComInstance2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
clsid: ?*const Guid,
|
|
tsid: ?*const Guid,
|
|
CtxtID: u64,
|
|
ObjectID: u64,
|
|
guidPartition: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjectDestroy2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComInstance2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComInstance2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
CtxtID: u64,
|
|
) 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 IComInstance2Events_OnObjectCreate2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, clsid: ?*const Guid, tsid: ?*const Guid, CtxtID: u64, ObjectID: u64, guidPartition: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComInstance2Events.VTable, @ptrCast(self.vtable)).OnObjectCreate2(@as(*const IComInstance2Events, @ptrCast(self)), pInfo, guidActivity, clsid, tsid, CtxtID, ObjectID, guidPartition);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComInstance2Events_OnObjectDestroy2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, CtxtID: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComInstance2Events.VTable, @ptrCast(self.vtable)).OnObjectDestroy2(@as(*const IComInstance2Events, @ptrCast(self)), pInfo, CtxtID);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComObjectPool2Events_Value = Guid.initString("65bf6534-85ea-4f64-8cf4-3d974b2ab1cf");
|
|
pub const IID_IComObjectPool2Events = &IID_IComObjectPool2Events_Value;
|
|
pub const IComObjectPool2Events = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnObjPoolPutObject2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPool2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
nReason: i32,
|
|
dwAvailable: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPool2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
nReason: i32,
|
|
dwAvailable: u32,
|
|
oid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolGetObject2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPool2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
dwAvailable: u32,
|
|
oid: u64,
|
|
guidPartition: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPool2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
dwAvailable: u32,
|
|
oid: u64,
|
|
guidPartition: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolRecycleToTx2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPool2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
guidTx: ?*const Guid,
|
|
objid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPool2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
guidTx: ?*const Guid,
|
|
objid: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnObjPoolGetFromTx2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectPool2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
guidTx: ?*const Guid,
|
|
objid: u64,
|
|
guidPartition: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectPool2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidActivity: ?*const Guid,
|
|
guidObject: ?*const Guid,
|
|
guidTx: ?*const Guid,
|
|
objid: u64,
|
|
guidPartition: ?*const Guid,
|
|
) 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 IComObjectPool2Events_OnObjPoolPutObject2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, nReason: i32, dwAvailable: u32, oid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPool2Events.VTable, @ptrCast(self.vtable)).OnObjPoolPutObject2(@as(*const IComObjectPool2Events, @ptrCast(self)), pInfo, guidObject, nReason, dwAvailable, oid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPool2Events_OnObjPoolGetObject2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, dwAvailable: u32, oid: u64, guidPartition: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPool2Events.VTable, @ptrCast(self.vtable)).OnObjPoolGetObject2(@as(*const IComObjectPool2Events, @ptrCast(self)), pInfo, guidActivity, guidObject, dwAvailable, oid, guidPartition);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPool2Events_OnObjPoolRecycleToTx2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, guidTx: ?*const Guid, objid: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPool2Events.VTable, @ptrCast(self.vtable)).OnObjPoolRecycleToTx2(@as(*const IComObjectPool2Events, @ptrCast(self)), pInfo, guidActivity, guidObject, guidTx, objid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComObjectPool2Events_OnObjPoolGetFromTx2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidActivity: ?*const Guid, guidObject: ?*const Guid, guidTx: ?*const Guid, objid: u64, guidPartition: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectPool2Events.VTable, @ptrCast(self.vtable)).OnObjPoolGetFromTx2(@as(*const IComObjectPool2Events, @ptrCast(self)), pInfo, guidActivity, guidObject, guidTx, objid, guidPartition);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IComObjectConstruction2Events_Value = Guid.initString("4b5a7827-8df2-45c0-8f6f-57ea1f856a9f");
|
|
pub const IID_IComObjectConstruction2Events = &IID_IComObjectConstruction2Events_Value;
|
|
pub const IComObjectConstruction2Events = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnObjectConstruct2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComObjectConstruction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
sConstructString: ?[*:0]const u16,
|
|
oid: u64,
|
|
guidPartition: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComObjectConstruction2Events,
|
|
pInfo: ?*COMSVCSEVENTINFO,
|
|
guidObject: ?*const Guid,
|
|
sConstructString: ?[*:0]const u16,
|
|
oid: u64,
|
|
guidPartition: ?*const Guid,
|
|
) 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 IComObjectConstruction2Events_OnObjectConstruct2(self: *const T, pInfo: ?*COMSVCSEVENTINFO, guidObject: ?*const Guid, sConstructString: ?[*:0]const u16, oid: u64, guidPartition: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IComObjectConstruction2Events.VTable, @ptrCast(self.vtable)).OnObjectConstruct2(@as(*const IComObjectConstruction2Events, @ptrCast(self)), pInfo, guidObject, sConstructString, oid, guidPartition);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISystemAppEventData_Value = Guid.initString("d6d48a3c-d5c5-49e7-8c74-99e4889ed52f");
|
|
pub const IID_ISystemAppEventData = &IID_ISystemAppEventData_Value;
|
|
pub const ISystemAppEventData = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Startup: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISystemAppEventData,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISystemAppEventData,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
OnDataChanged: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISystemAppEventData,
|
|
dwPID: u32,
|
|
dwMask: u32,
|
|
dwNumberSinks: u32,
|
|
bstrDwMethodMask: ?BSTR,
|
|
dwReason: u32,
|
|
u64TraceHandle: u64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISystemAppEventData,
|
|
dwPID: u32,
|
|
dwMask: u32,
|
|
dwNumberSinks: u32,
|
|
bstrDwMethodMask: ?BSTR,
|
|
dwReason: u32,
|
|
u64TraceHandle: u64,
|
|
) 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 ISystemAppEventData_Startup(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ISystemAppEventData.VTable, @ptrCast(self.vtable)).Startup(@as(*const ISystemAppEventData, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISystemAppEventData_OnDataChanged(self: *const T, dwPID: u32, dwMask: u32, dwNumberSinks: u32, bstrDwMethodMask: ?BSTR, dwReason: u32, u64TraceHandle: u64) callconv(.Inline) HRESULT {
|
|
return @as(*const ISystemAppEventData.VTable, @ptrCast(self.vtable)).OnDataChanged(@as(*const ISystemAppEventData, @ptrCast(self)), dwPID, dwMask, dwNumberSinks, bstrDwMethodMask, dwReason, u64TraceHandle);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IMtsEvents_Value = Guid.initString("bacedf4d-74ab-11d0-b162-00aa00ba3258");
|
|
pub const IID_IMtsEvents = &IID_IMtsEvents_Value;
|
|
pub const IMtsEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_PackageName: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsEvents,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsEvents,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_PackageGuid: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsEvents,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsEvents,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PostEvent: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMtsEvents,
|
|
vEvent: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMtsEvents,
|
|
vEvent: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_FireEvents: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsEvents,
|
|
pVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsEvents,
|
|
pVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetProcessID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMtsEvents,
|
|
id: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMtsEvents,
|
|
id: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEvents_get_PackageName(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).get_PackageName(@as(*const IMtsEvents, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEvents_get_PackageGuid(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).get_PackageGuid(@as(*const IMtsEvents, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEvents_PostEvent(self: *const T, vEvent: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).PostEvent(@as(*const IMtsEvents, @ptrCast(self)), vEvent);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEvents_get_FireEvents(self: *const T, pVal: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).get_FireEvents(@as(*const IMtsEvents, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEvents_GetProcessID(self: *const T, id: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEvents.VTable, @ptrCast(self.vtable)).GetProcessID(@as(*const IMtsEvents, @ptrCast(self)), id);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IMtsEventInfo_Value = Guid.initString("d56c3dc1-8482-11d0-b170-00aa00ba3258");
|
|
pub const IID_IMtsEventInfo = &IID_IMtsEventInfo_Value;
|
|
pub const IMtsEventInfo = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Names: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsEventInfo,
|
|
pUnk: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsEventInfo,
|
|
pUnk: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_DisplayName: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsEventInfo,
|
|
sDisplayName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsEventInfo,
|
|
sDisplayName: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_EventID: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsEventInfo,
|
|
sGuidEventID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsEventInfo,
|
|
sGuidEventID: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsEventInfo,
|
|
lCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsEventInfo,
|
|
lCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Value: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsEventInfo,
|
|
sKey: ?BSTR,
|
|
pVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsEventInfo,
|
|
sKey: ?BSTR,
|
|
pVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEventInfo_get_Names(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_Names(@as(*const IMtsEventInfo, @ptrCast(self)), pUnk);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEventInfo_get_DisplayName(self: *const T, sDisplayName: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_DisplayName(@as(*const IMtsEventInfo, @ptrCast(self)), sDisplayName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEventInfo_get_EventID(self: *const T, sGuidEventID: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_EventID(@as(*const IMtsEventInfo, @ptrCast(self)), sGuidEventID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEventInfo_get_Count(self: *const T, lCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IMtsEventInfo, @ptrCast(self)), lCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsEventInfo_get_Value(self: *const T, sKey: ?BSTR, pVal: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsEventInfo.VTable, @ptrCast(self.vtable)).get_Value(@as(*const IMtsEventInfo, @ptrCast(self)), sKey, pVal);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IMTSLocator_Value = Guid.initString("d19b8bfd-7f88-11d0-b16e-00aa00ba3258");
|
|
pub const IID_IMTSLocator = &IID_IMTSLocator_Value;
|
|
pub const IMTSLocator = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
GetEventDispatcher: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMTSLocator,
|
|
pUnk: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMTSLocator,
|
|
pUnk: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMTSLocator_GetEventDispatcher(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IMTSLocator.VTable, @ptrCast(self.vtable)).GetEventDispatcher(@as(*const IMTSLocator, @ptrCast(self)), pUnk);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IMtsGrp_Value = Guid.initString("4b2e958c-0393-11d1-b1ab-00aa00ba3258");
|
|
pub const IID_IMtsGrp = &IID_IMtsGrp_Value;
|
|
pub const IMtsGrp = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMtsGrp,
|
|
pVal: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMtsGrp,
|
|
pVal: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Item: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMtsGrp,
|
|
lIndex: i32,
|
|
ppUnkDispatcher: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMtsGrp,
|
|
lIndex: i32,
|
|
ppUnkDispatcher: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Refresh: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMtsGrp,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMtsGrp,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsGrp_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsGrp.VTable, @ptrCast(self.vtable)).get_Count(@as(*const IMtsGrp, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsGrp_Item(self: *const T, lIndex: i32, ppUnkDispatcher: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsGrp.VTable, @ptrCast(self.vtable)).Item(@as(*const IMtsGrp, @ptrCast(self)), lIndex, ppUnkDispatcher);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMtsGrp_Refresh(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IMtsGrp.VTable, @ptrCast(self.vtable)).Refresh(@as(*const IMtsGrp, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IMessageMover_Value = Guid.initString("588a085a-b795-11d1-8054-00c04fc340ee");
|
|
pub const IID_IMessageMover = &IID_IMessageMover_Value;
|
|
pub const IMessageMover = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_SourcePath: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMessageMover,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMessageMover,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_SourcePath: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMessageMover,
|
|
newVal: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMessageMover,
|
|
newVal: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_DestPath: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMessageMover,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMessageMover,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_DestPath: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMessageMover,
|
|
newVal: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMessageMover,
|
|
newVal: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_CommitBatchSize: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMessageMover,
|
|
pVal: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMessageMover,
|
|
pVal: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_CommitBatchSize: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IMessageMover,
|
|
newVal: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IMessageMover,
|
|
newVal: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
MoveMessages: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMessageMover,
|
|
plMessagesMoved: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMessageMover,
|
|
plMessagesMoved: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMessageMover_get_SourcePath(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).get_SourcePath(@as(*const IMessageMover, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMessageMover_put_SourcePath(self: *const T, newVal: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).put_SourcePath(@as(*const IMessageMover, @ptrCast(self)), newVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMessageMover_get_DestPath(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).get_DestPath(@as(*const IMessageMover, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMessageMover_put_DestPath(self: *const T, newVal: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).put_DestPath(@as(*const IMessageMover, @ptrCast(self)), newVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMessageMover_get_CommitBatchSize(self: *const T, pVal: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).get_CommitBatchSize(@as(*const IMessageMover, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMessageMover_put_CommitBatchSize(self: *const T, newVal: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).put_CommitBatchSize(@as(*const IMessageMover, @ptrCast(self)), newVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMessageMover_MoveMessages(self: *const T, plMessagesMoved: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IMessageMover.VTable, @ptrCast(self.vtable)).MoveMessages(@as(*const IMessageMover, @ptrCast(self)), plMessagesMoved);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IEventServerTrace_Value = Guid.initString("9a9f12b8-80af-47ab-a579-35ea57725370");
|
|
pub const IID_IEventServerTrace = &IID_IEventServerTrace_Value;
|
|
pub const IEventServerTrace = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
StartTraceGuid: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IEventServerTrace,
|
|
bstrguidEvent: ?BSTR,
|
|
bstrguidFilter: ?BSTR,
|
|
lPidFilter: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IEventServerTrace,
|
|
bstrguidEvent: ?BSTR,
|
|
bstrguidFilter: ?BSTR,
|
|
lPidFilter: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
StopTraceGuid: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IEventServerTrace,
|
|
bstrguidEvent: ?BSTR,
|
|
bstrguidFilter: ?BSTR,
|
|
lPidFilter: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IEventServerTrace,
|
|
bstrguidEvent: ?BSTR,
|
|
bstrguidFilter: ?BSTR,
|
|
lPidFilter: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnumTraceGuid: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IEventServerTrace,
|
|
plCntGuids: ?*i32,
|
|
pbstrGuidList: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IEventServerTrace,
|
|
plCntGuids: ?*i32,
|
|
pbstrGuidList: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IEventServerTrace_StartTraceGuid(self: *const T, bstrguidEvent: ?BSTR, bstrguidFilter: ?BSTR, lPidFilter: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IEventServerTrace.VTable, @ptrCast(self.vtable)).StartTraceGuid(@as(*const IEventServerTrace, @ptrCast(self)), bstrguidEvent, bstrguidFilter, lPidFilter);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IEventServerTrace_StopTraceGuid(self: *const T, bstrguidEvent: ?BSTR, bstrguidFilter: ?BSTR, lPidFilter: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IEventServerTrace.VTable, @ptrCast(self.vtable)).StopTraceGuid(@as(*const IEventServerTrace, @ptrCast(self)), bstrguidEvent, bstrguidFilter, lPidFilter);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IEventServerTrace_EnumTraceGuid(self: *const T, plCntGuids: ?*i32, pbstrGuidList: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IEventServerTrace.VTable, @ptrCast(self.vtable)).EnumTraceGuid(@as(*const IEventServerTrace, @ptrCast(self)), plCntGuids, pbstrGuidList);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const RECYCLE_INFO = extern struct {
|
|
guidCombaseProcessIdentifier: Guid,
|
|
ProcessStartTime: i64,
|
|
dwRecycleLifetimeLimit: u32,
|
|
dwRecycleMemoryLimit: u32,
|
|
dwRecycleExpirationTimeout: u32,
|
|
};
|
|
|
|
pub const DUMPTYPE = enum(i32) {
|
|
FULL = 0,
|
|
MINI = 1,
|
|
NONE = 2,
|
|
};
|
|
pub const DUMPTYPE_FULL = DUMPTYPE.FULL;
|
|
pub const DUMPTYPE_MINI = DUMPTYPE.MINI;
|
|
pub const DUMPTYPE_NONE = DUMPTYPE.NONE;
|
|
|
|
pub const HANG_INFO = extern struct {
|
|
fAppHangMonitorEnabled: BOOL,
|
|
fTerminateOnHang: BOOL,
|
|
DumpType: DUMPTYPE,
|
|
dwHangTimeout: u32,
|
|
dwDumpCount: u32,
|
|
dwInfoMsgCount: u32,
|
|
};
|
|
|
|
pub const COMPLUS_APPTYPE = enum(i32) {
|
|
UNKNOWN = -1,
|
|
SERVER = 1,
|
|
LIBRARY = 0,
|
|
SWC = 2,
|
|
};
|
|
pub const APPTYPE_UNKNOWN = COMPLUS_APPTYPE.UNKNOWN;
|
|
pub const APPTYPE_SERVER = COMPLUS_APPTYPE.SERVER;
|
|
pub const APPTYPE_LIBRARY = COMPLUS_APPTYPE.LIBRARY;
|
|
pub const APPTYPE_SWC = COMPLUS_APPTYPE.SWC;
|
|
|
|
pub const CAppStatistics = extern struct {
|
|
m_cTotalCalls: u32,
|
|
m_cTotalInstances: u32,
|
|
m_cTotalClasses: u32,
|
|
m_cCallsPerSecond: u32,
|
|
};
|
|
|
|
pub const CAppData = extern struct {
|
|
m_idApp: u32,
|
|
m_szAppGuid: [40]u16,
|
|
m_dwAppProcessId: u32,
|
|
m_AppStatistics: CAppStatistics,
|
|
};
|
|
|
|
pub const CCLSIDData = extern struct {
|
|
m_clsid: Guid,
|
|
m_cReferences: u32,
|
|
m_cBound: u32,
|
|
m_cPooled: u32,
|
|
m_cInCall: u32,
|
|
m_dwRespTime: u32,
|
|
m_cCallsCompleted: u32,
|
|
m_cCallsFailed: u32,
|
|
};
|
|
|
|
pub const CCLSIDData2 = extern struct {
|
|
m_clsid: Guid,
|
|
m_appid: Guid,
|
|
m_partid: Guid,
|
|
m_pwszAppName: ?PWSTR,
|
|
m_pwszCtxName: ?PWSTR,
|
|
m_eAppType: COMPLUS_APPTYPE,
|
|
m_cReferences: u32,
|
|
m_cBound: u32,
|
|
m_cPooled: u32,
|
|
m_cInCall: u32,
|
|
m_dwRespTime: u32,
|
|
m_cCallsCompleted: u32,
|
|
m_cCallsFailed: u32,
|
|
};
|
|
|
|
pub const GetAppTrackerDataFlags = enum(i32) {
|
|
PROCESS_EXE_NAME = 1,
|
|
LIBRARY_APPS = 2,
|
|
SWC = 4,
|
|
CLASS_NAME = 8,
|
|
APPLICATION_NAME = 16,
|
|
};
|
|
pub const GATD_INCLUDE_PROCESS_EXE_NAME = GetAppTrackerDataFlags.PROCESS_EXE_NAME;
|
|
pub const GATD_INCLUDE_LIBRARY_APPS = GetAppTrackerDataFlags.LIBRARY_APPS;
|
|
pub const GATD_INCLUDE_SWC = GetAppTrackerDataFlags.SWC;
|
|
pub const GATD_INCLUDE_CLASS_NAME = GetAppTrackerDataFlags.CLASS_NAME;
|
|
pub const GATD_INCLUDE_APPLICATION_NAME = GetAppTrackerDataFlags.APPLICATION_NAME;
|
|
|
|
pub const ApplicationProcessSummary = extern struct {
|
|
PartitionIdPrimaryApplication: Guid,
|
|
ApplicationIdPrimaryApplication: Guid,
|
|
ApplicationInstanceId: Guid,
|
|
ProcessId: u32,
|
|
Type: COMPLUS_APPTYPE,
|
|
ProcessExeName: ?PWSTR,
|
|
IsService: BOOL,
|
|
IsPaused: BOOL,
|
|
IsRecycled: BOOL,
|
|
};
|
|
|
|
pub const ApplicationProcessStatistics = extern struct {
|
|
NumCallsOutstanding: u32,
|
|
NumTrackedComponents: u32,
|
|
NumComponentInstances: u32,
|
|
AvgCallsPerSecond: u32,
|
|
Reserved1: u32,
|
|
Reserved2: u32,
|
|
Reserved3: u32,
|
|
Reserved4: u32,
|
|
};
|
|
|
|
pub const ApplicationProcessRecycleInfo = extern struct {
|
|
IsRecyclable: BOOL,
|
|
IsRecycled: BOOL,
|
|
TimeRecycled: FILETIME,
|
|
TimeToTerminate: FILETIME,
|
|
RecycleReasonCode: i32,
|
|
IsPendingRecycle: BOOL,
|
|
HasAutomaticLifetimeRecycling: BOOL,
|
|
TimeForAutomaticRecycling: FILETIME,
|
|
MemoryLimitInKB: u32,
|
|
MemoryUsageInKBLastCheck: u32,
|
|
ActivationLimit: u32,
|
|
NumActivationsLastReported: u32,
|
|
CallLimit: u32,
|
|
NumCallsLastReported: u32,
|
|
};
|
|
|
|
pub const ApplicationSummary = extern struct {
|
|
ApplicationInstanceId: Guid,
|
|
PartitionId: Guid,
|
|
ApplicationId: Guid,
|
|
Type: COMPLUS_APPTYPE,
|
|
ApplicationName: ?PWSTR,
|
|
NumTrackedComponents: u32,
|
|
NumComponentInstances: u32,
|
|
};
|
|
|
|
pub const ComponentSummary = extern struct {
|
|
ApplicationInstanceId: Guid,
|
|
PartitionId: Guid,
|
|
ApplicationId: Guid,
|
|
Clsid: Guid,
|
|
ClassName: ?PWSTR,
|
|
ApplicationName: ?PWSTR,
|
|
};
|
|
|
|
pub const ComponentStatistics = extern struct {
|
|
NumInstances: u32,
|
|
NumBoundReferences: u32,
|
|
NumPooledObjects: u32,
|
|
NumObjectsInCall: u32,
|
|
AvgResponseTimeInMs: u32,
|
|
NumCallsCompletedRecent: u32,
|
|
NumCallsFailedRecent: u32,
|
|
NumCallsCompletedTotal: u32,
|
|
NumCallsFailedTotal: u32,
|
|
Reserved1: u32,
|
|
Reserved2: u32,
|
|
Reserved3: u32,
|
|
Reserved4: u32,
|
|
};
|
|
|
|
pub const ComponentHangMonitorInfo = extern struct {
|
|
IsMonitored: BOOL,
|
|
TerminateOnHang: BOOL,
|
|
AvgCallThresholdInMs: u32,
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IGetAppTrackerData_Value = Guid.initString("507c3ac8-3e12-4cb0-9366-653d3e050638");
|
|
pub const IID_IGetAppTrackerData = &IID_IGetAppTrackerData_Value;
|
|
pub const IGetAppTrackerData = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetApplicationProcesses: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetAppTrackerData,
|
|
PartitionId: ?*const Guid,
|
|
ApplicationId: ?*const Guid,
|
|
Flags: u32,
|
|
NumApplicationProcesses: ?*u32,
|
|
ApplicationProcesses: [*]?*ApplicationProcessSummary,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetAppTrackerData,
|
|
PartitionId: ?*const Guid,
|
|
ApplicationId: ?*const Guid,
|
|
Flags: u32,
|
|
NumApplicationProcesses: ?*u32,
|
|
ApplicationProcesses: [*]?*ApplicationProcessSummary,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetApplicationProcessDetails: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetAppTrackerData,
|
|
ApplicationInstanceId: ?*const Guid,
|
|
ProcessId: u32,
|
|
Flags: u32,
|
|
Summary: ?*ApplicationProcessSummary,
|
|
Statistics: ?*ApplicationProcessStatistics,
|
|
RecycleInfo: ?*ApplicationProcessRecycleInfo,
|
|
AnyComponentsHangMonitored: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetAppTrackerData,
|
|
ApplicationInstanceId: ?*const Guid,
|
|
ProcessId: u32,
|
|
Flags: u32,
|
|
Summary: ?*ApplicationProcessSummary,
|
|
Statistics: ?*ApplicationProcessStatistics,
|
|
RecycleInfo: ?*ApplicationProcessRecycleInfo,
|
|
AnyComponentsHangMonitored: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetApplicationsInProcess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetAppTrackerData,
|
|
ApplicationInstanceId: ?*const Guid,
|
|
ProcessId: u32,
|
|
PartitionId: ?*const Guid,
|
|
Flags: u32,
|
|
NumApplicationsInProcess: ?*u32,
|
|
Applications: [*]?*ApplicationSummary,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetAppTrackerData,
|
|
ApplicationInstanceId: ?*const Guid,
|
|
ProcessId: u32,
|
|
PartitionId: ?*const Guid,
|
|
Flags: u32,
|
|
NumApplicationsInProcess: ?*u32,
|
|
Applications: [*]?*ApplicationSummary,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetComponentsInProcess: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetAppTrackerData,
|
|
ApplicationInstanceId: ?*const Guid,
|
|
ProcessId: u32,
|
|
PartitionId: ?*const Guid,
|
|
ApplicationId: ?*const Guid,
|
|
Flags: u32,
|
|
NumComponentsInProcess: ?*u32,
|
|
Components: [*]?*ComponentSummary,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetAppTrackerData,
|
|
ApplicationInstanceId: ?*const Guid,
|
|
ProcessId: u32,
|
|
PartitionId: ?*const Guid,
|
|
ApplicationId: ?*const Guid,
|
|
Flags: u32,
|
|
NumComponentsInProcess: ?*u32,
|
|
Components: [*]?*ComponentSummary,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetComponentDetails: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetAppTrackerData,
|
|
ApplicationInstanceId: ?*const Guid,
|
|
ProcessId: u32,
|
|
Clsid: ?*const Guid,
|
|
Flags: u32,
|
|
Summary: ?*ComponentSummary,
|
|
Statistics: ?*ComponentStatistics,
|
|
HangMonitorInfo: ?*ComponentHangMonitorInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetAppTrackerData,
|
|
ApplicationInstanceId: ?*const Guid,
|
|
ProcessId: u32,
|
|
Clsid: ?*const Guid,
|
|
Flags: u32,
|
|
Summary: ?*ComponentSummary,
|
|
Statistics: ?*ComponentStatistics,
|
|
HangMonitorInfo: ?*ComponentHangMonitorInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTrackerDataAsCollectionObject: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetAppTrackerData,
|
|
TopLevelCollection: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetAppTrackerData,
|
|
TopLevelCollection: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetSuggestedPollingInterval: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetAppTrackerData,
|
|
PollingIntervalInSeconds: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetAppTrackerData,
|
|
PollingIntervalInSeconds: ?*u32,
|
|
) 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 IGetAppTrackerData_GetApplicationProcesses(self: *const T, PartitionId: ?*const Guid, ApplicationId: ?*const Guid, Flags: u32, NumApplicationProcesses: ?*u32, ApplicationProcesses: [*]?*ApplicationProcessSummary) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetApplicationProcesses(@as(*const IGetAppTrackerData, @ptrCast(self)), PartitionId, ApplicationId, Flags, NumApplicationProcesses, ApplicationProcesses);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetAppTrackerData_GetApplicationProcessDetails(self: *const T, ApplicationInstanceId: ?*const Guid, ProcessId: u32, Flags: u32, Summary: ?*ApplicationProcessSummary, Statistics: ?*ApplicationProcessStatistics, RecycleInfo: ?*ApplicationProcessRecycleInfo, AnyComponentsHangMonitored: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetApplicationProcessDetails(@as(*const IGetAppTrackerData, @ptrCast(self)), ApplicationInstanceId, ProcessId, Flags, Summary, Statistics, RecycleInfo, AnyComponentsHangMonitored);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetAppTrackerData_GetApplicationsInProcess(self: *const T, ApplicationInstanceId: ?*const Guid, ProcessId: u32, PartitionId: ?*const Guid, Flags: u32, NumApplicationsInProcess: ?*u32, Applications: [*]?*ApplicationSummary) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetApplicationsInProcess(@as(*const IGetAppTrackerData, @ptrCast(self)), ApplicationInstanceId, ProcessId, PartitionId, Flags, NumApplicationsInProcess, Applications);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetAppTrackerData_GetComponentsInProcess(self: *const T, ApplicationInstanceId: ?*const Guid, ProcessId: u32, PartitionId: ?*const Guid, ApplicationId: ?*const Guid, Flags: u32, NumComponentsInProcess: ?*u32, Components: [*]?*ComponentSummary) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetComponentsInProcess(@as(*const IGetAppTrackerData, @ptrCast(self)), ApplicationInstanceId, ProcessId, PartitionId, ApplicationId, Flags, NumComponentsInProcess, Components);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetAppTrackerData_GetComponentDetails(self: *const T, ApplicationInstanceId: ?*const Guid, ProcessId: u32, Clsid: ?*const Guid, Flags: u32, Summary: ?*ComponentSummary, Statistics: ?*ComponentStatistics, HangMonitorInfo: ?*ComponentHangMonitorInfo) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetComponentDetails(@as(*const IGetAppTrackerData, @ptrCast(self)), ApplicationInstanceId, ProcessId, Clsid, Flags, Summary, Statistics, HangMonitorInfo);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetAppTrackerData_GetTrackerDataAsCollectionObject(self: *const T, TopLevelCollection: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetTrackerDataAsCollectionObject(@as(*const IGetAppTrackerData, @ptrCast(self)), TopLevelCollection);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetAppTrackerData_GetSuggestedPollingInterval(self: *const T, PollingIntervalInSeconds: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetAppTrackerData.VTable, @ptrCast(self.vtable)).GetSuggestedPollingInterval(@as(*const IGetAppTrackerData, @ptrCast(self)), PollingIntervalInSeconds);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IDispenserManager_Value = Guid.initString("5cb31e10-2b5f-11cf-be10-00aa00a2fa25");
|
|
pub const IID_IDispenserManager = &IID_IDispenserManager_Value;
|
|
pub const IDispenserManager = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
RegisterDispenser: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDispenserManager,
|
|
__MIDL__IDispenserManager0000: ?*IDispenserDriver,
|
|
szDispenserName: ?[*:0]const u16,
|
|
__MIDL__IDispenserManager0001: ?*?*IHolder,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDispenserManager,
|
|
__MIDL__IDispenserManager0000: ?*IDispenserDriver,
|
|
szDispenserName: ?[*:0]const u16,
|
|
__MIDL__IDispenserManager0001: ?*?*IHolder,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetContext: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDispenserManager,
|
|
__MIDL__IDispenserManager0002: ?*usize,
|
|
__MIDL__IDispenserManager0003: ?*usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDispenserManager,
|
|
__MIDL__IDispenserManager0002: ?*usize,
|
|
__MIDL__IDispenserManager0003: ?*usize,
|
|
) 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 IDispenserManager_RegisterDispenser(self: *const T, __MIDL__IDispenserManager0000: ?*IDispenserDriver, szDispenserName: ?[*:0]const u16, __MIDL__IDispenserManager0001: ?*?*IHolder) callconv(.Inline) HRESULT {
|
|
return @as(*const IDispenserManager.VTable, @ptrCast(self.vtable)).RegisterDispenser(@as(*const IDispenserManager, @ptrCast(self)), __MIDL__IDispenserManager0000, szDispenserName, __MIDL__IDispenserManager0001);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDispenserManager_GetContext(self: *const T, __MIDL__IDispenserManager0002: ?*usize, __MIDL__IDispenserManager0003: ?*usize) callconv(.Inline) HRESULT {
|
|
return @as(*const IDispenserManager.VTable, @ptrCast(self.vtable)).GetContext(@as(*const IDispenserManager, @ptrCast(self)), __MIDL__IDispenserManager0002, __MIDL__IDispenserManager0003);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IHolder_Value = Guid.initString("bf6a1850-2b45-11cf-be10-00aa00a2fa25");
|
|
pub const IID_IHolder = &IID_IHolder_Value;
|
|
pub const IHolder = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
AllocResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0000: usize,
|
|
__MIDL__IHolder0001: ?*usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0000: usize,
|
|
__MIDL__IHolder0001: ?*usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
FreeResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0002: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0002: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TrackResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0003: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0003: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TrackResourceS: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0004: ?*u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0004: ?*u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
UntrackResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0005: usize,
|
|
__MIDL__IHolder0006: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0005: usize,
|
|
__MIDL__IHolder0006: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
UntrackResourceS: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0007: ?*u16,
|
|
__MIDL__IHolder0008: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0007: ?*u16,
|
|
__MIDL__IHolder0008: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Close: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IHolder,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IHolder,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RequestDestroyResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0009: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IHolder,
|
|
__MIDL__IHolder0009: usize,
|
|
) 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 IHolder_AllocResource(self: *const T, __MIDL__IHolder0000: usize, __MIDL__IHolder0001: ?*usize) callconv(.Inline) HRESULT {
|
|
return @as(*const IHolder.VTable, @ptrCast(self.vtable)).AllocResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0000, __MIDL__IHolder0001);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IHolder_FreeResource(self: *const T, __MIDL__IHolder0002: usize) callconv(.Inline) HRESULT {
|
|
return @as(*const IHolder.VTable, @ptrCast(self.vtable)).FreeResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0002);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IHolder_TrackResource(self: *const T, __MIDL__IHolder0003: usize) callconv(.Inline) HRESULT {
|
|
return @as(*const IHolder.VTable, @ptrCast(self.vtable)).TrackResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0003);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IHolder_TrackResourceS(self: *const T, __MIDL__IHolder0004: ?*u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IHolder.VTable, @ptrCast(self.vtable)).TrackResourceS(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0004);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IHolder_UntrackResource(self: *const T, __MIDL__IHolder0005: usize, __MIDL__IHolder0006: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IHolder.VTable, @ptrCast(self.vtable)).UntrackResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0005, __MIDL__IHolder0006);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IHolder_UntrackResourceS(self: *const T, __MIDL__IHolder0007: ?*u16, __MIDL__IHolder0008: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IHolder.VTable, @ptrCast(self.vtable)).UntrackResourceS(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0007, __MIDL__IHolder0008);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IHolder_Close(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IHolder.VTable, @ptrCast(self.vtable)).Close(@as(*const IHolder, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IHolder_RequestDestroyResource(self: *const T, __MIDL__IHolder0009: usize) callconv(.Inline) HRESULT {
|
|
return @as(*const IHolder.VTable, @ptrCast(self.vtable)).RequestDestroyResource(@as(*const IHolder, @ptrCast(self)), __MIDL__IHolder0009);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IDispenserDriver_Value = Guid.initString("208b3651-2b48-11cf-be10-00aa00a2fa25");
|
|
pub const IID_IDispenserDriver = &IID_IDispenserDriver_Value;
|
|
pub const IDispenserDriver = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDispenserDriver,
|
|
ResTypId: usize,
|
|
pResId: ?*usize,
|
|
pSecsFreeBeforeDestroy: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDispenserDriver,
|
|
ResTypId: usize,
|
|
pResId: ?*usize,
|
|
pSecsFreeBeforeDestroy: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RateResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDispenserDriver,
|
|
ResTypId: usize,
|
|
ResId: usize,
|
|
fRequiresTransactionEnlistment: BOOL,
|
|
pRating: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDispenserDriver,
|
|
ResTypId: usize,
|
|
ResId: usize,
|
|
fRequiresTransactionEnlistment: BOOL,
|
|
pRating: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnlistResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDispenserDriver,
|
|
ResId: usize,
|
|
TransId: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDispenserDriver,
|
|
ResId: usize,
|
|
TransId: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ResetResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDispenserDriver,
|
|
ResId: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDispenserDriver,
|
|
ResId: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DestroyResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDispenserDriver,
|
|
ResId: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDispenserDriver,
|
|
ResId: usize,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DestroyResourceS: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IDispenserDriver,
|
|
ResId: ?*u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IDispenserDriver,
|
|
ResId: ?*u16,
|
|
) 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 IDispenserDriver_CreateResource(self: *const T, ResTypId: usize, pResId: ?*usize, pSecsFreeBeforeDestroy: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).CreateResource(@as(*const IDispenserDriver, @ptrCast(self)), ResTypId, pResId, pSecsFreeBeforeDestroy);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDispenserDriver_RateResource(self: *const T, ResTypId: usize, ResId: usize, fRequiresTransactionEnlistment: BOOL, pRating: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).RateResource(@as(*const IDispenserDriver, @ptrCast(self)), ResTypId, ResId, fRequiresTransactionEnlistment, pRating);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDispenserDriver_EnlistResource(self: *const T, ResId: usize, TransId: usize) callconv(.Inline) HRESULT {
|
|
return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).EnlistResource(@as(*const IDispenserDriver, @ptrCast(self)), ResId, TransId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDispenserDriver_ResetResource(self: *const T, ResId: usize) callconv(.Inline) HRESULT {
|
|
return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).ResetResource(@as(*const IDispenserDriver, @ptrCast(self)), ResId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDispenserDriver_DestroyResource(self: *const T, ResId: usize) callconv(.Inline) HRESULT {
|
|
return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).DestroyResource(@as(*const IDispenserDriver, @ptrCast(self)), ResId);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IDispenserDriver_DestroyResourceS(self: *const T, ResId: ?*u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IDispenserDriver.VTable, @ptrCast(self.vtable)).DestroyResourceS(@as(*const IDispenserDriver, @ptrCast(self)), ResId);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_ITransactionProxy_Value = Guid.initString("02558374-df2e-4dae-bd6b-1d5c994f9bdc");
|
|
pub const IID_ITransactionProxy = &IID_ITransactionProxy_Value;
|
|
pub const ITransactionProxy = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Commit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProxy,
|
|
guid: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionProxy,
|
|
guid: Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Abort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProxy,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionProxy,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Promote: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProxy,
|
|
pTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionProxy,
|
|
pTransaction: ?*?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateVoter: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProxy,
|
|
pTxAsync: ?*ITransactionVoterNotifyAsync2,
|
|
ppBallot: ?*?*ITransactionVoterBallotAsync2,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionProxy,
|
|
pTxAsync: ?*ITransactionVoterNotifyAsync2,
|
|
ppBallot: ?*?*ITransactionVoterBallotAsync2,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetIsolationLevel: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProxy,
|
|
__MIDL__ITransactionProxy0000: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionProxy,
|
|
__MIDL__ITransactionProxy0000: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetIdentifier: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProxy,
|
|
pbstrIdentifier: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionProxy,
|
|
pbstrIdentifier: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsReusable: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProxy,
|
|
pfIsReusable: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionProxy,
|
|
pfIsReusable: ?*BOOL,
|
|
) 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 ITransactionProxy_Commit(self: *const T, guid: Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).Commit(@as(*const ITransactionProxy, @ptrCast(self)), guid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProxy_Abort(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).Abort(@as(*const ITransactionProxy, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProxy_Promote(self: *const T, pTransaction: ?*?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).Promote(@as(*const ITransactionProxy, @ptrCast(self)), pTransaction);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProxy_CreateVoter(self: *const T, pTxAsync: ?*ITransactionVoterNotifyAsync2, ppBallot: ?*?*ITransactionVoterBallotAsync2) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).CreateVoter(@as(*const ITransactionProxy, @ptrCast(self)), pTxAsync, ppBallot);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProxy_GetIsolationLevel(self: *const T, __MIDL__ITransactionProxy0000: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).GetIsolationLevel(@as(*const ITransactionProxy, @ptrCast(self)), __MIDL__ITransactionProxy0000);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProxy_GetIdentifier(self: *const T, pbstrIdentifier: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).GetIdentifier(@as(*const ITransactionProxy, @ptrCast(self)), pbstrIdentifier);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProxy_IsReusable(self: *const T, pfIsReusable: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionProxy.VTable, @ptrCast(self.vtable)).IsReusable(@as(*const ITransactionProxy, @ptrCast(self)), pfIsReusable);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IContextSecurityPerimeter_Value = Guid.initString("a7549a29-a7c4-42e1-8dc1-7e3d748dc24a");
|
|
pub const IID_IContextSecurityPerimeter = &IID_IContextSecurityPerimeter_Value;
|
|
pub const IContextSecurityPerimeter = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetPerimeterFlag: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextSecurityPerimeter,
|
|
pFlag: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextSecurityPerimeter,
|
|
pFlag: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetPerimeterFlag: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextSecurityPerimeter,
|
|
fFlag: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextSecurityPerimeter,
|
|
fFlag: BOOL,
|
|
) 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 IContextSecurityPerimeter_GetPerimeterFlag(self: *const T, pFlag: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextSecurityPerimeter.VTable, @ptrCast(self.vtable)).GetPerimeterFlag(@as(*const IContextSecurityPerimeter, @ptrCast(self)), pFlag);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContextSecurityPerimeter_SetPerimeterFlag(self: *const T, fFlag: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextSecurityPerimeter.VTable, @ptrCast(self.vtable)).SetPerimeterFlag(@as(*const IContextSecurityPerimeter, @ptrCast(self)), fFlag);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_ITxProxyHolder_Value = Guid.initString("13d86f31-0139-41af-bcad-c7d50435fe9f");
|
|
pub const IID_ITxProxyHolder = &IID_ITxProxyHolder_Value;
|
|
pub const ITxProxyHolder = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetIdentifier: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITxProxyHolder,
|
|
pGuidLtx: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITxProxyHolder,
|
|
pGuidLtx: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
};
|
|
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 ITxProxyHolder_GetIdentifier(self: *const T, pGuidLtx: ?*Guid) callconv(.Inline) void {
|
|
return @as(*const ITxProxyHolder.VTable, @ptrCast(self.vtable)).GetIdentifier(@as(*const ITxProxyHolder, @ptrCast(self)), pGuidLtx);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IObjectContext_Value = Guid.initString("51372ae0-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IObjectContext = &IID_IObjectContext_Value;
|
|
pub const IObjectContext = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateInstance: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContext,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
ppv: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContext,
|
|
rclsid: ?*const Guid,
|
|
riid: ?*const Guid,
|
|
ppv: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetComplete: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnableCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DisableCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsInTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) BOOL,
|
|
else => *const fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) BOOL,
|
|
},
|
|
IsSecurityEnabled: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) BOOL,
|
|
else => *const fn(
|
|
self: *const IObjectContext,
|
|
) callconv(@import("std").os.windows.WINAPI) BOOL,
|
|
},
|
|
IsCallerInRole: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContext,
|
|
bstrRole: ?BSTR,
|
|
pfIsInRole: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContext,
|
|
bstrRole: ?BSTR,
|
|
pfIsInRole: ?*BOOL,
|
|
) 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 IObjectContext_CreateInstance(self: *const T, rclsid: ?*const Guid, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).CreateInstance(@as(*const IObjectContext, @ptrCast(self)), rclsid, riid, ppv);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContext_SetComplete(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).SetComplete(@as(*const IObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContext_SetAbort(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).SetAbort(@as(*const IObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContext_EnableCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).EnableCommit(@as(*const IObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContext_DisableCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).DisableCommit(@as(*const IObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContext_IsInTransaction(self: *const T) callconv(.Inline) BOOL {
|
|
return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).IsInTransaction(@as(*const IObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContext_IsSecurityEnabled(self: *const T) callconv(.Inline) BOOL {
|
|
return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).IsSecurityEnabled(@as(*const IObjectContext, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContext_IsCallerInRole(self: *const T, bstrRole: ?BSTR, pfIsInRole: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContext.VTable, @ptrCast(self.vtable)).IsCallerInRole(@as(*const IObjectContext, @ptrCast(self)), bstrRole, pfIsInRole);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IObjectControl_Value = Guid.initString("51372aec-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IObjectControl = &IID_IObjectControl_Value;
|
|
pub const IObjectControl = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Activate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Deactivate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
CanBePooled: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) BOOL,
|
|
else => *const fn(
|
|
self: *const IObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) BOOL,
|
|
},
|
|
};
|
|
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 IObjectControl_Activate(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectControl.VTable, @ptrCast(self.vtable)).Activate(@as(*const IObjectControl, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectControl_Deactivate(self: *const T) callconv(.Inline) void {
|
|
return @as(*const IObjectControl.VTable, @ptrCast(self.vtable)).Deactivate(@as(*const IObjectControl, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectControl_CanBePooled(self: *const T) callconv(.Inline) BOOL {
|
|
return @as(*const IObjectControl.VTable, @ptrCast(self.vtable)).CanBePooled(@as(*const IObjectControl, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IEnumNames_Value = Guid.initString("51372af2-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IEnumNames = &IID_IEnumNames_Value;
|
|
pub const IEnumNames = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Next: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IEnumNames,
|
|
celt: u32,
|
|
rgname: ?*?BSTR,
|
|
pceltFetched: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IEnumNames,
|
|
celt: u32,
|
|
rgname: ?*?BSTR,
|
|
pceltFetched: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Skip: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IEnumNames,
|
|
celt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IEnumNames,
|
|
celt: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reset: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IEnumNames,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IEnumNames,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Clone: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IEnumNames,
|
|
ppenum: ?*?*IEnumNames,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IEnumNames,
|
|
ppenum: ?*?*IEnumNames,
|
|
) 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 IEnumNames_Next(self: *const T, celt: u32, rgname: ?*?BSTR, pceltFetched: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IEnumNames.VTable, @ptrCast(self.vtable)).Next(@as(*const IEnumNames, @ptrCast(self)), celt, rgname, pceltFetched);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IEnumNames_Skip(self: *const T, celt: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IEnumNames.VTable, @ptrCast(self.vtable)).Skip(@as(*const IEnumNames, @ptrCast(self)), celt);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IEnumNames_Reset(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IEnumNames.VTable, @ptrCast(self.vtable)).Reset(@as(*const IEnumNames, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IEnumNames_Clone(self: *const T, ppenum: ?*?*IEnumNames) callconv(.Inline) HRESULT {
|
|
return @as(*const IEnumNames.VTable, @ptrCast(self.vtable)).Clone(@as(*const IEnumNames, @ptrCast(self)), ppenum);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISecurityProperty_Value = Guid.initString("51372aea-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_ISecurityProperty = &IID_ISecurityProperty_Value;
|
|
pub const ISecurityProperty = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetDirectCreatorSID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?*?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?*?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOriginalCreatorSID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?*?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?*?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetDirectCallerSID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?*?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?*?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetOriginalCallerSID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?*?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?*?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ReleaseSID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?PSID,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISecurityProperty,
|
|
pSID: ?PSID,
|
|
) 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 ISecurityProperty_GetDirectCreatorSID(self: *const T, pSID: ?*?PSID) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).GetDirectCreatorSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityProperty_GetOriginalCreatorSID(self: *const T, pSID: ?*?PSID) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).GetOriginalCreatorSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityProperty_GetDirectCallerSID(self: *const T, pSID: ?*?PSID) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).GetDirectCallerSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityProperty_GetOriginalCallerSID(self: *const T, pSID: ?*?PSID) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).GetOriginalCallerSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISecurityProperty_ReleaseSID(self: *const T, pSID: ?PSID) callconv(.Inline) HRESULT {
|
|
return @as(*const ISecurityProperty.VTable, @ptrCast(self.vtable)).ReleaseSID(@as(*const ISecurityProperty, @ptrCast(self)), pSID);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ObjectControl_Value = Guid.initString("7dc41850-0c31-11d0-8b79-00aa00b8a790");
|
|
pub const IID_ObjectControl = &IID_ObjectControl_Value;
|
|
pub const ObjectControl = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Activate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Deactivate: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CanBePooled: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ObjectControl,
|
|
pbPoolable: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ObjectControl,
|
|
pbPoolable: ?*i16,
|
|
) 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 ObjectControl_Activate(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectControl.VTable, @ptrCast(self.vtable)).Activate(@as(*const ObjectControl, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectControl_Deactivate(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectControl.VTable, @ptrCast(self.vtable)).Deactivate(@as(*const ObjectControl, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ObjectControl_CanBePooled(self: *const T, pbPoolable: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ObjectControl.VTable, @ptrCast(self.vtable)).CanBePooled(@as(*const ObjectControl, @ptrCast(self)), pbPoolable);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISharedProperty_Value = Guid.initString("2a005c01-a5de-11cf-9e66-00aa00a3f464");
|
|
pub const IID_ISharedProperty = &IID_ISharedProperty_Value;
|
|
pub const ISharedProperty = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Value: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISharedProperty,
|
|
pVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISharedProperty,
|
|
pVal: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_Value: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISharedProperty,
|
|
val: VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISharedProperty,
|
|
val: VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedProperty_get_Value(self: *const T, pVal: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedProperty.VTable, @ptrCast(self.vtable)).get_Value(@as(*const ISharedProperty, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedProperty_put_Value(self: *const T, val: VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedProperty.VTable, @ptrCast(self.vtable)).put_Value(@as(*const ISharedProperty, @ptrCast(self)), val);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISharedPropertyGroup_Value = Guid.initString("2a005c07-a5de-11cf-9e66-00aa00a3f464");
|
|
pub const IID_ISharedPropertyGroup = &IID_ISharedPropertyGroup_Value;
|
|
pub const ISharedPropertyGroup = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
CreatePropertyByPosition: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISharedPropertyGroup,
|
|
Index: i32,
|
|
fExists: ?*i16,
|
|
ppProp: ?*?*ISharedProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISharedPropertyGroup,
|
|
Index: i32,
|
|
fExists: ?*i16,
|
|
ppProp: ?*?*ISharedProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_PropertyByPosition: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISharedPropertyGroup,
|
|
Index: i32,
|
|
ppProperty: ?*?*ISharedProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISharedPropertyGroup,
|
|
Index: i32,
|
|
ppProperty: ?*?*ISharedProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CreateProperty: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISharedPropertyGroup,
|
|
Name: ?BSTR,
|
|
fExists: ?*i16,
|
|
ppProp: ?*?*ISharedProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISharedPropertyGroup,
|
|
Name: ?BSTR,
|
|
fExists: ?*i16,
|
|
ppProp: ?*?*ISharedProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Property: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISharedPropertyGroup,
|
|
Name: ?BSTR,
|
|
ppProperty: ?*?*ISharedProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISharedPropertyGroup,
|
|
Name: ?BSTR,
|
|
ppProperty: ?*?*ISharedProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedPropertyGroup_CreatePropertyByPosition(self: *const T, Index: i32, fExists: ?*i16, ppProp: ?*?*ISharedProperty) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedPropertyGroup.VTable, @ptrCast(self.vtable)).CreatePropertyByPosition(@as(*const ISharedPropertyGroup, @ptrCast(self)), Index, fExists, ppProp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedPropertyGroup_get_PropertyByPosition(self: *const T, Index: i32, ppProperty: ?*?*ISharedProperty) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedPropertyGroup.VTable, @ptrCast(self.vtable)).get_PropertyByPosition(@as(*const ISharedPropertyGroup, @ptrCast(self)), Index, ppProperty);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedPropertyGroup_CreateProperty(self: *const T, Name: ?BSTR, fExists: ?*i16, ppProp: ?*?*ISharedProperty) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedPropertyGroup.VTable, @ptrCast(self.vtable)).CreateProperty(@as(*const ISharedPropertyGroup, @ptrCast(self)), Name, fExists, ppProp);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedPropertyGroup_get_Property(self: *const T, Name: ?BSTR, ppProperty: ?*?*ISharedProperty) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedPropertyGroup.VTable, @ptrCast(self.vtable)).get_Property(@as(*const ISharedPropertyGroup, @ptrCast(self)), Name, ppProperty);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISharedPropertyGroupManager_Value = Guid.initString("2a005c0d-a5de-11cf-9e66-00aa00a3f464");
|
|
pub const IID_ISharedPropertyGroupManager = &IID_ISharedPropertyGroupManager_Value;
|
|
pub const ISharedPropertyGroupManager = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
CreatePropertyGroup: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISharedPropertyGroupManager,
|
|
Name: ?BSTR,
|
|
dwIsoMode: ?*i32,
|
|
dwRelMode: ?*i32,
|
|
fExists: ?*i16,
|
|
ppGroup: ?*?*ISharedPropertyGroup,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISharedPropertyGroupManager,
|
|
Name: ?BSTR,
|
|
dwIsoMode: ?*i32,
|
|
dwRelMode: ?*i32,
|
|
fExists: ?*i16,
|
|
ppGroup: ?*?*ISharedPropertyGroup,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Group: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISharedPropertyGroupManager,
|
|
Name: ?BSTR,
|
|
ppGroup: ?*?*ISharedPropertyGroup,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISharedPropertyGroupManager,
|
|
Name: ?BSTR,
|
|
ppGroup: ?*?*ISharedPropertyGroup,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get__NewEnum: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ISharedPropertyGroupManager,
|
|
retval: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ISharedPropertyGroupManager,
|
|
retval: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedPropertyGroupManager_CreatePropertyGroup(self: *const T, Name: ?BSTR, dwIsoMode: ?*i32, dwRelMode: ?*i32, fExists: ?*i16, ppGroup: ?*?*ISharedPropertyGroup) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedPropertyGroupManager.VTable, @ptrCast(self.vtable)).CreatePropertyGroup(@as(*const ISharedPropertyGroupManager, @ptrCast(self)), Name, dwIsoMode, dwRelMode, fExists, ppGroup);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedPropertyGroupManager_get_Group(self: *const T, Name: ?BSTR, ppGroup: ?*?*ISharedPropertyGroup) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedPropertyGroupManager.VTable, @ptrCast(self.vtable)).get_Group(@as(*const ISharedPropertyGroupManager, @ptrCast(self)), Name, ppGroup);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISharedPropertyGroupManager_get__NewEnum(self: *const T, retval: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ISharedPropertyGroupManager.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ISharedPropertyGroupManager, @ptrCast(self)), retval);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IObjectConstruct_Value = Guid.initString("41c4f8b3-7439-11d2-98cb-00c04f8ee1c4");
|
|
pub const IID_IObjectConstruct = &IID_IObjectConstruct_Value;
|
|
pub const IObjectConstruct = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Construct: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectConstruct,
|
|
pCtorObj: ?*IDispatch,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectConstruct,
|
|
pCtorObj: ?*IDispatch,
|
|
) 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 IObjectConstruct_Construct(self: *const T, pCtorObj: ?*IDispatch) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectConstruct.VTable, @ptrCast(self.vtable)).Construct(@as(*const IObjectConstruct, @ptrCast(self)), pCtorObj);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IObjectConstructString_Value = Guid.initString("41c4f8b2-7439-11d2-98cb-00c04f8ee1c4");
|
|
pub const IID_IObjectConstructString = &IID_IObjectConstructString_Value;
|
|
pub const IObjectConstructString = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_ConstructString: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IObjectConstructString,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IObjectConstructString,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectConstructString_get_ConstructString(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectConstructString.VTable, @ptrCast(self.vtable)).get_ConstructString(@as(*const IObjectConstructString, @ptrCast(self)), pVal);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IObjectContextActivity_Value = Guid.initString("51372afc-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IObjectContextActivity = &IID_IObjectContextActivity_Value;
|
|
pub const IObjectContextActivity = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetActivityId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextActivity,
|
|
pGUID: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextActivity,
|
|
pGUID: ?*Guid,
|
|
) 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 IObjectContextActivity_GetActivityId(self: *const T, pGUID: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextActivity.VTable, @ptrCast(self.vtable)).GetActivityId(@as(*const IObjectContextActivity, @ptrCast(self)), pGUID);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IObjectContextInfo_Value = Guid.initString("75b52ddb-e8ed-11d1-93ad-00aa00ba3258");
|
|
pub const IID_IObjectContextInfo = &IID_IObjectContextInfo_Value;
|
|
pub const IObjectContextInfo = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
IsInTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) BOOL,
|
|
else => *const fn(
|
|
self: *const IObjectContextInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) BOOL,
|
|
},
|
|
GetTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextInfo,
|
|
pptrans: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextInfo,
|
|
pptrans: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTransactionId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextInfo,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextInfo,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetActivityId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextInfo,
|
|
pGUID: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextInfo,
|
|
pGUID: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetContextId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextInfo,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextInfo,
|
|
pGuid: ?*Guid,
|
|
) 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 IObjectContextInfo_IsInTransaction(self: *const T) callconv(.Inline) BOOL {
|
|
return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).IsInTransaction(@as(*const IObjectContextInfo, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContextInfo_GetTransaction(self: *const T, pptrans: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).GetTransaction(@as(*const IObjectContextInfo, @ptrCast(self)), pptrans);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContextInfo_GetTransactionId(self: *const T, pGuid: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).GetTransactionId(@as(*const IObjectContextInfo, @ptrCast(self)), pGuid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContextInfo_GetActivityId(self: *const T, pGUID: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).GetActivityId(@as(*const IObjectContextInfo, @ptrCast(self)), pGUID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContextInfo_GetContextId(self: *const T, pGuid: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextInfo.VTable, @ptrCast(self.vtable)).GetContextId(@as(*const IObjectContextInfo, @ptrCast(self)), pGuid);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IObjectContextInfo2_Value = Guid.initString("594be71a-4bc4-438b-9197-cfd176248b09");
|
|
pub const IID_IObjectContextInfo2 = &IID_IObjectContextInfo2_Value;
|
|
pub const IObjectContextInfo2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IObjectContextInfo.VTable,
|
|
GetPartitionId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextInfo2,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextInfo2,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetApplicationId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextInfo2,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextInfo2,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetApplicationInstanceId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextInfo2,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextInfo2,
|
|
pGuid: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IObjectContextInfo.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContextInfo2_GetPartitionId(self: *const T, pGuid: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextInfo2.VTable, @ptrCast(self.vtable)).GetPartitionId(@as(*const IObjectContextInfo2, @ptrCast(self)), pGuid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContextInfo2_GetApplicationId(self: *const T, pGuid: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextInfo2.VTable, @ptrCast(self.vtable)).GetApplicationId(@as(*const IObjectContextInfo2, @ptrCast(self)), pGuid);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjectContextInfo2_GetApplicationInstanceId(self: *const T, pGuid: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextInfo2.VTable, @ptrCast(self.vtable)).GetApplicationInstanceId(@as(*const IObjectContextInfo2, @ptrCast(self)), pGuid);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_ITransactionStatus_Value = Guid.initString("61f589e8-3724-4898-a0a4-664ae9e1d1b4");
|
|
pub const IID_ITransactionStatus = &IID_ITransactionStatus_Value;
|
|
pub const ITransactionStatus = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SetTransactionStatus: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionStatus,
|
|
hrStatus: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionStatus,
|
|
hrStatus: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetTransactionStatus: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionStatus,
|
|
pHrStatus: ?*HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionStatus,
|
|
pHrStatus: ?*HRESULT,
|
|
) 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 ITransactionStatus_SetTransactionStatus(self: *const T, hrStatus: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionStatus.VTable, @ptrCast(self.vtable)).SetTransactionStatus(@as(*const ITransactionStatus, @ptrCast(self)), hrStatus);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionStatus_GetTransactionStatus(self: *const T, pHrStatus: ?*HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionStatus.VTable, @ptrCast(self.vtable)).GetTransactionStatus(@as(*const ITransactionStatus, @ptrCast(self)), pHrStatus);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IObjectContextTip_Value = Guid.initString("92fd41ca-bad9-11d2-9a2d-00c04f797bc9");
|
|
pub const IID_IObjectContextTip = &IID_IObjectContextTip_Value;
|
|
pub const IObjectContextTip = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetTipUrl: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjectContextTip,
|
|
pTipUrl: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IObjectContextTip,
|
|
pTipUrl: ?*?BSTR,
|
|
) 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 IObjectContextTip_GetTipUrl(self: *const T, pTipUrl: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IObjectContextTip.VTable, @ptrCast(self.vtable)).GetTipUrl(@as(*const IObjectContextTip, @ptrCast(self)), pTipUrl);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IPlaybackControl_Value = Guid.initString("51372afd-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IPlaybackControl = &IID_IPlaybackControl_Value;
|
|
pub const IPlaybackControl = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
FinalClientRetry: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IPlaybackControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IPlaybackControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
FinalServerRetry: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IPlaybackControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IPlaybackControl,
|
|
) 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 IPlaybackControl_FinalClientRetry(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IPlaybackControl.VTable, @ptrCast(self.vtable)).FinalClientRetry(@as(*const IPlaybackControl, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IPlaybackControl_FinalServerRetry(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IPlaybackControl.VTable, @ptrCast(self.vtable)).FinalServerRetry(@as(*const IPlaybackControl, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IGetContextProperties_Value = Guid.initString("51372af4-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IGetContextProperties = &IID_IGetContextProperties_Value;
|
|
pub const IGetContextProperties = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Count: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetContextProperties,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetContextProperties,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetProperty: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetContextProperties,
|
|
name: ?BSTR,
|
|
pProperty: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetContextProperties,
|
|
name: ?BSTR,
|
|
pProperty: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnumNames: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IGetContextProperties,
|
|
ppenum: ?*?*IEnumNames,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IGetContextProperties,
|
|
ppenum: ?*?*IEnumNames,
|
|
) 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 IGetContextProperties_Count(self: *const T, plCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetContextProperties.VTable, @ptrCast(self.vtable)).Count(@as(*const IGetContextProperties, @ptrCast(self)), plCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetContextProperties_GetProperty(self: *const T, name: ?BSTR, pProperty: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetContextProperties.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IGetContextProperties, @ptrCast(self)), name, pProperty);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IGetContextProperties_EnumNames(self: *const T, ppenum: ?*?*IEnumNames) callconv(.Inline) HRESULT {
|
|
return @as(*const IGetContextProperties.VTable, @ptrCast(self.vtable)).EnumNames(@as(*const IGetContextProperties, @ptrCast(self)), ppenum);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const TransactionVote = enum(i32) {
|
|
Commit = 0,
|
|
Abort = 1,
|
|
};
|
|
pub const TxCommit = TransactionVote.Commit;
|
|
pub const TxAbort = TransactionVote.Abort;
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IContextState_Value = Guid.initString("3c05e54b-a42a-11d2-afc4-00c04f8ee1c4");
|
|
pub const IID_IContextState = &IID_IContextState_Value;
|
|
pub const IContextState = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SetDeactivateOnReturn: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextState,
|
|
bDeactivate: i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextState,
|
|
bDeactivate: i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetDeactivateOnReturn: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextState,
|
|
pbDeactivate: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextState,
|
|
pbDeactivate: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetMyTransactionVote: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextState,
|
|
txVote: TransactionVote,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextState,
|
|
txVote: TransactionVote,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetMyTransactionVote: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextState,
|
|
ptxVote: ?*TransactionVote,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextState,
|
|
ptxVote: ?*TransactionVote,
|
|
) 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 IContextState_SetDeactivateOnReturn(self: *const T, bDeactivate: i16) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextState.VTable, @ptrCast(self.vtable)).SetDeactivateOnReturn(@as(*const IContextState, @ptrCast(self)), bDeactivate);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContextState_GetDeactivateOnReturn(self: *const T, pbDeactivate: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextState.VTable, @ptrCast(self.vtable)).GetDeactivateOnReturn(@as(*const IContextState, @ptrCast(self)), pbDeactivate);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContextState_SetMyTransactionVote(self: *const T, txVote: TransactionVote) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextState.VTable, @ptrCast(self.vtable)).SetMyTransactionVote(@as(*const IContextState, @ptrCast(self)), txVote);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContextState_GetMyTransactionVote(self: *const T, ptxVote: ?*TransactionVote) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextState.VTable, @ptrCast(self.vtable)).GetMyTransactionVote(@as(*const IContextState, @ptrCast(self)), ptxVote);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IPoolManager_Value = Guid.initString("0a469861-5a91-43a0-99b6-d5e179bb0631");
|
|
pub const IID_IPoolManager = &IID_IPoolManager_Value;
|
|
pub const IPoolManager = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
ShutdownPool: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IPoolManager,
|
|
CLSIDOrProgID: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IPoolManager,
|
|
CLSIDOrProgID: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IPoolManager_ShutdownPool(self: *const T, CLSIDOrProgID: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IPoolManager.VTable, @ptrCast(self.vtable)).ShutdownPool(@as(*const IPoolManager, @ptrCast(self)), CLSIDOrProgID);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISelectCOMLBServer_Value = Guid.initString("dcf443f4-3f8a-4872-b9f0-369a796d12d6");
|
|
pub const IID_ISelectCOMLBServer = &IID_ISelectCOMLBServer_Value;
|
|
pub const ISelectCOMLBServer = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Init: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISelectCOMLBServer,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISelectCOMLBServer,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetLBServer: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISelectCOMLBServer,
|
|
pUnk: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISelectCOMLBServer,
|
|
pUnk: ?*IUnknown,
|
|
) 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 ISelectCOMLBServer_Init(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ISelectCOMLBServer.VTable, @ptrCast(self.vtable)).Init(@as(*const ISelectCOMLBServer, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISelectCOMLBServer_GetLBServer(self: *const T, pUnk: ?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ISelectCOMLBServer.VTable, @ptrCast(self.vtable)).GetLBServer(@as(*const ISelectCOMLBServer, @ptrCast(self)), pUnk);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICOMLBArguments_Value = Guid.initString("3a0f150f-8ee5-4b94-b40e-aef2f9e42ed2");
|
|
pub const IID_ICOMLBArguments = &IID_ICOMLBArguments_Value;
|
|
pub const ICOMLBArguments = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetCLSID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMLBArguments,
|
|
pCLSID: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMLBArguments,
|
|
pCLSID: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetCLSID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMLBArguments,
|
|
pCLSID: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMLBArguments,
|
|
pCLSID: ?*Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetMachineName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMLBArguments,
|
|
cchSvr: u32,
|
|
szServerName: [*:0]u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMLBArguments,
|
|
cchSvr: u32,
|
|
szServerName: [*:0]u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetMachineName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICOMLBArguments,
|
|
cchSvr: u32,
|
|
szServerName: [*:0]u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICOMLBArguments,
|
|
cchSvr: u32,
|
|
szServerName: [*:0]u16,
|
|
) 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 ICOMLBArguments_GetCLSID(self: *const T, pCLSID: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMLBArguments.VTable, @ptrCast(self.vtable)).GetCLSID(@as(*const ICOMLBArguments, @ptrCast(self)), pCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMLBArguments_SetCLSID(self: *const T, pCLSID: ?*Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMLBArguments.VTable, @ptrCast(self.vtable)).SetCLSID(@as(*const ICOMLBArguments, @ptrCast(self)), pCLSID);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMLBArguments_GetMachineName(self: *const T, cchSvr: u32, szServerName: [*:0]u16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMLBArguments.VTable, @ptrCast(self.vtable)).GetMachineName(@as(*const ICOMLBArguments, @ptrCast(self)), cchSvr, szServerName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICOMLBArguments_SetMachineName(self: *const T, cchSvr: u32, szServerName: [*:0]u16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICOMLBArguments.VTable, @ptrCast(self.vtable)).SetMachineName(@as(*const ICOMLBArguments, @ptrCast(self)), cchSvr, szServerName);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICrmLogControl_Value = Guid.initString("a0e174b3-d26e-11d2-8f84-00805fc7bcd9");
|
|
pub const IID_ICrmLogControl = &IID_ICrmLogControl_Value;
|
|
pub const ICrmLogControl = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_TransactionUOW: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICrmLogControl,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICrmLogControl,
|
|
pVal: ?*?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RegisterCompensator: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmLogControl,
|
|
lpcwstrProgIdCompensator: ?[*:0]const u16,
|
|
lpcwstrDescription: ?[*:0]const u16,
|
|
lCrmRegFlags: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmLogControl,
|
|
lpcwstrProgIdCompensator: ?[*:0]const u16,
|
|
lpcwstrDescription: ?[*:0]const u16,
|
|
lCrmRegFlags: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
WriteLogRecordVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmLogControl,
|
|
pLogRecord: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmLogControl,
|
|
pLogRecord: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ForceLog: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ForgetLogRecord: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ForceTransactionToAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
WriteLogRecord: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmLogControl,
|
|
rgBlob: [*]BLOB,
|
|
cBlob: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmLogControl,
|
|
rgBlob: [*]BLOB,
|
|
cBlob: u32,
|
|
) 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 ICrmLogControl_get_TransactionUOW(self: *const T, pVal: ?*?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).get_TransactionUOW(@as(*const ICrmLogControl, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmLogControl_RegisterCompensator(self: *const T, lpcwstrProgIdCompensator: ?[*:0]const u16, lpcwstrDescription: ?[*:0]const u16, lCrmRegFlags: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).RegisterCompensator(@as(*const ICrmLogControl, @ptrCast(self)), lpcwstrProgIdCompensator, lpcwstrDescription, lCrmRegFlags);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmLogControl_WriteLogRecordVariants(self: *const T, pLogRecord: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).WriteLogRecordVariants(@as(*const ICrmLogControl, @ptrCast(self)), pLogRecord);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmLogControl_ForceLog(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).ForceLog(@as(*const ICrmLogControl, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmLogControl_ForgetLogRecord(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).ForgetLogRecord(@as(*const ICrmLogControl, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmLogControl_ForceTransactionToAbort(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).ForceTransactionToAbort(@as(*const ICrmLogControl, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmLogControl_WriteLogRecord(self: *const T, rgBlob: [*]BLOB, cBlob: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmLogControl.VTable, @ptrCast(self.vtable)).WriteLogRecord(@as(*const ICrmLogControl, @ptrCast(self)), rgBlob, cBlob);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICrmCompensatorVariants_Value = Guid.initString("f0baf8e4-7804-11d1-82e9-00a0c91eede9");
|
|
pub const IID_ICrmCompensatorVariants = &IID_ICrmCompensatorVariants_Value;
|
|
pub const ICrmCompensatorVariants = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SetLogControlVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pLogControl: ?*ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pLogControl: ?*ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BeginPrepareVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PrepareRecordVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pLogRecord: ?*VARIANT,
|
|
pbForget: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pLogRecord: ?*VARIANT,
|
|
pbForget: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EndPrepareVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pbOkToPrepare: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pbOkToPrepare: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BeginCommitVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
bRecovery: i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
bRecovery: i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CommitRecordVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pLogRecord: ?*VARIANT,
|
|
pbForget: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pLogRecord: ?*VARIANT,
|
|
pbForget: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EndCommitVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BeginAbortVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
bRecovery: i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
bRecovery: i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AbortRecordVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pLogRecord: ?*VARIANT,
|
|
pbForget: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
pLogRecord: ?*VARIANT,
|
|
pbForget: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EndAbortVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensatorVariants,
|
|
) 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 ICrmCompensatorVariants_SetLogControlVariants(self: *const T, pLogControl: ?*ICrmLogControl) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).SetLogControlVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pLogControl);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_BeginPrepareVariants(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).BeginPrepareVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_PrepareRecordVariants(self: *const T, pLogRecord: ?*VARIANT, pbForget: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).PrepareRecordVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pLogRecord, pbForget);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_EndPrepareVariants(self: *const T, pbOkToPrepare: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).EndPrepareVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pbOkToPrepare);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_BeginCommitVariants(self: *const T, bRecovery: i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).BeginCommitVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), bRecovery);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_CommitRecordVariants(self: *const T, pLogRecord: ?*VARIANT, pbForget: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).CommitRecordVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pLogRecord, pbForget);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_EndCommitVariants(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).EndCommitVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_BeginAbortVariants(self: *const T, bRecovery: i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).BeginAbortVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), bRecovery);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_AbortRecordVariants(self: *const T, pLogRecord: ?*VARIANT, pbForget: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).AbortRecordVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)), pLogRecord, pbForget);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensatorVariants_EndAbortVariants(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensatorVariants.VTable, @ptrCast(self.vtable)).EndAbortVariants(@as(*const ICrmCompensatorVariants, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const CrmLogRecordRead = extern struct {
|
|
dwCrmFlags: u32,
|
|
dwSequenceNumber: u32,
|
|
blobUserData: BLOB,
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICrmCompensator_Value = Guid.initString("bbc01830-8d3b-11d1-82ec-00a0c91eede9");
|
|
pub const IID_ICrmCompensator = &IID_ICrmCompensator_Value;
|
|
pub const ICrmCompensator = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SetLogControl: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
pLogControl: ?*ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
pLogControl: ?*ICrmLogControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BeginPrepare: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PrepareRecord: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
crmLogRec: CrmLogRecordRead,
|
|
pfForget: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
crmLogRec: CrmLogRecordRead,
|
|
pfForget: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EndPrepare: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
pfOkToPrepare: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
pfOkToPrepare: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BeginCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
fRecovery: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
fRecovery: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
CommitRecord: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
crmLogRec: CrmLogRecordRead,
|
|
pfForget: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
crmLogRec: CrmLogRecordRead,
|
|
pfForget: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EndCommit: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BeginAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
fRecovery: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
fRecovery: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AbortRecord: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
crmLogRec: CrmLogRecordRead,
|
|
pfForget: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
crmLogRec: CrmLogRecordRead,
|
|
pfForget: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EndAbort: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmCompensator,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmCompensator,
|
|
) 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 ICrmCompensator_SetLogControl(self: *const T, pLogControl: ?*ICrmLogControl) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).SetLogControl(@as(*const ICrmCompensator, @ptrCast(self)), pLogControl);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_BeginPrepare(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).BeginPrepare(@as(*const ICrmCompensator, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_PrepareRecord(self: *const T, crmLogRec: CrmLogRecordRead, pfForget: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).PrepareRecord(@as(*const ICrmCompensator, @ptrCast(self)), crmLogRec, pfForget);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_EndPrepare(self: *const T, pfOkToPrepare: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).EndPrepare(@as(*const ICrmCompensator, @ptrCast(self)), pfOkToPrepare);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_BeginCommit(self: *const T, fRecovery: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).BeginCommit(@as(*const ICrmCompensator, @ptrCast(self)), fRecovery);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_CommitRecord(self: *const T, crmLogRec: CrmLogRecordRead, pfForget: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).CommitRecord(@as(*const ICrmCompensator, @ptrCast(self)), crmLogRec, pfForget);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_EndCommit(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).EndCommit(@as(*const ICrmCompensator, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_BeginAbort(self: *const T, fRecovery: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).BeginAbort(@as(*const ICrmCompensator, @ptrCast(self)), fRecovery);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_AbortRecord(self: *const T, crmLogRec: CrmLogRecordRead, pfForget: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).AbortRecord(@as(*const ICrmCompensator, @ptrCast(self)), crmLogRec, pfForget);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmCompensator_EndAbort(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmCompensator.VTable, @ptrCast(self.vtable)).EndAbort(@as(*const ICrmCompensator, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const CrmTransactionState = enum(i32) {
|
|
Active = 0,
|
|
Committed = 1,
|
|
Aborted = 2,
|
|
Indoubt = 3,
|
|
};
|
|
pub const TxState_Active = CrmTransactionState.Active;
|
|
pub const TxState_Committed = CrmTransactionState.Committed;
|
|
pub const TxState_Aborted = CrmTransactionState.Aborted;
|
|
pub const TxState_Indoubt = CrmTransactionState.Indoubt;
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICrmMonitorLogRecords_Value = Guid.initString("70c8e441-c7ed-11d1-82fb-00a0c91eede9");
|
|
pub const IID_ICrmMonitorLogRecords = &IID_ICrmMonitorLogRecords_Value;
|
|
pub const ICrmMonitorLogRecords = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
pVal: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
pVal: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_TransactionState: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
pVal: ?*CrmTransactionState,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
pVal: ?*CrmTransactionState,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_StructuredRecords: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
pVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
pVal: ?*i16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetLogRecord: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
dwIndex: u32,
|
|
pCrmLogRec: ?*CrmLogRecordRead,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
dwIndex: u32,
|
|
pCrmLogRec: ?*CrmLogRecordRead,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetLogRecordVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
IndexNumber: VARIANT,
|
|
pLogRecord: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitorLogRecords,
|
|
IndexNumber: VARIANT,
|
|
pLogRecord: ?*VARIANT,
|
|
) 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 ICrmMonitorLogRecords_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorLogRecords_get_TransactionState(self: *const T, pVal: ?*CrmTransactionState) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).get_TransactionState(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorLogRecords_get_StructuredRecords(self: *const T, pVal: ?*i16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).get_StructuredRecords(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorLogRecords_GetLogRecord(self: *const T, dwIndex: u32, pCrmLogRec: ?*CrmLogRecordRead) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).GetLogRecord(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), dwIndex, pCrmLogRec);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorLogRecords_GetLogRecordVariants(self: *const T, IndexNumber: VARIANT, pLogRecord: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorLogRecords.VTable, @ptrCast(self.vtable)).GetLogRecordVariants(@as(*const ICrmMonitorLogRecords, @ptrCast(self)), IndexNumber, pLogRecord);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICrmMonitorClerks_Value = Guid.initString("70c8e442-c7ed-11d1-82fb-00a0c91eede9");
|
|
pub const IID_ICrmMonitorClerks = &IID_ICrmMonitorClerks_Value;
|
|
pub const ICrmMonitorClerks = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
Item: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get__NewEnum: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorClerks,
|
|
pVal: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICrmMonitorClerks,
|
|
pVal: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_Count: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorClerks,
|
|
pVal: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const ICrmMonitorClerks,
|
|
pVal: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ProgIdCompensator: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Description: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TransactionUOW: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
ActivityId: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitorClerks,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorClerks_Item(self: *const T, Index: VARIANT, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).Item(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorClerks_get__NewEnum(self: *const T, pVal: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).get__NewEnum(@as(*const ICrmMonitorClerks, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorClerks_get_Count(self: *const T, pVal: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).get_Count(@as(*const ICrmMonitorClerks, @ptrCast(self)), pVal);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorClerks_ProgIdCompensator(self: *const T, Index: VARIANT, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).ProgIdCompensator(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorClerks_Description(self: *const T, Index: VARIANT, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).Description(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorClerks_TransactionUOW(self: *const T, Index: VARIANT, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).TransactionUOW(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitorClerks_ActivityId(self: *const T, Index: VARIANT, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitorClerks.VTable, @ptrCast(self.vtable)).ActivityId(@as(*const ICrmMonitorClerks, @ptrCast(self)), Index, pItem);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICrmMonitor_Value = Guid.initString("70c8e443-c7ed-11d1-82fb-00a0c91eede9");
|
|
pub const IID_ICrmMonitor = &IID_ICrmMonitor_Value;
|
|
pub const ICrmMonitor = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetClerks: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitor,
|
|
pClerks: ?*?*ICrmMonitorClerks,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitor,
|
|
pClerks: ?*?*ICrmMonitorClerks,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
HoldClerk: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmMonitor,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmMonitor,
|
|
Index: VARIANT,
|
|
pItem: ?*VARIANT,
|
|
) 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 ICrmMonitor_GetClerks(self: *const T, pClerks: ?*?*ICrmMonitorClerks) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitor.VTable, @ptrCast(self.vtable)).GetClerks(@as(*const ICrmMonitor, @ptrCast(self)), pClerks);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmMonitor_HoldClerk(self: *const T, Index: VARIANT, pItem: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmMonitor.VTable, @ptrCast(self.vtable)).HoldClerk(@as(*const ICrmMonitor, @ptrCast(self)), Index, pItem);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ICrmFormatLogRecords_Value = Guid.initString("9c51d821-c98b-11d1-82fb-00a0c91eede9");
|
|
pub const IID_ICrmFormatLogRecords = &IID_ICrmFormatLogRecords_Value;
|
|
pub const ICrmFormatLogRecords = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetColumnCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmFormatLogRecords,
|
|
plColumnCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmFormatLogRecords,
|
|
plColumnCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetColumnHeaders: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmFormatLogRecords,
|
|
pHeaders: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmFormatLogRecords,
|
|
pHeaders: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetColumn: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmFormatLogRecords,
|
|
CrmLogRec: CrmLogRecordRead,
|
|
pFormattedLogRecord: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmFormatLogRecords,
|
|
CrmLogRec: CrmLogRecordRead,
|
|
pFormattedLogRecord: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetColumnVariants: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICrmFormatLogRecords,
|
|
LogRecord: VARIANT,
|
|
pFormattedLogRecord: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICrmFormatLogRecords,
|
|
LogRecord: VARIANT,
|
|
pFormattedLogRecord: ?*VARIANT,
|
|
) 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 ICrmFormatLogRecords_GetColumnCount(self: *const T, plColumnCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmFormatLogRecords.VTable, @ptrCast(self.vtable)).GetColumnCount(@as(*const ICrmFormatLogRecords, @ptrCast(self)), plColumnCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmFormatLogRecords_GetColumnHeaders(self: *const T, pHeaders: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmFormatLogRecords.VTable, @ptrCast(self.vtable)).GetColumnHeaders(@as(*const ICrmFormatLogRecords, @ptrCast(self)), pHeaders);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmFormatLogRecords_GetColumn(self: *const T, CrmLogRec: CrmLogRecordRead, pFormattedLogRecord: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmFormatLogRecords.VTable, @ptrCast(self.vtable)).GetColumn(@as(*const ICrmFormatLogRecords, @ptrCast(self)), CrmLogRec, pFormattedLogRecord);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ICrmFormatLogRecords_GetColumnVariants(self: *const T, LogRecord: VARIANT, pFormattedLogRecord: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const ICrmFormatLogRecords.VTable, @ptrCast(self.vtable)).GetColumnVariants(@as(*const ICrmFormatLogRecords, @ptrCast(self)), LogRecord, pFormattedLogRecord);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const CSC_InheritanceConfig = enum(i32) {
|
|
nherit = 0,
|
|
gnore = 1,
|
|
};
|
|
pub const CSC_Inherit = CSC_InheritanceConfig.nherit;
|
|
pub const CSC_Ignore = CSC_InheritanceConfig.gnore;
|
|
|
|
pub const CSC_ThreadPool = enum(i32) {
|
|
ThreadPoolNone = 0,
|
|
ThreadPoolInherit = 1,
|
|
STAThreadPool = 2,
|
|
MTAThreadPool = 3,
|
|
};
|
|
pub const CSC_ThreadPoolNone = CSC_ThreadPool.ThreadPoolNone;
|
|
pub const CSC_ThreadPoolInherit = CSC_ThreadPool.ThreadPoolInherit;
|
|
pub const CSC_STAThreadPool = CSC_ThreadPool.STAThreadPool;
|
|
pub const CSC_MTAThreadPool = CSC_ThreadPool.MTAThreadPool;
|
|
|
|
pub const CSC_Binding = enum(i32) {
|
|
NoBinding = 0,
|
|
BindToPoolThread = 1,
|
|
};
|
|
pub const CSC_NoBinding = CSC_Binding.NoBinding;
|
|
pub const CSC_BindToPoolThread = CSC_Binding.BindToPoolThread;
|
|
|
|
pub const CSC_TransactionConfig = enum(i32) {
|
|
NoTransaction = 0,
|
|
IfContainerIsTransactional = 1,
|
|
CreateTransactionIfNecessary = 2,
|
|
NewTransaction = 3,
|
|
};
|
|
pub const CSC_NoTransaction = CSC_TransactionConfig.NoTransaction;
|
|
pub const CSC_IfContainerIsTransactional = CSC_TransactionConfig.IfContainerIsTransactional;
|
|
pub const CSC_CreateTransactionIfNecessary = CSC_TransactionConfig.CreateTransactionIfNecessary;
|
|
pub const CSC_NewTransaction = CSC_TransactionConfig.NewTransaction;
|
|
|
|
pub const CSC_SynchronizationConfig = enum(i32) {
|
|
NoSynchronization = 0,
|
|
IfContainerIsSynchronized = 1,
|
|
NewSynchronizationIfNecessary = 2,
|
|
NewSynchronization = 3,
|
|
};
|
|
pub const CSC_NoSynchronization = CSC_SynchronizationConfig.NoSynchronization;
|
|
pub const CSC_IfContainerIsSynchronized = CSC_SynchronizationConfig.IfContainerIsSynchronized;
|
|
pub const CSC_NewSynchronizationIfNecessary = CSC_SynchronizationConfig.NewSynchronizationIfNecessary;
|
|
pub const CSC_NewSynchronization = CSC_SynchronizationConfig.NewSynchronization;
|
|
|
|
pub const CSC_TrackerConfig = enum(i32) {
|
|
DontUseTracker = 0,
|
|
UseTracker = 1,
|
|
};
|
|
pub const CSC_DontUseTracker = CSC_TrackerConfig.DontUseTracker;
|
|
pub const CSC_UseTracker = CSC_TrackerConfig.UseTracker;
|
|
|
|
pub const CSC_PartitionConfig = enum(i32) {
|
|
NoPartition = 0,
|
|
InheritPartition = 1,
|
|
NewPartition = 2,
|
|
};
|
|
pub const CSC_NoPartition = CSC_PartitionConfig.NoPartition;
|
|
pub const CSC_InheritPartition = CSC_PartitionConfig.InheritPartition;
|
|
pub const CSC_NewPartition = CSC_PartitionConfig.NewPartition;
|
|
|
|
pub const CSC_IISIntrinsicsConfig = enum(i32) {
|
|
NoIISIntrinsics = 0,
|
|
InheritIISIntrinsics = 1,
|
|
};
|
|
pub const CSC_NoIISIntrinsics = CSC_IISIntrinsicsConfig.NoIISIntrinsics;
|
|
pub const CSC_InheritIISIntrinsics = CSC_IISIntrinsicsConfig.InheritIISIntrinsics;
|
|
|
|
pub const CSC_COMTIIntrinsicsConfig = enum(i32) {
|
|
NoCOMTIIntrinsics = 0,
|
|
InheritCOMTIIntrinsics = 1,
|
|
};
|
|
pub const CSC_NoCOMTIIntrinsics = CSC_COMTIIntrinsicsConfig.NoCOMTIIntrinsics;
|
|
pub const CSC_InheritCOMTIIntrinsics = CSC_COMTIIntrinsicsConfig.InheritCOMTIIntrinsics;
|
|
|
|
pub const CSC_SxsConfig = enum(i32) {
|
|
NoSxs = 0,
|
|
InheritSxs = 1,
|
|
NewSxs = 2,
|
|
};
|
|
pub const CSC_NoSxs = CSC_SxsConfig.NoSxs;
|
|
pub const CSC_InheritSxs = CSC_SxsConfig.InheritSxs;
|
|
pub const CSC_NewSxs = CSC_SxsConfig.NewSxs;
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceIISIntrinsicsConfig_Value = Guid.initString("1a0cf920-d452-46f4-bc36-48118d54ea52");
|
|
pub const IID_IServiceIISIntrinsicsConfig = &IID_IServiceIISIntrinsicsConfig_Value;
|
|
pub const IServiceIISIntrinsicsConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
IISIntrinsicsConfig: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceIISIntrinsicsConfig,
|
|
iisIntrinsicsConfig: CSC_IISIntrinsicsConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceIISIntrinsicsConfig,
|
|
iisIntrinsicsConfig: CSC_IISIntrinsicsConfig,
|
|
) 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 IServiceIISIntrinsicsConfig_IISIntrinsicsConfig(self: *const T, iisIntrinsicsConfig: CSC_IISIntrinsicsConfig) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceIISIntrinsicsConfig.VTable, @ptrCast(self.vtable)).IISIntrinsicsConfig(@as(*const IServiceIISIntrinsicsConfig, @ptrCast(self)), iisIntrinsicsConfig);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceComTIIntrinsicsConfig_Value = Guid.initString("09e6831e-04e1-4ed4-9d0f-e8b168bafeaf");
|
|
pub const IID_IServiceComTIIntrinsicsConfig = &IID_IServiceComTIIntrinsicsConfig_Value;
|
|
pub const IServiceComTIIntrinsicsConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
ComTIIntrinsicsConfig: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceComTIIntrinsicsConfig,
|
|
comtiIntrinsicsConfig: CSC_COMTIIntrinsicsConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceComTIIntrinsicsConfig,
|
|
comtiIntrinsicsConfig: CSC_COMTIIntrinsicsConfig,
|
|
) 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 IServiceComTIIntrinsicsConfig_ComTIIntrinsicsConfig(self: *const T, comtiIntrinsicsConfig: CSC_COMTIIntrinsicsConfig) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceComTIIntrinsicsConfig.VTable, @ptrCast(self.vtable)).ComTIIntrinsicsConfig(@as(*const IServiceComTIIntrinsicsConfig, @ptrCast(self)), comtiIntrinsicsConfig);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceSxsConfig_Value = Guid.initString("c7cd7379-f3f2-4634-811b-703281d73e08");
|
|
pub const IID_IServiceSxsConfig = &IID_IServiceSxsConfig_Value;
|
|
pub const IServiceSxsConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SxsConfig: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceSxsConfig,
|
|
scsConfig: CSC_SxsConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceSxsConfig,
|
|
scsConfig: CSC_SxsConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SxsName: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceSxsConfig,
|
|
szSxsName: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceSxsConfig,
|
|
szSxsName: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SxsDirectory: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceSxsConfig,
|
|
szSxsDirectory: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceSxsConfig,
|
|
szSxsDirectory: ?[*:0]const u16,
|
|
) 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 IServiceSxsConfig_SxsConfig(self: *const T, scsConfig: CSC_SxsConfig) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceSxsConfig.VTable, @ptrCast(self.vtable)).SxsConfig(@as(*const IServiceSxsConfig, @ptrCast(self)), scsConfig);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceSxsConfig_SxsName(self: *const T, szSxsName: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceSxsConfig.VTable, @ptrCast(self.vtable)).SxsName(@as(*const IServiceSxsConfig, @ptrCast(self)), szSxsName);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceSxsConfig_SxsDirectory(self: *const T, szSxsDirectory: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceSxsConfig.VTable, @ptrCast(self.vtable)).SxsDirectory(@as(*const IServiceSxsConfig, @ptrCast(self)), szSxsDirectory);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_ICheckSxsConfig_Value = Guid.initString("0ff5a96f-11fc-47d1-baa6-25dd347e7242");
|
|
pub const IID_ICheckSxsConfig = &IID_ICheckSxsConfig_Value;
|
|
pub const ICheckSxsConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
IsSameSxsConfig: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ICheckSxsConfig,
|
|
wszSxsName: ?[*:0]const u16,
|
|
wszSxsDirectory: ?[*:0]const u16,
|
|
wszSxsAppName: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ICheckSxsConfig,
|
|
wszSxsName: ?[*:0]const u16,
|
|
wszSxsDirectory: ?[*:0]const u16,
|
|
wszSxsAppName: ?[*:0]const u16,
|
|
) 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 ICheckSxsConfig_IsSameSxsConfig(self: *const T, wszSxsName: ?[*:0]const u16, wszSxsDirectory: ?[*:0]const u16, wszSxsAppName: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const ICheckSxsConfig.VTable, @ptrCast(self.vtable)).IsSameSxsConfig(@as(*const ICheckSxsConfig, @ptrCast(self)), wszSxsName, wszSxsDirectory, wszSxsAppName);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceInheritanceConfig_Value = Guid.initString("92186771-d3b4-4d77-a8ea-ee842d586f35");
|
|
pub const IID_IServiceInheritanceConfig = &IID_IServiceInheritanceConfig_Value;
|
|
pub const IServiceInheritanceConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
ContainingContextTreatment: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceInheritanceConfig,
|
|
inheritanceConfig: CSC_InheritanceConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceInheritanceConfig,
|
|
inheritanceConfig: CSC_InheritanceConfig,
|
|
) 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 IServiceInheritanceConfig_ContainingContextTreatment(self: *const T, inheritanceConfig: CSC_InheritanceConfig) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceInheritanceConfig.VTable, @ptrCast(self.vtable)).ContainingContextTreatment(@as(*const IServiceInheritanceConfig, @ptrCast(self)), inheritanceConfig);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceThreadPoolConfig_Value = Guid.initString("186d89bc-f277-4bcc-80d5-4df7b836ef4a");
|
|
pub const IID_IServiceThreadPoolConfig = &IID_IServiceThreadPoolConfig_Value;
|
|
pub const IServiceThreadPoolConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SelectThreadPool: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceThreadPoolConfig,
|
|
threadPool: CSC_ThreadPool,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceThreadPoolConfig,
|
|
threadPool: CSC_ThreadPool,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetBindingInfo: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceThreadPoolConfig,
|
|
binding: CSC_Binding,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceThreadPoolConfig,
|
|
binding: CSC_Binding,
|
|
) 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 IServiceThreadPoolConfig_SelectThreadPool(self: *const T, threadPool: CSC_ThreadPool) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceThreadPoolConfig.VTable, @ptrCast(self.vtable)).SelectThreadPool(@as(*const IServiceThreadPoolConfig, @ptrCast(self)), threadPool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceThreadPoolConfig_SetBindingInfo(self: *const T, binding: CSC_Binding) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceThreadPoolConfig.VTable, @ptrCast(self.vtable)).SetBindingInfo(@as(*const IServiceThreadPoolConfig, @ptrCast(self)), binding);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceTransactionConfigBase_Value = Guid.initString("772b3fbe-6ffd-42fb-b5f8-8f9b260f3810");
|
|
pub const IID_IServiceTransactionConfigBase = &IID_IServiceTransactionConfigBase_Value;
|
|
pub const IServiceTransactionConfigBase = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
ConfigureTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
transactionConfig: CSC_TransactionConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
transactionConfig: CSC_TransactionConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
IsolationLevel: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
option: COMAdminTxIsolationLevelOptions,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
option: COMAdminTxIsolationLevelOptions,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
TransactionTimeout: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
ulTimeoutSec: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
ulTimeoutSec: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BringYourOwnTransaction: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
szTipURL: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
szTipURL: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
NewTransactionDescription: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
szTxDesc: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceTransactionConfigBase,
|
|
szTxDesc: ?[*:0]const u16,
|
|
) 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 IServiceTransactionConfigBase_ConfigureTransaction(self: *const T, transactionConfig: CSC_TransactionConfig) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).ConfigureTransaction(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), transactionConfig);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceTransactionConfigBase_IsolationLevel(self: *const T, option: COMAdminTxIsolationLevelOptions) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).IsolationLevel(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), option);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceTransactionConfigBase_TransactionTimeout(self: *const T, ulTimeoutSec: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).TransactionTimeout(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), ulTimeoutSec);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceTransactionConfigBase_BringYourOwnTransaction(self: *const T, szTipURL: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).BringYourOwnTransaction(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), szTipURL);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceTransactionConfigBase_NewTransactionDescription(self: *const T, szTxDesc: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceTransactionConfigBase.VTable, @ptrCast(self.vtable)).NewTransactionDescription(@as(*const IServiceTransactionConfigBase, @ptrCast(self)), szTxDesc);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceTransactionConfig_Value = Guid.initString("59f4c2a3-d3d7-4a31-b6e4-6ab3177c50b9");
|
|
pub const IID_IServiceTransactionConfig = &IID_IServiceTransactionConfig_Value;
|
|
pub const IServiceTransactionConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IServiceTransactionConfigBase.VTable,
|
|
ConfigureBYOT: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceTransactionConfig,
|
|
pITxByot: ?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceTransactionConfig,
|
|
pITxByot: ?*ITransaction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IServiceTransactionConfigBase.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceTransactionConfig_ConfigureBYOT(self: *const T, pITxByot: ?*ITransaction) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceTransactionConfig.VTable, @ptrCast(self.vtable)).ConfigureBYOT(@as(*const IServiceTransactionConfig, @ptrCast(self)), pITxByot);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceSysTxnConfig_Value = Guid.initString("33caf1a1-fcb8-472b-b45e-967448ded6d8");
|
|
pub const IID_IServiceSysTxnConfig = &IID_IServiceSysTxnConfig_Value;
|
|
pub const IServiceSysTxnConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IServiceTransactionConfig.VTable,
|
|
ConfigureBYOTSysTxn: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceSysTxnConfig,
|
|
pTxProxy: ?*ITransactionProxy,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceSysTxnConfig,
|
|
pTxProxy: ?*ITransactionProxy,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IServiceTransactionConfig.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceSysTxnConfig_ConfigureBYOTSysTxn(self: *const T, pTxProxy: ?*ITransactionProxy) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceSysTxnConfig.VTable, @ptrCast(self.vtable)).ConfigureBYOTSysTxn(@as(*const IServiceSysTxnConfig, @ptrCast(self)), pTxProxy);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceSynchronizationConfig_Value = Guid.initString("fd880e81-6dce-4c58-af83-a208846c0030");
|
|
pub const IID_IServiceSynchronizationConfig = &IID_IServiceSynchronizationConfig_Value;
|
|
pub const IServiceSynchronizationConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
ConfigureSynchronization: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceSynchronizationConfig,
|
|
synchConfig: CSC_SynchronizationConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceSynchronizationConfig,
|
|
synchConfig: CSC_SynchronizationConfig,
|
|
) 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 IServiceSynchronizationConfig_ConfigureSynchronization(self: *const T, synchConfig: CSC_SynchronizationConfig) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceSynchronizationConfig.VTable, @ptrCast(self.vtable)).ConfigureSynchronization(@as(*const IServiceSynchronizationConfig, @ptrCast(self)), synchConfig);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceTrackerConfig_Value = Guid.initString("6c3a3e1d-0ba6-4036-b76f-d0404db816c9");
|
|
pub const IID_IServiceTrackerConfig = &IID_IServiceTrackerConfig_Value;
|
|
pub const IServiceTrackerConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
TrackerConfig: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceTrackerConfig,
|
|
trackerConfig: CSC_TrackerConfig,
|
|
szTrackerAppName: ?[*:0]const u16,
|
|
szTrackerCtxName: ?[*:0]const u16,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceTrackerConfig,
|
|
trackerConfig: CSC_TrackerConfig,
|
|
szTrackerAppName: ?[*:0]const u16,
|
|
szTrackerCtxName: ?[*:0]const u16,
|
|
) 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 IServiceTrackerConfig_TrackerConfig(self: *const T, trackerConfig: CSC_TrackerConfig, szTrackerAppName: ?[*:0]const u16, szTrackerCtxName: ?[*:0]const u16) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceTrackerConfig.VTable, @ptrCast(self.vtable)).TrackerConfig(@as(*const IServiceTrackerConfig, @ptrCast(self)), trackerConfig, szTrackerAppName, szTrackerCtxName);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServicePartitionConfig_Value = Guid.initString("80182d03-5ea4-4831-ae97-55beffc2e590");
|
|
pub const IID_IServicePartitionConfig = &IID_IServicePartitionConfig_Value;
|
|
pub const IServicePartitionConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
PartitionConfig: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServicePartitionConfig,
|
|
partitionConfig: CSC_PartitionConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServicePartitionConfig,
|
|
partitionConfig: CSC_PartitionConfig,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
PartitionID: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServicePartitionConfig,
|
|
guidPartitionID: ?*const Guid,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServicePartitionConfig,
|
|
guidPartitionID: ?*const Guid,
|
|
) 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 IServicePartitionConfig_PartitionConfig(self: *const T, partitionConfig: CSC_PartitionConfig) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePartitionConfig.VTable, @ptrCast(self.vtable)).PartitionConfig(@as(*const IServicePartitionConfig, @ptrCast(self)), partitionConfig);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePartitionConfig_PartitionID(self: *const T, guidPartitionID: ?*const Guid) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePartitionConfig.VTable, @ptrCast(self.vtable)).PartitionID(@as(*const IServicePartitionConfig, @ptrCast(self)), guidPartitionID);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceCall_Value = Guid.initString("bd3e2e12-42dd-40f4-a09a-95a50c58304b");
|
|
pub const IID_IServiceCall = &IID_IServiceCall_Value;
|
|
pub const IServiceCall = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnCall: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceCall,
|
|
) 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 IServiceCall_OnCall(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceCall.VTable, @ptrCast(self.vtable)).OnCall(@as(*const IServiceCall, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IAsyncErrorNotify_Value = Guid.initString("fe6777fb-a674-4177-8f32-6d707e113484");
|
|
pub const IID_IAsyncErrorNotify = &IID_IAsyncErrorNotify_Value;
|
|
pub const IAsyncErrorNotify = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnError: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IAsyncErrorNotify,
|
|
hr: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IAsyncErrorNotify,
|
|
hr: HRESULT,
|
|
) 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 IAsyncErrorNotify_OnError(self: *const T, hr: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const IAsyncErrorNotify.VTable, @ptrCast(self.vtable)).OnError(@as(*const IAsyncErrorNotify, @ptrCast(self)), hr);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServiceActivity_Value = Guid.initString("67532e0c-9e2f-4450-a354-035633944e17");
|
|
pub const IID_IServiceActivity = &IID_IServiceActivity_Value;
|
|
pub const IServiceActivity = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SynchronousCall: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceActivity,
|
|
pIServiceCall: ?*IServiceCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceActivity,
|
|
pIServiceCall: ?*IServiceCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AsynchronousCall: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceActivity,
|
|
pIServiceCall: ?*IServiceCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceActivity,
|
|
pIServiceCall: ?*IServiceCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
BindToCurrentThread: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceActivity,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceActivity,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
UnbindFromThread: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServiceActivity,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServiceActivity,
|
|
) 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 IServiceActivity_SynchronousCall(self: *const T, pIServiceCall: ?*IServiceCall) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceActivity.VTable, @ptrCast(self.vtable)).SynchronousCall(@as(*const IServiceActivity, @ptrCast(self)), pIServiceCall);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceActivity_AsynchronousCall(self: *const T, pIServiceCall: ?*IServiceCall) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceActivity.VTable, @ptrCast(self.vtable)).AsynchronousCall(@as(*const IServiceActivity, @ptrCast(self)), pIServiceCall);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceActivity_BindToCurrentThread(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceActivity.VTable, @ptrCast(self.vtable)).BindToCurrentThread(@as(*const IServiceActivity, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServiceActivity_UnbindFromThread(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IServiceActivity.VTable, @ptrCast(self.vtable)).UnbindFromThread(@as(*const IServiceActivity, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IThreadPoolKnobs_Value = Guid.initString("51372af7-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IThreadPoolKnobs = &IID_IThreadPoolKnobs_Value;
|
|
pub const IThreadPoolKnobs = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetMaxThreads: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
plcMaxThreads: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
plcMaxThreads: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetCurrentThreads: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
plcCurrentThreads: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
plcCurrentThreads: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetMaxThreads: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
lcMaxThreads: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
lcMaxThreads: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetDeleteDelay: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
pmsecDeleteDelay: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
pmsecDeleteDelay: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetDeleteDelay: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
msecDeleteDelay: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
msecDeleteDelay: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetMaxQueuedRequests: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
plcMaxQueuedRequests: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
plcMaxQueuedRequests: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetCurrentQueuedRequests: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
plcCurrentQueuedRequests: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
plcCurrentQueuedRequests: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetMaxQueuedRequests: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
lcMaxQueuedRequests: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
lcMaxQueuedRequests: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetMinThreads: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
lcMinThreads: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
lcMinThreads: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetQueueDepth: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IThreadPoolKnobs,
|
|
lcQueueDepth: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IThreadPoolKnobs,
|
|
lcQueueDepth: i32,
|
|
) 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 IThreadPoolKnobs_GetMaxThreads(self: *const T, plcMaxThreads: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetMaxThreads(@as(*const IThreadPoolKnobs, @ptrCast(self)), plcMaxThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_GetCurrentThreads(self: *const T, plcCurrentThreads: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetCurrentThreads(@as(*const IThreadPoolKnobs, @ptrCast(self)), plcCurrentThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_SetMaxThreads(self: *const T, lcMaxThreads: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMaxThreads(@as(*const IThreadPoolKnobs, @ptrCast(self)), lcMaxThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_GetDeleteDelay(self: *const T, pmsecDeleteDelay: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetDeleteDelay(@as(*const IThreadPoolKnobs, @ptrCast(self)), pmsecDeleteDelay);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_SetDeleteDelay(self: *const T, msecDeleteDelay: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetDeleteDelay(@as(*const IThreadPoolKnobs, @ptrCast(self)), msecDeleteDelay);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_GetMaxQueuedRequests(self: *const T, plcMaxQueuedRequests: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetMaxQueuedRequests(@as(*const IThreadPoolKnobs, @ptrCast(self)), plcMaxQueuedRequests);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_GetCurrentQueuedRequests(self: *const T, plcCurrentQueuedRequests: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetCurrentQueuedRequests(@as(*const IThreadPoolKnobs, @ptrCast(self)), plcCurrentQueuedRequests);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_SetMaxQueuedRequests(self: *const T, lcMaxQueuedRequests: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMaxQueuedRequests(@as(*const IThreadPoolKnobs, @ptrCast(self)), lcMaxQueuedRequests);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_SetMinThreads(self: *const T, lcMinThreads: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMinThreads(@as(*const IThreadPoolKnobs, @ptrCast(self)), lcMinThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IThreadPoolKnobs_SetQueueDepth(self: *const T, lcQueueDepth: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetQueueDepth(@as(*const IThreadPoolKnobs, @ptrCast(self)), lcQueueDepth);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IComStaThreadPoolKnobs_Value = Guid.initString("324b64fa-33b6-11d2-98b7-00c04f8ee1c4");
|
|
pub const IID_IComStaThreadPoolKnobs = &IID_IComStaThreadPoolKnobs_Value;
|
|
pub const IComStaThreadPoolKnobs = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SetMinThreadCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
minThreads: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
minThreads: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetMinThreadCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
minThreads: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
minThreads: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetMaxThreadCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
maxThreads: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
maxThreads: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetMaxThreadCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
maxThreads: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
maxThreads: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetActivityPerThread: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
activitiesPerThread: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
activitiesPerThread: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetActivityPerThread: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
activitiesPerThread: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
activitiesPerThread: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetActivityRatio: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
activityRatio: f64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
activityRatio: f64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetActivityRatio: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
activityRatio: ?*f64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
activityRatio: ?*f64,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetThreadCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
pdwThreads: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
pdwThreads: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetQueueDepth: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
pdwQDepth: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
pdwQDepth: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetQueueDepth: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
dwQDepth: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs,
|
|
dwQDepth: i32,
|
|
) 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 IComStaThreadPoolKnobs_SetMinThreadCount(self: *const T, minThreads: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMinThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), minThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_GetMinThreadCount(self: *const T, minThreads: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetMinThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), minThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_SetMaxThreadCount(self: *const T, maxThreads: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetMaxThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), maxThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_GetMaxThreadCount(self: *const T, maxThreads: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetMaxThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), maxThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_SetActivityPerThread(self: *const T, activitiesPerThread: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetActivityPerThread(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), activitiesPerThread);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_GetActivityPerThread(self: *const T, activitiesPerThread: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetActivityPerThread(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), activitiesPerThread);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_SetActivityRatio(self: *const T, activityRatio: f64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetActivityRatio(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), activityRatio);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_GetActivityRatio(self: *const T, activityRatio: ?*f64) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetActivityRatio(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), activityRatio);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_GetThreadCount(self: *const T, pdwThreads: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetThreadCount(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), pdwThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_GetQueueDepth(self: *const T, pdwQDepth: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).GetQueueDepth(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), pdwQDepth);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs_SetQueueDepth(self: *const T, dwQDepth: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).SetQueueDepth(@as(*const IComStaThreadPoolKnobs, @ptrCast(self)), dwQDepth);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IComMtaThreadPoolKnobs_Value = Guid.initString("f9a76d2e-76a5-43eb-a0c4-49bec8e48480");
|
|
pub const IID_IComMtaThreadPoolKnobs = &IID_IComMtaThreadPoolKnobs_Value;
|
|
pub const IComMtaThreadPoolKnobs = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
MTASetMaxThreadCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMtaThreadPoolKnobs,
|
|
dwMaxThreads: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMtaThreadPoolKnobs,
|
|
dwMaxThreads: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
MTAGetMaxThreadCount: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMtaThreadPoolKnobs,
|
|
pdwMaxThreads: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMtaThreadPoolKnobs,
|
|
pdwMaxThreads: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
MTASetThrottleValue: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMtaThreadPoolKnobs,
|
|
dwThrottle: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMtaThreadPoolKnobs,
|
|
dwThrottle: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
MTAGetThrottleValue: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComMtaThreadPoolKnobs,
|
|
pdwThrottle: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComMtaThreadPoolKnobs,
|
|
pdwThrottle: ?*u32,
|
|
) 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 IComMtaThreadPoolKnobs_MTASetMaxThreadCount(self: *const T, dwMaxThreads: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMtaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).MTASetMaxThreadCount(@as(*const IComMtaThreadPoolKnobs, @ptrCast(self)), dwMaxThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComMtaThreadPoolKnobs_MTAGetMaxThreadCount(self: *const T, pdwMaxThreads: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMtaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).MTAGetMaxThreadCount(@as(*const IComMtaThreadPoolKnobs, @ptrCast(self)), pdwMaxThreads);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComMtaThreadPoolKnobs_MTASetThrottleValue(self: *const T, dwThrottle: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMtaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).MTASetThrottleValue(@as(*const IComMtaThreadPoolKnobs, @ptrCast(self)), dwThrottle);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComMtaThreadPoolKnobs_MTAGetThrottleValue(self: *const T, pdwThrottle: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComMtaThreadPoolKnobs.VTable, @ptrCast(self.vtable)).MTAGetThrottleValue(@as(*const IComMtaThreadPoolKnobs, @ptrCast(self)), pdwThrottle);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
const IID_IComStaThreadPoolKnobs2_Value = Guid.initString("73707523-ff9a-4974-bf84-2108dc213740");
|
|
pub const IID_IComStaThreadPoolKnobs2 = &IID_IComStaThreadPoolKnobs2_Value;
|
|
pub const IComStaThreadPoolKnobs2 = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IComStaThreadPoolKnobs.VTable,
|
|
GetMaxCPULoad: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pdwLoad: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pdwLoad: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetMaxCPULoad: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pdwLoad: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pdwLoad: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetCPUMetricEnabled: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pbMetricEnabled: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pbMetricEnabled: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetCPUMetricEnabled: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
bMetricEnabled: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
bMetricEnabled: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetCreateThreadsAggressively: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pbMetricEnabled: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pbMetricEnabled: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetCreateThreadsAggressively: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
bMetricEnabled: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
bMetricEnabled: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetMaxCSR: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pdwCSR: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pdwCSR: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetMaxCSR: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
dwCSR: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
dwCSR: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetWaitTimeForThreadCleanup: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pdwThreadCleanupWaitTime: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
pdwThreadCleanupWaitTime: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetWaitTimeForThreadCleanup: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
dwThreadCleanupWaitTime: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IComStaThreadPoolKnobs2,
|
|
dwThreadCleanupWaitTime: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IComStaThreadPoolKnobs.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_GetMaxCPULoad(self: *const T, pdwLoad: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetMaxCPULoad(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pdwLoad);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_SetMaxCPULoad(self: *const T, pdwLoad: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetMaxCPULoad(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pdwLoad);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_GetCPUMetricEnabled(self: *const T, pbMetricEnabled: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetCPUMetricEnabled(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pbMetricEnabled);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_SetCPUMetricEnabled(self: *const T, bMetricEnabled: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetCPUMetricEnabled(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), bMetricEnabled);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_GetCreateThreadsAggressively(self: *const T, pbMetricEnabled: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetCreateThreadsAggressively(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pbMetricEnabled);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_SetCreateThreadsAggressively(self: *const T, bMetricEnabled: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetCreateThreadsAggressively(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), bMetricEnabled);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_GetMaxCSR(self: *const T, pdwCSR: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetMaxCSR(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pdwCSR);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_SetMaxCSR(self: *const T, dwCSR: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetMaxCSR(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), dwCSR);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_GetWaitTimeForThreadCleanup(self: *const T, pdwThreadCleanupWaitTime: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).GetWaitTimeForThreadCleanup(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), pdwThreadCleanupWaitTime);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IComStaThreadPoolKnobs2_SetWaitTimeForThreadCleanup(self: *const T, dwThreadCleanupWaitTime: i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IComStaThreadPoolKnobs2.VTable, @ptrCast(self.vtable)).SetWaitTimeForThreadCleanup(@as(*const IComStaThreadPoolKnobs2, @ptrCast(self)), dwThreadCleanupWaitTime);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IProcessInitializer_Value = Guid.initString("1113f52d-dc7f-4943-aed6-88d04027e32a");
|
|
pub const IID_IProcessInitializer = &IID_IProcessInitializer_Value;
|
|
pub const IProcessInitializer = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Startup: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IProcessInitializer,
|
|
punkProcessControl: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IProcessInitializer,
|
|
punkProcessControl: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Shutdown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IProcessInitializer,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IProcessInitializer,
|
|
) 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 IProcessInitializer_Startup(self: *const T, punkProcessControl: ?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IProcessInitializer.VTable, @ptrCast(self.vtable)).Startup(@as(*const IProcessInitializer, @ptrCast(self)), punkProcessControl);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IProcessInitializer_Shutdown(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IProcessInitializer.VTable, @ptrCast(self.vtable)).Shutdown(@as(*const IProcessInitializer, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IServicePoolConfig_Value = Guid.initString("a9690656-5bca-470c-8451-250c1f43a33e");
|
|
pub const IID_IServicePoolConfig = &IID_IServicePoolConfig_Value;
|
|
pub const IServicePoolConfig = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_MaxPoolSize: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
dwMaxPool: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
dwMaxPool: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_MaxPoolSize: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
pdwMaxPool: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
pdwMaxPool: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_MinPoolSize: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
dwMinPool: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
dwMinPool: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_MinPoolSize: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
pdwMinPool: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
pdwMinPool: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_CreationTimeout: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
dwCreationTimeout: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
dwCreationTimeout: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_CreationTimeout: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
pdwCreationTimeout: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
pdwCreationTimeout: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_TransactionAffinity: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
fTxAffinity: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
fTxAffinity: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_TransactionAffinity: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
pfTxAffinity: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
pfTxAffinity: ?*BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
put_ClassFactory: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
pFactory: ?*IClassFactory,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
pFactory: ?*IClassFactory,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
get_ClassFactory: switch (@import("builtin").zig_backend) {
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
.stage1 => fn(
|
|
self: *const IServicePoolConfig,
|
|
pFactory: ?*?*IClassFactory,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
// TODO: this function has a "SpecialName", should Zig do anything with this?
|
|
else => *const fn(
|
|
self: *const IServicePoolConfig,
|
|
pFactory: ?*?*IClassFactory,
|
|
) 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 IServicePoolConfig_put_MaxPoolSize(self: *const T, dwMaxPool: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_MaxPoolSize(@as(*const IServicePoolConfig, @ptrCast(self)), dwMaxPool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_get_MaxPoolSize(self: *const T, pdwMaxPool: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_MaxPoolSize(@as(*const IServicePoolConfig, @ptrCast(self)), pdwMaxPool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_put_MinPoolSize(self: *const T, dwMinPool: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_MinPoolSize(@as(*const IServicePoolConfig, @ptrCast(self)), dwMinPool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_get_MinPoolSize(self: *const T, pdwMinPool: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_MinPoolSize(@as(*const IServicePoolConfig, @ptrCast(self)), pdwMinPool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_put_CreationTimeout(self: *const T, dwCreationTimeout: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_CreationTimeout(@as(*const IServicePoolConfig, @ptrCast(self)), dwCreationTimeout);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_get_CreationTimeout(self: *const T, pdwCreationTimeout: ?*u32) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_CreationTimeout(@as(*const IServicePoolConfig, @ptrCast(self)), pdwCreationTimeout);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_put_TransactionAffinity(self: *const T, fTxAffinity: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_TransactionAffinity(@as(*const IServicePoolConfig, @ptrCast(self)), fTxAffinity);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_get_TransactionAffinity(self: *const T, pfTxAffinity: ?*BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_TransactionAffinity(@as(*const IServicePoolConfig, @ptrCast(self)), pfTxAffinity);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_put_ClassFactory(self: *const T, pFactory: ?*IClassFactory) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).put_ClassFactory(@as(*const IServicePoolConfig, @ptrCast(self)), pFactory);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePoolConfig_get_ClassFactory(self: *const T, pFactory: ?*?*IClassFactory) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePoolConfig.VTable, @ptrCast(self.vtable)).get_ClassFactory(@as(*const IServicePoolConfig, @ptrCast(self)), pFactory);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IServicePool_Value = Guid.initString("b302df81-ea45-451e-99a2-09f9fd1b1e13");
|
|
pub const IID_IServicePool = &IID_IServicePool_Value;
|
|
pub const IServicePool = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Initialize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServicePool,
|
|
pPoolConfig: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServicePool,
|
|
pPoolConfig: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetObject: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServicePool,
|
|
riid: ?*const Guid,
|
|
ppv: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServicePool,
|
|
riid: ?*const Guid,
|
|
ppv: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Shutdown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IServicePool,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IServicePool,
|
|
) 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 IServicePool_Initialize(self: *const T, pPoolConfig: ?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePool.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IServicePool, @ptrCast(self)), pPoolConfig);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePool_GetObject(self: *const T, riid: ?*const Guid, ppv: ?*?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePool.VTable, @ptrCast(self.vtable)).GetObject(@as(*const IServicePool, @ptrCast(self)), riid, ppv);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IServicePool_Shutdown(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IServicePool.VTable, @ptrCast(self.vtable)).Shutdown(@as(*const IServicePool, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IManagedPooledObj_Value = Guid.initString("c5da4bea-1b42-4437-8926-b6a38860a770");
|
|
pub const IID_IManagedPooledObj = &IID_IManagedPooledObj_Value;
|
|
pub const IManagedPooledObj = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SetHeld: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IManagedPooledObj,
|
|
m_bHeld: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IManagedPooledObj,
|
|
m_bHeld: BOOL,
|
|
) 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 IManagedPooledObj_SetHeld(self: *const T, m_bHeld: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IManagedPooledObj.VTable, @ptrCast(self.vtable)).SetHeld(@as(*const IManagedPooledObj, @ptrCast(self)), m_bHeld);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IManagedPoolAction_Value = Guid.initString("da91b74e-5388-4783-949d-c1cd5fb00506");
|
|
pub const IID_IManagedPoolAction = &IID_IManagedPoolAction_Value;
|
|
pub const IManagedPoolAction = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
LastRelease: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IManagedPoolAction,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IManagedPoolAction,
|
|
) 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 IManagedPoolAction_LastRelease(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IManagedPoolAction.VTable, @ptrCast(self.vtable)).LastRelease(@as(*const IManagedPoolAction, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IManagedObjectInfo_Value = Guid.initString("1427c51a-4584-49d8-90a0-c50d8086cbe9");
|
|
pub const IID_IManagedObjectInfo = &IID_IManagedObjectInfo_Value;
|
|
pub const IManagedObjectInfo = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
GetIUnknown: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IManagedObjectInfo,
|
|
pUnk: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IManagedObjectInfo,
|
|
pUnk: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetIObjectControl: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IManagedObjectInfo,
|
|
pCtrl: ?*?*IObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IManagedObjectInfo,
|
|
pCtrl: ?*?*IObjectControl,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetInPool: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IManagedObjectInfo,
|
|
bInPool: BOOL,
|
|
pPooledObj: ?*IManagedPooledObj,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IManagedObjectInfo,
|
|
bInPool: BOOL,
|
|
pPooledObj: ?*IManagedPooledObj,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetWrapperStrength: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IManagedObjectInfo,
|
|
bStrong: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IManagedObjectInfo,
|
|
bStrong: BOOL,
|
|
) 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 IManagedObjectInfo_GetIUnknown(self: *const T, pUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const IManagedObjectInfo.VTable, @ptrCast(self.vtable)).GetIUnknown(@as(*const IManagedObjectInfo, @ptrCast(self)), pUnk);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IManagedObjectInfo_GetIObjectControl(self: *const T, pCtrl: ?*?*IObjectControl) callconv(.Inline) HRESULT {
|
|
return @as(*const IManagedObjectInfo.VTable, @ptrCast(self.vtable)).GetIObjectControl(@as(*const IManagedObjectInfo, @ptrCast(self)), pCtrl);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IManagedObjectInfo_SetInPool(self: *const T, bInPool: BOOL, pPooledObj: ?*IManagedPooledObj) callconv(.Inline) HRESULT {
|
|
return @as(*const IManagedObjectInfo.VTable, @ptrCast(self.vtable)).SetInPool(@as(*const IManagedObjectInfo, @ptrCast(self)), bInPool, pPooledObj);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IManagedObjectInfo_SetWrapperStrength(self: *const T, bStrong: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IManagedObjectInfo.VTable, @ptrCast(self.vtable)).SetWrapperStrength(@as(*const IManagedObjectInfo, @ptrCast(self)), bStrong);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IAppDomainHelper_Value = Guid.initString("c7b67079-8255-42c6-9ec0-6994a3548780");
|
|
pub const IID_IAppDomainHelper = &IID_IAppDomainHelper_Value;
|
|
pub const IAppDomainHelper = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
Initialize: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IAppDomainHelper,
|
|
pUnkAD: ?*IUnknown,
|
|
__MIDL__IAppDomainHelper0000: isize,
|
|
pPool: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IAppDomainHelper,
|
|
pUnkAD: ?*IUnknown,
|
|
__MIDL__IAppDomainHelper0000: isize,
|
|
pPool: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DoCallback: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IAppDomainHelper,
|
|
pUnkAD: ?*IUnknown,
|
|
__MIDL__IAppDomainHelper0001: isize,
|
|
pPool: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IAppDomainHelper,
|
|
pUnkAD: ?*IUnknown,
|
|
__MIDL__IAppDomainHelper0001: isize,
|
|
pPool: ?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IAppDomainHelper_Initialize(self: *const T, pUnkAD: ?*IUnknown, __MIDL__IAppDomainHelper0000: isize, pPool: ?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IAppDomainHelper.VTable, @ptrCast(self.vtable)).Initialize(@as(*const IAppDomainHelper, @ptrCast(self)), pUnkAD, __MIDL__IAppDomainHelper0000, pPool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IAppDomainHelper_DoCallback(self: *const T, pUnkAD: ?*IUnknown, __MIDL__IAppDomainHelper0001: isize, pPool: ?*anyopaque) callconv(.Inline) HRESULT {
|
|
return @as(*const IAppDomainHelper.VTable, @ptrCast(self.vtable)).DoCallback(@as(*const IAppDomainHelper, @ptrCast(self)), pUnkAD, __MIDL__IAppDomainHelper0001, pPool);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IAssemblyLocator_Value = Guid.initString("391ffbb9-a8ee-432a-abc8-baa238dab90f");
|
|
pub const IID_IAssemblyLocator = &IID_IAssemblyLocator_Value;
|
|
pub const IAssemblyLocator = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IDispatch.VTable,
|
|
GetModules: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IAssemblyLocator,
|
|
applicationDir: ?BSTR,
|
|
applicationName: ?BSTR,
|
|
assemblyName: ?BSTR,
|
|
pModules: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IAssemblyLocator,
|
|
applicationDir: ?BSTR,
|
|
applicationName: ?BSTR,
|
|
assemblyName: ?BSTR,
|
|
pModules: ?*?*SAFEARRAY,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
};
|
|
vtable: *const VTable,
|
|
pub fn MethodMixin(comptime T: type) type { return struct {
|
|
pub usingnamespace IDispatch.MethodMixin(T);
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IAssemblyLocator_GetModules(self: *const T, applicationDir: ?BSTR, applicationName: ?BSTR, assemblyName: ?BSTR, pModules: ?*?*SAFEARRAY) callconv(.Inline) HRESULT {
|
|
return @as(*const IAssemblyLocator.VTable, @ptrCast(self.vtable)).GetModules(@as(*const IAssemblyLocator, @ptrCast(self)), applicationDir, applicationName, assemblyName, pModules);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IManagedActivationEvents_Value = Guid.initString("a5f325af-572f-46da-b8ab-827c3d95d99e");
|
|
pub const IID_IManagedActivationEvents = &IID_IManagedActivationEvents_Value;
|
|
pub const IManagedActivationEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
CreateManagedStub: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IManagedActivationEvents,
|
|
pInfo: ?*IManagedObjectInfo,
|
|
fDist: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IManagedActivationEvents,
|
|
pInfo: ?*IManagedObjectInfo,
|
|
fDist: BOOL,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
DestroyManagedStub: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IManagedActivationEvents,
|
|
pInfo: ?*IManagedObjectInfo,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IManagedActivationEvents,
|
|
pInfo: ?*IManagedObjectInfo,
|
|
) 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 IManagedActivationEvents_CreateManagedStub(self: *const T, pInfo: ?*IManagedObjectInfo, fDist: BOOL) callconv(.Inline) HRESULT {
|
|
return @as(*const IManagedActivationEvents.VTable, @ptrCast(self.vtable)).CreateManagedStub(@as(*const IManagedActivationEvents, @ptrCast(self)), pInfo, fDist);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IManagedActivationEvents_DestroyManagedStub(self: *const T, pInfo: ?*IManagedObjectInfo) callconv(.Inline) HRESULT {
|
|
return @as(*const IManagedActivationEvents.VTable, @ptrCast(self.vtable)).DestroyManagedStub(@as(*const IManagedActivationEvents, @ptrCast(self)), pInfo);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_ISendMethodEvents_Value = Guid.initString("2732fd59-b2b4-4d44-878c-8b8f09626008");
|
|
pub const IID_ISendMethodEvents = &IID_ISendMethodEvents_Value;
|
|
pub const ISendMethodEvents = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SendMethodCall: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISendMethodEvents,
|
|
pIdentity: ?*const anyopaque,
|
|
riid: ?*const Guid,
|
|
dwMeth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISendMethodEvents,
|
|
pIdentity: ?*const anyopaque,
|
|
riid: ?*const Guid,
|
|
dwMeth: u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SendMethodReturn: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ISendMethodEvents,
|
|
pIdentity: ?*const anyopaque,
|
|
riid: ?*const Guid,
|
|
dwMeth: u32,
|
|
hrCall: HRESULT,
|
|
hrServer: HRESULT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ISendMethodEvents,
|
|
pIdentity: ?*const anyopaque,
|
|
riid: ?*const Guid,
|
|
dwMeth: u32,
|
|
hrCall: HRESULT,
|
|
hrServer: HRESULT,
|
|
) 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 ISendMethodEvents_SendMethodCall(self: *const T, pIdentity: ?*const anyopaque, riid: ?*const Guid, dwMeth: u32) callconv(.Inline) HRESULT {
|
|
return @as(*const ISendMethodEvents.VTable, @ptrCast(self.vtable)).SendMethodCall(@as(*const ISendMethodEvents, @ptrCast(self)), pIdentity, riid, dwMeth);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ISendMethodEvents_SendMethodReturn(self: *const T, pIdentity: ?*const anyopaque, riid: ?*const Guid, dwMeth: u32, hrCall: HRESULT, hrServer: HRESULT) callconv(.Inline) HRESULT {
|
|
return @as(*const ISendMethodEvents.VTable, @ptrCast(self.vtable)).SendMethodReturn(@as(*const ISendMethodEvents, @ptrCast(self)), pIdentity, riid, dwMeth, hrCall, hrServer);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_ITransactionResourcePool_Value = Guid.initString("c5feb7c1-346a-11d1-b1cc-00aa00ba3258");
|
|
pub const IID_ITransactionResourcePool = &IID_ITransactionResourcePool_Value;
|
|
pub const ITransactionResourcePool = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
PutResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResourcePool,
|
|
pPool: ?*IObjPool,
|
|
pUnk: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResourcePool,
|
|
pPool: ?*IObjPool,
|
|
pUnk: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetResource: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionResourcePool,
|
|
pPool: ?*IObjPool,
|
|
ppUnk: ?*?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionResourcePool,
|
|
pPool: ?*IObjPool,
|
|
ppUnk: ?*?*IUnknown,
|
|
) 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 ITransactionResourcePool_PutResource(self: *const T, pPool: ?*IObjPool, pUnk: ?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResourcePool.VTable, @ptrCast(self.vtable)).PutResource(@as(*const ITransactionResourcePool, @ptrCast(self)), pPool, pUnk);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionResourcePool_GetResource(self: *const T, pPool: ?*IObjPool, ppUnk: ?*?*IUnknown) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionResourcePool.VTable, @ptrCast(self.vtable)).GetResource(@as(*const ITransactionResourcePool, @ptrCast(self)), pPool, ppUnk);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IMTSCall_Value = Guid.initString("51372aef-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IMTSCall = &IID_IMTSCall_Value;
|
|
pub const IMTSCall = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
OnCall: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMTSCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMTSCall,
|
|
) 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 IMTSCall_OnCall(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IMTSCall.VTable, @ptrCast(self.vtable)).OnCall(@as(*const IMTSCall, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IContextProperties_Value = Guid.initString("d396da85-bf8f-11d1-bbae-00c04fc2fa5f");
|
|
pub const IID_IContextProperties = &IID_IContextProperties_Value;
|
|
pub const IContextProperties = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Count: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextProperties,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextProperties,
|
|
plCount: ?*i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
GetProperty: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextProperties,
|
|
name: ?BSTR,
|
|
pProperty: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextProperties,
|
|
name: ?BSTR,
|
|
pProperty: ?*VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
EnumNames: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextProperties,
|
|
ppenum: ?*?*IEnumNames,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextProperties,
|
|
ppenum: ?*?*IEnumNames,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
SetProperty: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextProperties,
|
|
name: ?BSTR,
|
|
property: VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextProperties,
|
|
name: ?BSTR,
|
|
property: VARIANT,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
RemoveProperty: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IContextProperties,
|
|
name: ?BSTR,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IContextProperties,
|
|
name: ?BSTR,
|
|
) 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 IContextProperties_Count(self: *const T, plCount: ?*i32) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).Count(@as(*const IContextProperties, @ptrCast(self)), plCount);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContextProperties_GetProperty(self: *const T, name: ?BSTR, pProperty: ?*VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).GetProperty(@as(*const IContextProperties, @ptrCast(self)), name, pProperty);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContextProperties_EnumNames(self: *const T, ppenum: ?*?*IEnumNames) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).EnumNames(@as(*const IContextProperties, @ptrCast(self)), ppenum);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContextProperties_SetProperty(self: *const T, name: ?BSTR, property: VARIANT) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).SetProperty(@as(*const IContextProperties, @ptrCast(self)), name, property);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IContextProperties_RemoveProperty(self: *const T, name: ?BSTR) callconv(.Inline) HRESULT {
|
|
return @as(*const IContextProperties.VTable, @ptrCast(self.vtable)).RemoveProperty(@as(*const IContextProperties, @ptrCast(self)), name);
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_IObjPool_Value = Guid.initString("7d8805a0-2ea7-11d1-b1cc-00aa00ba3258");
|
|
pub const IID_IObjPool = &IID_IObjPool_Value;
|
|
pub const IObjPool = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Reserved1: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved3: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved4: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
PutEndTx: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjPool,
|
|
pObj: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IObjPool,
|
|
pObj: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved5: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved6: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IObjPool,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
};
|
|
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 IObjPool_Reserved1(self: *const T) callconv(.Inline) void {
|
|
return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved1(@as(*const IObjPool, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjPool_Reserved2(self: *const T) callconv(.Inline) void {
|
|
return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved2(@as(*const IObjPool, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjPool_Reserved3(self: *const T) callconv(.Inline) void {
|
|
return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved3(@as(*const IObjPool, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjPool_Reserved4(self: *const T) callconv(.Inline) void {
|
|
return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved4(@as(*const IObjPool, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjPool_PutEndTx(self: *const T, pObj: ?*IUnknown) callconv(.Inline) void {
|
|
return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).PutEndTx(@as(*const IObjPool, @ptrCast(self)), pObj);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjPool_Reserved5(self: *const T) callconv(.Inline) void {
|
|
return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved5(@as(*const IObjPool, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IObjPool_Reserved6(self: *const T) callconv(.Inline) void {
|
|
return @as(*const IObjPool.VTable, @ptrCast(self.vtable)).Reserved6(@as(*const IObjPool, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
const IID_ITransactionProperty_Value = Guid.initString("788ea814-87b1-11d1-bba6-00c04fc2fa5f");
|
|
pub const IID_ITransactionProperty = &IID_ITransactionProperty_Value;
|
|
pub const ITransactionProperty = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
Reserved1: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved2: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved3: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved4: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved5: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved6: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved7: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved8: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved9: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
GetTransactionResourcePool: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
ppTxPool: ?*?*ITransactionResourcePool,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
ppTxPool: ?*?*ITransactionResourcePool,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reserved10: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved11: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved12: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved13: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved14: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved15: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved16: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
Reserved17: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const ITransactionProperty,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
};
|
|
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 ITransactionProperty_Reserved1(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved1(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved2(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved2(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved3(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved3(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved4(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved4(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved5(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved5(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved6(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved6(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved7(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved7(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved8(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved8(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved9(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved9(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_GetTransactionResourcePool(self: *const T, ppTxPool: ?*?*ITransactionResourcePool) callconv(.Inline) HRESULT {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).GetTransactionResourcePool(@as(*const ITransactionProperty, @ptrCast(self)), ppTxPool);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved10(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved10(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved11(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved11(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved12(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved12(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved13(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved13(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved14(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved14(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved15(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved15(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved16(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved16(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn ITransactionProperty_Reserved17(self: *const T) callconv(.Inline) void {
|
|
return @as(*const ITransactionProperty.VTable, @ptrCast(self.vtable)).Reserved17(@as(*const ITransactionProperty, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
const IID_IMTSActivity_Value = Guid.initString("51372af0-cae7-11cf-be81-00aa00a2fa25");
|
|
pub const IID_IMTSActivity = &IID_IMTSActivity_Value;
|
|
pub const IMTSActivity = extern struct {
|
|
pub const VTable = extern struct {
|
|
base: IUnknown.VTable,
|
|
SynchronousCall: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMTSActivity,
|
|
pCall: ?*IMTSCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMTSActivity,
|
|
pCall: ?*IMTSCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
AsyncCall: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMTSActivity,
|
|
pCall: ?*IMTSCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMTSActivity,
|
|
pCall: ?*IMTSCall,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
Reserved1: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMTSActivity,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
else => *const fn(
|
|
self: *const IMTSActivity,
|
|
) callconv(@import("std").os.windows.WINAPI) void,
|
|
},
|
|
BindToCurrentThread: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMTSActivity,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMTSActivity,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
},
|
|
UnbindFromThread: switch (@import("builtin").zig_backend) {
|
|
.stage1 => fn(
|
|
self: *const IMTSActivity,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT,
|
|
else => *const fn(
|
|
self: *const IMTSActivity,
|
|
) 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 IMTSActivity_SynchronousCall(self: *const T, pCall: ?*IMTSCall) callconv(.Inline) HRESULT {
|
|
return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).SynchronousCall(@as(*const IMTSActivity, @ptrCast(self)), pCall);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMTSActivity_AsyncCall(self: *const T, pCall: ?*IMTSCall) callconv(.Inline) HRESULT {
|
|
return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).AsyncCall(@as(*const IMTSActivity, @ptrCast(self)), pCall);
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMTSActivity_Reserved1(self: *const T) callconv(.Inline) void {
|
|
return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).Reserved1(@as(*const IMTSActivity, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMTSActivity_BindToCurrentThread(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).BindToCurrentThread(@as(*const IMTSActivity, @ptrCast(self)));
|
|
}
|
|
// NOTE: method is namespaced with interface name to avoid conflicts for now
|
|
pub fn IMTSActivity_UnbindFromThread(self: *const T) callconv(.Inline) HRESULT {
|
|
return @as(*const IMTSActivity.VTable, @ptrCast(self.vtable)).UnbindFromThread(@as(*const IMTSActivity, @ptrCast(self)));
|
|
}
|
|
};}
|
|
pub usingnamespace MethodMixin(@This());
|
|
};
|
|
|
|
pub const AutoSvcs_Error_Constants = enum(u32) {
|
|
mtsErrCtxAborted = 2147803138,
|
|
mtsErrCtxAborting = 2147803139,
|
|
mtsErrCtxNoContext = 2147803140,
|
|
mtsErrCtxNotRegistered = 2147803141,
|
|
mtsErrCtxSynchTimeout = 2147803142,
|
|
mtsErrCtxOldReference = 2147803143,
|
|
mtsErrCtxRoleNotFound = 2147803148,
|
|
mtsErrCtxNoSecurity = 2147803149,
|
|
mtsErrCtxWrongThread = 2147803150,
|
|
mtsErrCtxTMNotAvailable = 2147803151,
|
|
comQCErrApplicationNotQueued = 2148599296,
|
|
comQCErrNoQueueableInterfaces = 2148599297,
|
|
comQCErrQueuingServiceNotAvailable = 2148599298,
|
|
comQCErrQueueTransactMismatch = 2148599299,
|
|
comqcErrRecorderMarshalled = 2148599300,
|
|
comqcErrOutParam = 2148599301,
|
|
comqcErrRecorderNotTrusted = 2148599302,
|
|
comqcErrPSLoad = 2148599303,
|
|
comqcErrMarshaledObjSameTxn = 2148599304,
|
|
comqcErrInvalidMessage = 2148599376,
|
|
comqcErrMsmqSidUnavailable = 2148599377,
|
|
comqcErrWrongMsgExtension = 2148599378,
|
|
comqcErrMsmqServiceUnavailable = 2148599379,
|
|
comqcErrMsgNotAuthenticated = 2148599380,
|
|
comqcErrMsmqConnectorUsed = 2148599381,
|
|
comqcErrBadMarshaledObject = 2148599382,
|
|
};
|
|
pub const mtsErrCtxAborted = AutoSvcs_Error_Constants.mtsErrCtxAborted;
|
|
pub const mtsErrCtxAborting = AutoSvcs_Error_Constants.mtsErrCtxAborting;
|
|
pub const mtsErrCtxNoContext = AutoSvcs_Error_Constants.mtsErrCtxNoContext;
|
|
pub const mtsErrCtxNotRegistered = AutoSvcs_Error_Constants.mtsErrCtxNotRegistered;
|
|
pub const mtsErrCtxSynchTimeout = AutoSvcs_Error_Constants.mtsErrCtxSynchTimeout;
|
|
pub const mtsErrCtxOldReference = AutoSvcs_Error_Constants.mtsErrCtxOldReference;
|
|
pub const mtsErrCtxRoleNotFound = AutoSvcs_Error_Constants.mtsErrCtxRoleNotFound;
|
|
pub const mtsErrCtxNoSecurity = AutoSvcs_Error_Constants.mtsErrCtxNoSecurity;
|
|
pub const mtsErrCtxWrongThread = AutoSvcs_Error_Constants.mtsErrCtxWrongThread;
|
|
pub const mtsErrCtxTMNotAvailable = AutoSvcs_Error_Constants.mtsErrCtxTMNotAvailable;
|
|
pub const comQCErrApplicationNotQueued = AutoSvcs_Error_Constants.comQCErrApplicationNotQueued;
|
|
pub const comQCErrNoQueueableInterfaces = AutoSvcs_Error_Constants.comQCErrNoQueueableInterfaces;
|
|
pub const comQCErrQueuingServiceNotAvailable = AutoSvcs_Error_Constants.comQCErrQueuingServiceNotAvailable;
|
|
pub const comQCErrQueueTransactMismatch = AutoSvcs_Error_Constants.comQCErrQueueTransactMismatch;
|
|
pub const comqcErrRecorderMarshalled = AutoSvcs_Error_Constants.comqcErrRecorderMarshalled;
|
|
pub const comqcErrOutParam = AutoSvcs_Error_Constants.comqcErrOutParam;
|
|
pub const comqcErrRecorderNotTrusted = AutoSvcs_Error_Constants.comqcErrRecorderNotTrusted;
|
|
pub const comqcErrPSLoad = AutoSvcs_Error_Constants.comqcErrPSLoad;
|
|
pub const comqcErrMarshaledObjSameTxn = AutoSvcs_Error_Constants.comqcErrMarshaledObjSameTxn;
|
|
pub const comqcErrInvalidMessage = AutoSvcs_Error_Constants.comqcErrInvalidMessage;
|
|
pub const comqcErrMsmqSidUnavailable = AutoSvcs_Error_Constants.comqcErrMsmqSidUnavailable;
|
|
pub const comqcErrWrongMsgExtension = AutoSvcs_Error_Constants.comqcErrWrongMsgExtension;
|
|
pub const comqcErrMsmqServiceUnavailable = AutoSvcs_Error_Constants.comqcErrMsmqServiceUnavailable;
|
|
pub const comqcErrMsgNotAuthenticated = AutoSvcs_Error_Constants.comqcErrMsgNotAuthenticated;
|
|
pub const comqcErrMsmqConnectorUsed = AutoSvcs_Error_Constants.comqcErrMsmqConnectorUsed;
|
|
pub const comqcErrBadMarshaledObject = AutoSvcs_Error_Constants.comqcErrBadMarshaledObject;
|
|
|
|
pub const LockModes = enum(i32) {
|
|
SetGet = 0,
|
|
Method = 1,
|
|
};
|
|
pub const LockSetGet = LockModes.SetGet;
|
|
pub const LockMethod = LockModes.Method;
|
|
|
|
pub const ReleaseModes = enum(i32) {
|
|
Standard = 0,
|
|
Process = 1,
|
|
};
|
|
pub const Standard = ReleaseModes.Standard;
|
|
pub const Process = ReleaseModes.Process;
|
|
|
|
pub const CRMFLAGS = enum(i32) {
|
|
FORGETTARGET = 1,
|
|
WRITTENDURINGPREPARE = 2,
|
|
WRITTENDURINGCOMMIT = 4,
|
|
WRITTENDURINGABORT = 8,
|
|
WRITTENDURINGRECOVERY = 16,
|
|
WRITTENDURINGREPLAY = 32,
|
|
REPLAYINPROGRESS = 64,
|
|
};
|
|
pub const CRMFLAG_FORGETTARGET = CRMFLAGS.FORGETTARGET;
|
|
pub const CRMFLAG_WRITTENDURINGPREPARE = CRMFLAGS.WRITTENDURINGPREPARE;
|
|
pub const CRMFLAG_WRITTENDURINGCOMMIT = CRMFLAGS.WRITTENDURINGCOMMIT;
|
|
pub const CRMFLAG_WRITTENDURINGABORT = CRMFLAGS.WRITTENDURINGABORT;
|
|
pub const CRMFLAG_WRITTENDURINGRECOVERY = CRMFLAGS.WRITTENDURINGRECOVERY;
|
|
pub const CRMFLAG_WRITTENDURINGREPLAY = CRMFLAGS.WRITTENDURINGREPLAY;
|
|
pub const CRMFLAG_REPLAYINPROGRESS = CRMFLAGS.REPLAYINPROGRESS;
|
|
|
|
pub const CRMREGFLAGS = enum(i32) {
|
|
PREPAREPHASE = 1,
|
|
COMMITPHASE = 2,
|
|
ABORTPHASE = 4,
|
|
ALLPHASES = 7,
|
|
FAILIFINDOUBTSREMAIN = 16,
|
|
};
|
|
pub const CRMREGFLAG_PREPAREPHASE = CRMREGFLAGS.PREPAREPHASE;
|
|
pub const CRMREGFLAG_COMMITPHASE = CRMREGFLAGS.COMMITPHASE;
|
|
pub const CRMREGFLAG_ABORTPHASE = CRMREGFLAGS.ABORTPHASE;
|
|
pub const CRMREGFLAG_ALLPHASES = CRMREGFLAGS.ALLPHASES;
|
|
pub const CRMREGFLAG_FAILIFINDOUBTSREMAIN = CRMREGFLAGS.FAILIFINDOUBTSREMAIN;
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Section: Functions (9)
|
|
//--------------------------------------------------------------------------------
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
pub extern "ole32" fn CoGetDefaultContext(
|
|
aptType: APTTYPE,
|
|
riid: ?*const Guid,
|
|
ppv: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
pub extern "comsvcs" fn CoCreateActivity(
|
|
pIUnknown: ?*IUnknown,
|
|
riid: ?*const Guid,
|
|
ppObj: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
pub extern "comsvcs" fn CoEnterServiceDomain(
|
|
pConfigObject: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
pub extern "comsvcs" fn CoLeaveServiceDomain(
|
|
pUnkStatus: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) void;
|
|
|
|
// TODO: this type is limited to platform 'windows5.1.2600'
|
|
pub extern "comsvcs" fn GetManagedExtensions(
|
|
dwExts: ?*u32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
pub extern "comsvcs" fn SafeRef(
|
|
rid: ?*const Guid,
|
|
pUnk: ?*IUnknown,
|
|
) callconv(@import("std").os.windows.WINAPI) ?*anyopaque;
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
pub extern "comsvcs" fn RecycleSurrogate(
|
|
lReasonCode: i32,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
pub extern "comsvcs" fn MTSCreateActivity(
|
|
riid: ?*const Guid,
|
|
ppobj: ?*?*anyopaque,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
// TODO: this type is limited to platform 'windows5.0'
|
|
pub extern "mtxdm" fn GetDispenserManager(
|
|
param0: ?*?*IDispenserManager,
|
|
) callconv(@import("std").os.windows.WINAPI) HRESULT;
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// 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 (17)
|
|
//--------------------------------------------------------------------------------
|
|
const Guid = @import("../zig.zig").Guid;
|
|
const APTTYPE = @import("../system/com.zig").APTTYPE;
|
|
const BLOB = @import("../system/com.zig").BLOB;
|
|
const BOOL = @import("../foundation.zig").BOOL;
|
|
const BSTR = @import("../foundation.zig").BSTR;
|
|
const FILETIME = @import("../foundation.zig").FILETIME;
|
|
const HRESULT = @import("../foundation.zig").HRESULT;
|
|
const IClassFactory = @import("../system/com.zig").IClassFactory;
|
|
const IDispatch = @import("../system/com.zig").IDispatch;
|
|
const ITransaction = @import("../system/distributed_transaction_coordinator.zig").ITransaction;
|
|
const ITransactionVoterBallotAsync2 = @import("../system/distributed_transaction_coordinator.zig").ITransactionVoterBallotAsync2;
|
|
const ITransactionVoterNotifyAsync2 = @import("../system/distributed_transaction_coordinator.zig").ITransactionVoterNotifyAsync2;
|
|
const IUnknown = @import("../system/com.zig").IUnknown;
|
|
const PSID = @import("../foundation.zig").PSID;
|
|
const PWSTR = @import("../foundation.zig").PWSTR;
|
|
const SAFEARRAY = @import("../system/com.zig").SAFEARRAY;
|
|
const VARIANT = @import("../system/com.zig").VARIANT;
|
|
|
|
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);
|
|
}
|
|
}
|